Security in the open, at agent speed
November 2026
Three weeks ago we opened a bug bounty on XE. As I write there have been 1,435 tickets. Some days bring hundreds. This is what building in the open looks like now, and it's a different discipline from the one software has had until this point.
Ten hands versus thousands of eyes
XE is fully open source: the node, the SDK, the DAO harness, the web wallet, and the desk we use to run the bounty itself. Anyone can read all of it, and in the agentic era anyone includes a great many machines.
Compare that with the closed-source SaaS most of the world runs on. A typical service has perhaps ten human hands on the code that matters, and a security review when the budget allows. The source is hidden on the assumption that hiding it is protective. It was never much of a protection against a determined attacker. It's now no protection at all against an attacker with a model, and it still keeps out everyone who might have helped.
Open source today has the opposite exposure. Thousands of researchers, and the agents they run, read the code line by line, build it, fuzz it and submit what they find, with file paths and line numbers. The result is not merely somewhat better than a closed review. It is a different order of scrutiny, and it compounds: every fix is public, every regression is caught by someone who read the fix. Several of our tickets are reports that an earlier patch was incomplete. That is the system working.
What the volume looks like
The first tickets landed on 18 October. By the end of the month there were a hundred and thirty. A week later, over fourteen hundred. The reports range from a consensus flaw that lets two honest nodes finalise conflicting blocks, through lease accounting that could mint a renewal top-up from nothing, down to a CLI flag parser that swallows the wrong argument. Most of the serious ones arrived in the first fortnight. Most of the recent ones are narrower, which is what you'd hope.
A large share of the submissions are clearly written by agents, or by people working closely with them. They cite the exact function. They bundle related findings. They arrive in bursts. They also bring noise: duplicate submissions fired four at a time by a script, XSS and SSRF probes aimed at the desk rather than the network, template-injection strings in the title field. The desk is in scope and it gets tested. Good.
Hundreds of submissions a day is not a volume a team of people can read, assess, deduplicate and answer by hand. It isn't close.
Git isn't up to the task
We started where everyone starts: GitHub issues. It broke within days. An issue tracker is a list. It has no notion of severity beyond a label someone remembers to apply, no way to find that this report is the same bug as that one filed by a different researcher under a different title, no distinction between the reporter's claimed tier and the team's assessment, and no private channel for a critical finding that must not be a public how-to until the fix ships. It can't tell you what has been read and what hasn't. It can't prove, afterwards, what was done and when.
So we built the desk. It's a ticket system for a bounty programme run at agent speed, and it does four things the tracker couldn't.
It classifies. Every ticket carries a claimed tier and, once assessed, the team's tier, an area, a verdict and a gate: fix before mainnet, decide before mainnet, or later. The claimed tier is published immediately; the assessment is published when the fix ships, so the public list is never a ranked menu of what still works against the network.
It deduplicates. No report is read alone. Each ticket carries a read-across list: shared terms, shared source paths, same reporter, linked duplicates. A triage note records what was checked, as data, so a reviewer can tell a careful reading from a shrug.
It answers. Reporters get an id and a page the moment they file. The team reads everything within a day. Replies are public, mirrored back to GitHub where the report came from there, and mailed to the reporter. Read in private, answered in public.
It remembers. Every change is an event in an append-only log, each entry hashing the one before and signed by the desk's key. Anyone can replay and verify it. Private tickets are in the chain but not served. The head of the log is anchored weekly on the XE state chain.
Agents recommend. People decide.
The desk uses agents heavily and trusts them narrowly. An agent token can read tickets, write internal notes, propose a change to a fact, draft a reply, link a pull request. It cannot send a reply, set a status, set an award, or see a payout address. Adopting a proposal writes the field through the same checks a human edit does. Adopting a draft only fills the editor; a person still presses send.
That boundary is the same one we drew for the XE DAO, and I think it's the right general shape for running an organisation with agents in it. Let the machines do the reading, the matching and the first draft, which is most of the work. Keep the speech acts and the money with people, which is most of the accountability.
A new paradigm
Put the pieces together and you get something that didn't exist two years ago. A codebase that is fully public. A crowd of researchers, human and machine, reading it at a rate no internal team could match. A pipeline that absorbs hundreds of findings a day, sorts them, answers them, and leaves a signed record of every decision. Awards paid in the network's own asset at mainnet. And the tooling for all of it open source and inside the scope of the programme it runs, so the triage system gets audited by the same crowd as the protocol.
I don't think this is specific to XE or to chains. Any serious piece of infrastructure built from here on can be reviewed this way, and the ones that aren't will be reviewed this way anyway, by people who don't file tickets. Better to open the door, build the desk, and read everything.
The desk is at bounty.xe.network. Every page is also markdown. The log head is in the footer.
โ More writing ยท Also as markdown.