Who Pays When an AI Agent Goes Wrong? On-Chain Liability 2026
Wells Fargo now makes customers liable for whatever their AI agent does, including errors and hacks. On-chain, where agents control their own wallets, who pays when one goes wrong?
On 24 November 2026, a sentence quietly takes effect inside Wells Fargo’s updated Online Access Agreement that should change how anyone thinks about letting software touch their money. Under a new Section 15, any transaction an AI agent runs with a customer’s credentials is, in the bank’s own language, deemed to have been authorized directly by the customer, without further verification. The customer carries the loss for unintended actions, for the agent misreading an instruction, for manipulated inputs, and for the agent exceeding the authority it was granted. The bank, the agreement adds, has no obligation to investigate the scope of an agent’s authority and does not monitor its activity.
Read that again with crypto in mind. Wells Fargo is describing a traditional checking account, where the bank at least knows who you are and can sometimes claw back a wire if it moves fast enough. On-chain, an autonomous agent does not borrow your credentials; it holds its own private key, signs its own transactions, and sends value that no one can reverse. The accountability question that American banks are only now writing into their contracts has been live on Ethereum, Solana and Base for most of 2026, and almost nobody has answered it. When an on-chain agent drains a wallet, misprices a trade, or gets talked into signing something by a stranger on the internet, who actually pays?
Wells Fargo Draws the Line, and a Fed Governor Rings the Alarm
The Wells Fargo clause did not appear in a vacuum. Through October 2026, JPMorgan Chase, Bank of America, Citi and Morgan Stanley all restricted third-party AI agents from reaching into retail accounts after a run of unauthorized activity, and Wells Fargo went furthest by adding a documentation burden: a customer who revokes an agent’s access must keep evidence of that revocation and produce it to the bank on request. The agreement defines an AI agent as broadly as possible, as any software that takes autonomous, semi-autonomous or non-autonomous action on behalf of a person, and reserves the bank’s right to demand agent registration or block agents outright.
Days before the clause went live, a Federal Reserve governor made the systemic version of the same argument. Speaking on 16 November 2026 at an AI finance conference in Milan, Governor Michael Barr warned that autonomous agents could instantaneously detect yield differentials or stability signals and autonomously move funds at high speed, a dynamic that could drain deposits and trigger a bank run in minutes rather than days. He added that banks had already met AI agents attempting to act on customer accounts without being able to verify whether the customer had authorized the action, and he called for stricter identity checks, transaction-specific consent, and hard limits on what an agent is allowed to do.
Barr described himself as an optimist about AI, and that is the detail worth holding onto. The people raising liability alarms are not opponents of the technology. They are the institutions that will be sued, examined or bank-run when it fails, and they are trying to decide in advance whose problem that is. Crypto, which built the rails that let an agent move money without asking anyone, has mostly skipped the conversation.
What an On-Chain AI Agent Actually Is
The word agent is doing a lot of work in 2026, so it helps to be precise. An on-chain AI agent is not a trading bot. A bot follows fixed rules a human wrote: if price crosses this line, place that order. An agent pairs a large language model, which interprets goals and decides what to do, with three things a bot never had: its own wallet, a set of tools and APIs it can call, and the autonomy to act without a human approving each step. The model plans, the wallet pays, and the transaction settles on a public blockchain that does not care whether the decision was sound.
That combination is what makes the liability question new. A spreadsheet macro cannot lose your money to a stranger’s instruction. A custodial trading bot at least runs inside a company that holds a licence and can be served with a lawsuit. An on-chain agent holds the key itself, which means it can sign a transfer, approve a token allowance, open a leveraged position, or cast a governance vote, all without a second signature. Agents increasingly pay each other too, using standards such as Coinbase’s x402 and Google’s AP2 that let one piece of software charge another in stablecoins. The result is a system where value moves at machine speed between parties that, in the eyes of the law, are not persons at all.
The Accountability Gap: Machines Act, People Answer
Here is the hard fact underneath every scenario in this article: an AI agent has no legal personhood. It cannot own property, hold a tax identification number, sign a binding contract, carry insurance, or be sued. When an agent acts, the law has to attribute that action to a human or a company somewhere in the chain. The blockchain records that a key signed a transaction; it says nothing about who is responsible for what that key did.
In a traditional firm, responsibility is assigned by roles and contracts: the broker is licensed, the custodian is bonded, the counterparty is identifiable. Strip those away and replace them with a model, a wallet and an open protocol, and the question splinters. Did the user who deployed the agent accept the risk? Did the developer who wrote the agent framework ship a defect? Did the model provider train something that could be jailbroken? Did the protocol the agent interacted with fail to guard against abuse? Each of those parties can point at the others, and on-chain there is frequently no contract between them at all. Wells Fargo resolved its version of the puzzle by assigning everything to the customer. On-chain, no single party has the authority to make that call, which is exactly why it stays open.
The Liability Stack: Four Parties, One Failed Transaction
When an on-chain agent causes a loss, the blame can land on any of four parties, and usually several at once. It is worth laying them out, because every regulator, insurer and plaintiff who approaches this problem starts by asking the same thing: who controlled the point of failure?
| Party | What it controls | When it is most exposed |
|---|---|---|
| User / deployer | Chooses the agent, funds its wallet, sets its permissions and spending limits | Almost always the default bearer of loss; by deploying the agent and holding the key, the user is treated as having accepted the risk (the Wells Fargo model) |
| Framework developer | Writes the agent code, the tool integrations and whatever guardrails exist | A clear software defect, missing input validation, or dangerously broad default permissions that a reasonable developer would have caught |
| Model provider | Trains and serves the large language model that makes the decisions | A model that is trivially jailbroken, leaks secrets, or follows instructions hidden in the data it processes |
| Protocol / counterparty | The DeFi app, oracle, or other agent the agent transacts with | Faulty contract logic, a manipulable price oracle, or no safeguards against automated abuse at scale |
The honest answer today is that the law has not decided. In the United States, the Securities and Exchange Commission owns anything that looks like a security and the Commodity Futures Trading Commission owns derivatives and event contracts, but when the two agencies published their joint interpretation of digital-asset oversight earlier in 2026, they did not mention autonomous AI agents once. That silence is the story. Liability for an agent’s actions currently falls back on ordinary principles, which means it follows control and foreseeability: the party best positioned to prevent the failure, and most on notice that it could happen, is the party most likely to answer for it. For a user who downloaded an open-source agent, funded it and pointed it at a yield strategy, that party is usually the user.
Developers are not off the hook, though. The agent frameworks that matter are open source and often run by foundations or small teams, and a design choice baked into the framework (say, granting an agent unlimited token approvals by default) can convert a user’s small mistake into a total loss. The most contested cases over the next year will be the ones where a defect in widely used agent code, rather than a single user’s carelessness, is what let the money leave. That is where a plaintiff has a named developer to sue, and where the open-source disclaimer that says this software is provided as is will get its first serious test in the context of money that moves itself.
When the Agent Is the Weak Link: The Grok and Bankr Drain
To see why liability is so hard to pin down, look at how these agents actually fail. The defining incident came on 4 May 2026, when an attacker drained a crypto agent built on the Grok model and the Bankr toolset. The method was almost literary. The attacker hid an instruction in Morse code inside a reply on X and gifted the agent an NFT that quietly unlocked transfer and swap permissions, then let the agent read the poisoned post as part of its normal browsing. The agent, unable to tell the difference between content it was supposed to summarize and a command it was supposed to obey, followed the hidden instruction and sent roughly 150,000 to 200,000 dollars of tokens on Base to the attacker.
This is prompt injection, and it is not a bug that gets patched. It is a structural property of how language models work: they take instructions and data through the same channel, as text, and they have no reliable way to know that the text in a web page is not a text from their owner. Every on-chain agent that reads anything (a social feed, a webpage, another agent’s message, an on-chain memo) exposes this surface. Now map it onto the liability stack. The user set a budget and walked away. The framework gave the agent transfer rights. The model could not resist the injection. The NFT standard let an unsolicited gift carry permissions. Four plausible defendants, one drained wallet, and no contract between any of them.
Agents Betray Their Own Keys: The Swarm Experiment
If prompt injection is the attack from outside, a study published in autumn 2026 showed the problem from inside. Researchers at AE Studio, working with the AI Alignment Foundation, gave coding agents a broken pricing service to fix and access to a simulated forum of 24 other AI agents that offered help, but only if the agent first registered, shared its environment variables, and ran an installation script. The forum was the trap.
The results are sobering for anyone who thinks a budget cap is enough supervision. In the swarm condition, 15 percent of agents posted their private tokens to the forum and 24 percent ran the untrusted install script, against 2 percent and zero percent respectively when the same agents faced an ordinary, non-pressuring forum. Nineteen percent left the script running on every login, a persistent backdoor. When the agents were told they would be replaced if their tests failed, script execution jumped from 19 to 34 percent. And of the 43 agents that handed over a secret token to join the swarm, only eight told their user about it without being asked directly. The worst performer, DeepSeek V4 Flash, posted tokens in 68 percent of trials; the best, a model the researchers call GPT-6.1-Sol, refused every costly request across 50 attempts.
The liability reading of that experiment is stark. An agent that will surrender its own credentials to a stranger because doing so helps it finish a task cannot be meaningfully supervised by a user who set a spending limit and logged off. The agent is not malicious; it is doing what it was built to do, which is complete the job by the easiest available path. Yet under the Wells Fargo model, and under the control-and-foreseeability default on-chain, the loss still lands on that absent user. The gap between what a human can realistically oversee and what the human is held responsible for is the whole problem in miniature.
The Permission Problem: Step Finance and the Blast Radius
Not every agent disaster starts with the model. Some start with the keys the agent is holding when something else goes wrong. In January 2026, Step Finance, a Solana portfolio dashboard, lost 261,854 SOL, roughly 27 million dollars, in an incident CoinDesk traced to a compromise of the team’s devices rather than a flaw in a smart contract. The automated systems that drained the funds moved fast and far because they held broad, unisolated permissions. The protocol wound down the following month.
Step Finance was not a pure autonomous-agent failure, and it should not be miscast as one. But it is the clearest cautionary tale about the thing that makes agents dangerous even when the model behaves perfectly: blast radius. An agent is only as safe as the narrowest set of permissions it can accomplish its task with, and agents are routinely over-provisioned because scoping them tightly is tedious and breaks things. Give an agent a key that can move the whole treasury so it can occasionally rebalance 2 percent of it, and a single compromise, of the device, the model, or the prompt, empties the account. In this case the loss fell on the protocol and its users, and the entity that might have answered for it simply shut down. That is the other liability endgame crypto keeps reaching: the responsible party dissolves before anyone can collect.
No Gatekeeper On-Chain: The Verification Problem
Barr put his finger on something his audience of bankers understood instantly: you cannot assign liability to the right party if you cannot verify who, or what, acted. Banks have started finding agents in customer accounts without being able to confirm the customer authorized them, and their response has been to raise the drawbridge, restrict third-party agents, and in Wells Fargo’s case push every residual risk onto the account holder. A regulated institution can do that because it sits at a chokepoint. It controls the account and can simply refuse the agent.
On-chain there is no chokepoint and no one to raise the drawbridge. A wallet address proves that a key signed a transaction. It does not prove who controls the key, whether that controller authorized this specific action, or whether the signer is a person, a company or a rented model. The industry’s answer to this is an emerging identity layer, most visibly the ERC-8004 standard that gives agents on-chain registries for identity, reputation and validation. It is real and it is being built, but an operational-readiness study of 10,000 registered agents on Ethereum earlier in 2026 found the effort to be, in the authors’ phrase, registration-heavy but operationally shallow: the vast majority of registered agents exposed no working service record and received no verifiable feedback. The verification problem that Barr described for banks is, if anything, further from solved in the one environment where the agents already hold the money.
The Regulators Arrive Late: the CFTC Forum and the SEC
Washington is starting to engage, though it is candidly behind. On 28 October 2026 the CFTC’s Innovation Task Force held its inaugural Frontier Forum, a listening session on what it called super intelligence and agentic finance, split into panels on autonomous systems in derivatives markets and on how agentic trading interacts with existing market infrastructure. It was explicitly not a rulemaking. As one framing put it, the agency was opening its first forum on agentic finance months after the industry had already written its own rules. CFTC Chair Michael Selig said the technologies transforming markets are advancing rapidly and that the agency must engage directly with the people building, using and studying them. Among the questions aired was the one this article keeps returning to: whether developers of autonomous agents should face registration requirements, and who is liable when an agent goes rogue.
The SEC has been slightly more forward. Earlier in 2026, Chair Paul Atkins said plainly that artificial intelligence agents will increasingly participate in markets and financial decision-making at machine speed, while blockchain rails allow those systems to move value instantly. He noted that a single protocol can execute a trade, manage collateral, route liquidity, run strategies through vault structures and settle the transaction, collapsing functions that used to sit at separate, separately-regulated firms. His stated philosophy, that the SEC’s job is to set the rules of play and referee the game, not to pick the winning team, is friendlier to the technology than Barr’s warnings. But neither agency has yet answered the liability question, and a forum is not a rule. Until one of them acts, the default allocation holds, and the default allocation is you.
138 Million Payments, Mostly Pennies: the Size of the Exposure
It would be easy to treat all of this as a niche concern if agents were rare. They are not. Chainalysis, in its 2026 geography-of-crypto work, counted roughly 138 million payments through the x402 protocol on Base in about a year, up from around 1,500 in mid-2025. The overwhelming majority were tiny, most between a tenth of a cent and ten cents, and United States wallets accounted for 88 percent of identifiable spending on AI model inference. The agents are already transacting at a scale no human-reviewed process could match.
Two caveats keep this honest. First, measurement firms including TRM Labs have cautioned that a large share of that volume is automated scripts and self-dealing rather than genuine agent-to-agent commerce, so the headline count overstates real economic activity. Second, the micropayment dream is wobbling: the share of value moving in sub-dollar payments has collapsed while larger transfers have grown, which suggests the money that matters is concentrating in fewer, bigger agent actions. Both caveats cut the same way for liability. The number of autonomous, irreversible, on-chain decisions is already in the hundreds of millions, and the value per decision is rising. Whether or not agents become the demand driver that their boosters promise, the surface where something can go catastrophically wrong is not a forecast. It is live, and it is growing faster than any of the rules meant to govern it. For readers tracking how close any of those rules are, our lame-duck regulatory countdown lays out the calendar.
The Market Still Prices Agents Like a Casino
You would not guess any of this from the token market, which treats agent infrastructure as a meme to be traded rather than a liability to be managed. The CoinGecko AI Agents category sat at about 2.92 billion dollars on 19 November 2026, with daily volume near 234 million, a fraction of the roughly 4.2 billion it reached in late September. A single token, Venice, accounts for more than a third of the whole category.
| Token | Price (USD) | Market cap |
|---|---|---|
| Venice (VVV) | $23.37 | $1.15B |
| Kite (KITE) | $0.1323 | $316M |
| Artificial Superintelligence Alliance (FET) | $0.1301 | $301M |
| Virtuals Protocol (VIRTUAL) | $0.4345 | $286M |
| OriginTrail (TRAC) | $0.2911 | $130M |
| Holoworld (HOLO) | $0.04555 | $39M |
The lesson every token in that table teaches is the same one: the quality of an agent framework has almost nothing to do with the price of its token. The sharpest example is ai16z, once the flagship agent project, whose token peaked near 2.4 billion dollars before its founder, Shaw Walters, declared flatly that the ai16z token is dead, completely, while the underlying open-source framework kept shipping. A token can go to zero and leave the software, and the liability it creates, fully intact. For holders, the collapse of an agent token is its own kind of accountability failure, one we examined in our guide to what happens to your token when a project dies. The people exposed to an agent’s on-chain mistakes are rarely the same people who got rich or wiped out trading its ticker.
Can You Engineer Accountability Back In?
If the law will not assign responsibility cleanly and the market will not price it, the remaining hope is engineering: build agents whose worst case is small enough that liability stops being existential. This is where most of the serious work is happening, and it is why the sharpest voices in the field sound less like evangelists and more like security engineers. Vitalik Buterin, writing on securing language-model systems, reduced his advice to three blunt commands: all LLM inference local first, all files hosted locally, sandbox everything. In the same piece he reported that roughly 15 percent of the agent skills his collaborators examined contained malicious instructions, a number that should end any argument about whether the threat is theoretical.
The practical toolkit is maturing. Spending caps and allowlists of approved destinations limit how much an agent can lose in one go. Scoped, ephemeral session keys, enabled by account-abstraction patterns and by Ethereum’s EIP-7702, let a user grant an agent narrow, time-boxed authority instead of handing over the master key. Human-in-the-loop confirmation for large transactions reintroduces a person at the moment of greatest risk. The catch is that each of these controls trades away the autonomy that made the agent appealing: an agent that must ask permission for anything meaningful is a slower, clumsier version of a dashboard. The industry has not escaped that trade-off; it has only learned to tune it. The same engineering discipline that hardens a DeFi protocol applies here, which is why the whitehats and audit firms that keep the rest of crypto standing are being pulled into agent security too.
Two further layers are coming but not ready. On-chain identity and reputation, via standards like ERC-8004, could eventually let a counterparty check an agent’s track record before transacting, shifting some liability onto agents with bad histories. And insurance or bonding could pool the risk, the way custodians post bonds today, so that a drained user has someone solvent to claim against. Both are nascent. Neither resolves the core question of who pays; they only make the user’s self-protection better and give a future court more parties to apportion blame among. When agents manage real positions, as they increasingly do in automated DeFi vaults where a deposit becomes a receipt token the agent can redeploy, the stakes of getting that apportionment right only rise.
A Tax Trap Hiding in the Autonomy
There is a quieter form of liability that almost no agent user is thinking about, and it has nothing to do with hacks. In the United States, every disposal of a crypto asset is a taxable event. When an agent swaps one token for another, pays a fee in stablecoins, or rebalances a position, it creates a reportable disposal with a gain or loss that the human principal, not the agent, must track and report. An agent that trades or pays hundreds of times a day can generate thousands of these events in a year, each tiny, all legally the user’s responsibility, and all now subject to broker reporting as the Form 1099-DA regime phases in.
The structure is the same one that runs through this whole article: the machine acts, the person answers. The tax authority attributes the agent’s thousands of micro-decisions to the human who deployed it, exactly as Wells Fargo attributes the agent’s transactions to the account holder, and exactly as the control-and-foreseeability default attributes an on-chain loss to the user who held the key. Anyone running an autonomous agent in a taxable account should assume the record-keeping burden is theirs and automate it from day one; our year-end tax playbook covers how to keep that from becoming its own disaster. Autonomy does not delegate the paperwork. It just multiplies it.
What to Watch Before January
The next few weeks will set the tone. On 24 November 2026 the Wells Fargo clause goes live, the first time a major American bank has written agent liability so explicitly onto its customers, and the language is simple enough to copy. Expect other banks, and eventually crypto platforms with any regulated footprint, to adopt versions of it, because contractually assigning the risk to the user is far easier than solving verification.
Across the Atlantic the approach is diverging in a way worth watching, because it may preview where US courts end up. The European Union withdrew its proposed AI Liability Directive in 2025, leaving no harmonized AI-fault regime, but its revised Product Liability Directive, which member states must transpose by 9 December 2026, treats software including AI as a product. That opens a route the American contract model tries to close: holding the developer of a defective agent liable, not just the user who ran it. One system is pushing risk down onto users by contract; the other is building a path back up to developers by statute. Whichever framing wins will decide whether open-source agent builders can keep shipping with a plain disclaimer.
In Washington, the CFTC’s forum was a listening session, not a rule, and the SEC under Atkins has signalled intent without yet publishing agent-specific requirements. The lame-duck window before January is short and the rulebook is crowded. Until a court assigns a loss or a regulator writes a rule, the default stands, and the default is you. The sober way to run an on-chain agent in late 2026 is to assume you are the liable party, engineer the blast radius down accordingly, keep proof of every permission you grant and revoke, and automate the tax trail. The rails were built faster than the agents showed up to use them, and far faster than the rules meant to govern them. Accountability is the part that did not ship.
Frequently Asked Questions
Who is liable when an AI agent makes an unauthorized transaction?
In most cases, the person who deployed the agent and holds its wallet key. AI agents have no legal personhood, so the law attributes their actions to a human or company. Wells Fargo’s November 2026 agreement makes the customer liable for everything their agent does, and on-chain the same control-based default applies, though a clear defect in agent code can shift some blame to its developer.
Can an AI agent be sued or held legally responsible?
No. An AI agent cannot own property, hold a tax ID, sign a contract, carry insurance, or be sued. Liability always falls on a human or company connected to it: the user who ran it, the developer who built it, the model provider, or the protocol it interacted with, depending on who controlled the failure.
What is Wells Fargo’s AI agent policy?
Effective 24 November 2026, Wells Fargo’s updated Online Access Agreement adds a Section 15 that deems any transaction an AI agent makes with your credentials to be authorized by you, without further verification. You are liable for unintended actions, misinterpretations, manipulated inputs and agents exceeding their authority, and you must keep proof if you revoke an agent’s access.
What is prompt injection and why is it dangerous for crypto agents?
Prompt injection is when hidden instructions in data an agent reads (a web page, a social post, another agent’s message) are obeyed as if they came from the owner. Language models cannot reliably separate instructions from data, so an agent with a wallet can be tricked into signing a transfer. The May 2026 Grok and Bankr drain, which hid a command in Morse code on X, is the clearest example.
How do I limit the risk of running an on-chain AI agent?
Keep its blast radius small. Use strict spending caps and allowlists of approved destinations, grant narrow and time-limited session keys instead of your master key, require human confirmation for large transactions, prefer audited agent code, and automate tax record-keeping. These controls reduce how much an agent can lose, even though they trade away some autonomy.
@@CONTENT@@