On October 29, an attacker moved about $6.36 billion out of Binance wallets across ten blockchains, most of it in roughly 20 minutes. It’s the largest crypto theft on record, and TRM Labs attributes it, with high confidence, to North Korea’s TraderTraitor. trmlabs
The number isn’t the lesson. The structure is.
On Ethereum, the attacker used an EIP-7702 delegation to turn a hot wallet into a sweeper, with 50 pre-signed authorizations prepared in advance. On the other nine chains, Binance wallets simply sent funds through ordinary signed transfers. Different chains, key types and signing schemes, and valid signatures for the attacker on all of them within about half an hour. TRM’s read is that the signing infrastructure itself was compromised. Binance hadn’t published a root cause when I wrote this, so that’s an assessment, not a verdict. trmlabstrmlabs
Read it as an engineer. A signing system that speaks for ten chains isn’t a quorum. It’s one very large node. And look at the 50 authorizations. The attacker couldn’t predict the wallet’s transaction count, so it didn’t try. It covered the whole range and let one land. That’s a human team already designing around unpredictability.
Now add a swarm
That was people, rehearsing for at least 36 hours. Picture the same operation run by agents. This is a projection, not a forecast. trmlabs
Rehearsal becomes continuous and parallel across every chain and signing path. Probing gets cheap enough to run against every vendor, approval flow and employee at once. The defender’s window, about 37 minutes before the first big stablecoin freeze in this case, shrinks toward zero. And the attacker doesn’t need to be right, just to cover the space, the way those 50 authorizations did.
The defenders will have agents too. That’s where it gets uncomfortable.
Gods are what we call systems we’ve given up predicting
In 1936 Turing proved that no general program can inspect another program and certify what it will do. Rice’s theorem stretches that to almost any behavior you care about: will it leak, will it sign something it shouldn’t. The word “general” matters, because you can still verify specific, well-structured systems. What you can’t have is a universal inspector. Wolfram’s computational irreducibility adds the other half: for many systems, the only way to know what they’ll do is to run them.
A model is a huge, irreducible computation, and a swarm of them interacting is more so. You won’t predict what a swarm does, on offense or defense. Any security strategy that depends on spotting bad behavior in advance, whether by reading prompts, scanning code, or trusting a model to police a model, is betting on the inspector Turing ruled out.
We do this every time something gets too complex to predict. Storms had gods, markets have moods, and models now have intentions. “It decided.” “It’s lying.” Those are agent words for mechanisms we can’t forecast. The engineering response is the opposite of worship: stop betting on the component, and design the system so the component doesn’t matter.
The blockchain world already learned this. Satoshi published nine pages in 2008, the network went live in 2009, and by 2011 he was gone, leaving a system that runs without its creator. That isn’t a god you pray to. It’s a god you don’t need. Stellar gets there with overlapping quorum slices. Ethereum caps execution with gas because it can’t know whether a contract will finish. Gas is the halting problem’s workaround.
Quantum is the same lesson on a slower clock
Every key in this industry is an identity, and the math behind those keys is what a large enough quantum computer running Shor’s algorithm could break. That machine doesn’t exist today, and the target is signatures, not mining. Some of the oldest coins sit behind public keys that are already exposed, and their creator can’t sign the migration.
NIST finalized post-quantum signature standards in 2024. The tools exist. What takes years is moving an industry onto them, and nobody can tell you the date the threat becomes real. That’s the same problem again: you can’t predict the timeline, so you build for it not mattering. The answer is crypto-agility, keys and algorithms you can swap without rewriting the system. It’s boring work, and it lands on whoever controls signing.
Why we moved from nodes to signatures
Blockdaemon started by running as many nodes as possible. Our direction now is to sign as many transactions as possible.
That’s not a pivot away from infrastructure. It follows where the risk went. A node tells the network what’s true. A signature tells it what to do. Nodes make the chain trustworthy, and signing makes an institution’s authority trustworthy. Binance didn’t lose money because nodes lied. It lost it because something valid signed what it shouldn’t have.
Both pressures converge there. AI agents act through keys, so a swarm attacks signing. Quantum breaks signing, and the migration happens in signing. If the future is unpredictable components, the control point is who can move value, under what policy, with whose approval. Institutions will pay to get that right.
What survives
No single signer. A quorum of independent parties, not one system that speaks for everything. Our vault splits keys into shares on nodes the customer controls, and a transaction signs only when the required quorum approves.
Independence that’s real. If your approvers run the same model, one exploit compromises all of them. Correlated failure is the biggest swarm risk, because it turns f=1 into f=n.
Authority separated by chain and wallet tier. TRM’s own advice after the hack is to separate signing infrastructure and approval paths this way. trmlabs
Policy outside the model. The agent proposes, a deterministic rule set or a human approves. You can’t audit the mind. You can audit the record and constrain the permissions.
A veto that isn’t the signer. Tether, Circle, Ripple and World Liberty Financial froze about $2.67 billion, because other parties with their own authority could say no after the signer said yes. The attacker still holds roughly $2.4 billion that no issuer can reach. trmlabstrmlabs
Revocation you’ve already tested, and keys you can migrate. Speed and algorithm change are both variables now.
We’ve operated blockchain infrastructure since 2017, and this is its oldest lesson. Nodes fail, operators make mistakes, and something will do what nobody expected.
You don’t predict the node. You design the quorum.
