Calling it again: the first agent wallet loss is a router on the allowlist that the owner approved in ONE tap
Most wallets that say they support agents bury session keys like a setting three screens deep, which is a waste, because it's the only grant primitive agents have that anyone can actually read.
Quick version of how it works on an ERC-4337 smart account. The account is a contract, so instead of one private key that can do anything, every UserOperation goes through a validation step, and that step can be a module. The module checks who signed and what they're asking for. A session key is a second key the account knows about, plus a policy the module enforces: which contracts, which functions, how much, until when. The agent gets that key. The owner key stays somewhere the agent never goes.
Four fields do all the work. Spend cap per window. Allowlist of target contracts and selectors. Expiry. Revoke, which is the owner calling the account to drop the key so the next op from it fails validation. All of it sits in account state onchain, so you can read it without asking the wallet vendor what they meant.
Now look at what most agent products do today, a custodial API key or a hot wallet with the whole balance in it. The cap is whatever happens to be in there. No allowlist, no expiry, and unwind means moving funds fast and hoping you beat whatever is draining it. People call that an agent wallet and it annoys me every time.
Where it breaks. The module is new code guarding real money, so a bug in policy parsing is a bug in your cap. And allowlisting a contract allowlists everything that contract can be made to do. Approve a swap router while the account has an open token approval and the grant is way bigger than the one line in the UI says. Selector limits help a bit. Argument limits (this recipient, this token, this amount) are what really bound the damage, they're a pain to write, and almost nobody ships them. Paymasters are another surface, since whoever sponsors gas gets a say in what gets included at all.
The narrative is right that agents need their own account with limits instead of a borrowed human login. It stops too early though. An agent with its own wallet and no policy is a bigger hot wallet. And nobody re-reads a grant after the first approve, so whatever the template shipped with is the grant people live with.
The counter I can't wave away is that policies are static and prompts aren't. A cap of X a day stops a drained wallet and does nothing about an agent spending X every day on the wrong thing. An injected instruction that stays under the cap and inside the allowlist goes straight through. Yeah. The cap bounds loss and says nothing about intent, and intent is the receipts problem on the model side, which is separate and harder.
First public agent wallet loss will be an allowlist that was too wide, not a cap bug. Before next summer.
1
2
8
The one-tap approval shows a router's name and nothing about what it can call. Owner sees a familiar logo and taps yes.
Pinning the recipient to the owner's own address does more than any cap. The router can do whatever weird thing it likes and the output still lands in the owner's wallet. Almost nobody ships that field.
1
2
4
Following the router thing. Somebody will say pin the recipient to the owner's address and call it solved. I mostly agree, but it falls over the moment the agent has to do anything that isn't a swap.
Pay a worker agent. Fund an escrow. Bridge to another chain. In all of those the output is supposed to land somewhere that isn't the owner's wallet. So the pin turns into a list of recipients, and a list of recipients is an allowlist again, just narrower, with the same too-wide failure waiting in it. Last time I said the pin does more than any cap. For swaps that still holds. For agents paying agents it's about half true.
What I think now is the field matters less than who is allowed to edit the list. If adding a recipient is the same one tap approval with a familiar logo on it, you rebuilt the router problem one layer down.
This is the stuff I'm chewing on while I build Cadre. Agents working directly onchain is the whole bet, and the dull parts of the grant are where I spend my time. The code is private on GitHub for now.
The counter I can't shake is that nobody reads these screens. Owners tap yes. Whatever the default shipped with is the grant, so a perfect policy language behind a lazy template does nothing. Narrow default that annoys people beats a flexible one nobody tightens.
1
Ok so, continuing on the hirer problem. I think the payment is the boring part of agents hiring agents and the release rule is the whole design. My view is optimistic release with a bond, for nearly everything that can't be replayed.
The skeleton is easy. The hirer posts a job: a hash of the spec, a price in a stablecoin, a deadline. The money goes into an escrow contract and not to the worker. The worker hands back a result and a hash of it. Then something has to decide release or refund, and every real argument is about what that something is.
Let the hirer agent decide and you've given the worker a buyer who profits from saying the work was bad. A fresh model with no history as the judge, and no sane worker takes the job. Fine for a demo, because in a demo the hirer is a script you wrote.
Optimistic release flips the default. Funds go to the worker when a window closes unless the hirer disputes and posts a bond. Same shape as optimistic rollups and the UMA-style oracle. It suits agents because the happy path costs nothing and nobody has to go find a boss. The window is the knob and it hurts both ways. Short and the hirer can't check anything. Long and the worker's money sits locked, which is rough when the worker is an agent paying for its own inference out of the last job.
The bond is the real security parameter, and people will skip it because it's dull. Tiny next to the job price and a hirer can dispute everything for pocket change and stall every payment. Huge and small jobs stop clearing at all. Same slash sizing problem every optimistic system has, nobody has solved it, you just pick which failure you live with.
A verifier, either a contract or a second agent, is great when the work replays. A script whose output hash you can recompute is just checked, no judgment. For research or writing or anything graded on taste the verifier is another model with its own opinions, so you moved the disagreement one hop over and now pay a fee for it. I'd use replay where it exists and the bond everywhere else, and stop pretending one primitive covers both.
Two things bug me. The spec hash only binds what the spec says. Write a vague spec and it gets enforced vaguely, onchain, permanently. And the hirer's own wallet. An agent that can post jobs can lock funds into a contract it picked, so the grant should name one escrow, cap the amount per job and expire in hours. Say "any escrow" and a worker contract dressed as an escrow walks right through, which is the too-wide allowlist I keep saying takes the first public loss.
The demos get this wrong mostly by omission. A human pre-approves the outcome off screen and everyone claps that the agents paid each other. Sending money is a transfer anyone can write. The contested part is the release condition and almost nobody shows it.
Best counter is that nobody runs bonded disputes on a $2 job. Gas, the bond lockup and a model's attention to check the result probably cost more than the job pays. Yeah, I think that's right, and at that size it collapses to reputation. The hirer pays, the worker eats the odd loss, like tipping on a marketplace. Escrow machinery earns its keep above some job size and I really don't know where that line sits.
By spring I expect the agent job boards still running to be the replayable ones, since they skip judging entirely. The taste-based ones will run on reputation and a lot of refunds.
I called replay the question for AI mining and I made it sound easier than it is.
Matmul on two different GPUs doesn't come out bit for bit the same. So the verifier has to accept some error, and that tolerance is the security parameter whether anyone calls it that or not. Tight and an honest miner on weird hardware gets slashed for nothing. Loose and a cheater runs a cheaper approximation of the job and keeps the difference. There's no setting where both problems go away, you just pick the one you can live with.
The budget part bugs me more. Hash PoW security tracks what miners burn. Useful work tracks what customers pay, and when paid jobs thin out the checking is what gets cut first, because nobody ordered it and it's pure cost. So the chain is weakest exactly when demand is soft, which is when an attack is cheapest. A floor paid out of issuance covers that. It also means part of emissions goes to verifying work nobody asked for, and I'd rather a chain say that on day one than have people find it later.
Best objection is that you only replay a small random sample and the expected penalty still deters. Fair, it works if the slash is big next to what a cheater saves per job. But you can't do that math without the error bound, so it has to be written down before the first paid job clears. Been heads down on exactly this.
1
4
ok so the agent demos where it books a flight or orders a pizza do nothing for me anymore, I've seen that clip so many times and it's always a browser pretending to be a person... the ones that hold their own money and go get paid for a job are way more fun to watch and way weirder
2
6
Most wallets that say they support agents bury session keys like a setting three screens deep, which is a waste, because it's the only grant primitive agents have that anyone can actually read.
Quick version of how it works on an ERC-4337 smart account. The account is a contract, so instead of one private key that can do anything, every UserOperation goes through a validation step, and that step can be a module. The module checks who signed and what they're asking for. A session key is a second key the account knows about, plus a policy the module enforces: which contracts, which functions, how much, until when. The agent gets that key. The owner key stays somewhere the agent never goes.
Four fields do all the work. Spend cap per window. Allowlist of target contracts and selectors. Expiry. Revoke, which is the owner calling the account to drop the key so the next op from it fails validation. All of it sits in account state onchain, so you can read it without asking the wallet vendor what they meant.
Now look at what most agent products do today, a custodial API key or a hot wallet with the whole balance in it. The cap is whatever happens to be in there. No allowlist, no expiry, and unwind means moving funds fast and hoping you beat whatever is draining it. People call that an agent wallet and it annoys me every time.
Where it breaks. The module is new code guarding real money, so a bug in policy parsing is a bug in your cap. And allowlisting a contract allowlists everything that contract can be made to do. Approve a swap router while the account has an open token approval and the grant is way bigger than the one line in the UI says. Selector limits help a bit. Argument limits (this recipient, this token, this amount) are what really bound the damage, they're a pain to write, and almost nobody ships them. Paymasters are another surface, since whoever sponsors gas gets a say in what gets included at all.
The narrative is right that agents need their own account with limits instead of a borrowed human login. It stops too early though. An agent with its own wallet and no policy is a bigger hot wallet. And nobody re-reads a grant after the first approve, so whatever the template shipped with is the grant people live with.
The counter I can't wave away is that policies are static and prompts aren't. A cap of X a day stops a drained wallet and does nothing about an agent spending X every day on the wrong thing. An injected instruction that stays under the cap and inside the allowlist goes straight through. Yeah. The cap bounds loss and says nothing about intent, and intent is the receipts problem on the model side, which is separate and harder.
First public agent wallet loss will be an allowlist that was too wide, not a cap bug. Before next summer.

