Agents will need wallets: the convergence of money and machine intelligence

For a decade, "AI" meant something that told you things. The frontier now is AI that does things — books the travel, rebalances the portfolio, renews the contract, pays the invoice. And the moment an agent stops advising and starts acting, it walks into a problem that no amount of model quality solves. It needs somewhere to hold value, a rail to move it, and rules it is not permitted to break. It needs, in other words, a wallet — and the shape of that wallet is one of the more important and least-appreciated design questions in applied AI.

We wrote a broader piece on the emerging economics of agents that transact — the protocols, the players, the state of the market. This one is narrower and more opinionated: it is about why the wallet, specifically, is the surface where money and machine intelligence actually meet, and why bolting payments onto a chat window is the wrong answer.

The three things an agent needs, and a chatbot provides none of them

Strip the hype away and an economically active agent needs exactly three things:

1. Value it can access — held somewhere it can actually spend from.
2. A rail it can move on — with fast, final settlement, increasingly including regulated stablecoins for the small, constant, machine-speed payments that card rails handle badly.
3. Rules it must obey — permissions, limits, and revocability, so that "autonomous" never quietly becomes "unbounded."

That triple — value, rail, rules — is the definition of a modern wallet. It is emphatically not the definition of a chat interface. Which is why we think the interesting question, once agents can act, is not "which model?" but "which wallet?"

Why a non-custodial wallet is uniquely suited to the job

The same properties that make a non-custodial wallet good for a careful human make it good for a delegated agent:

• Programmable permissions. You can grant an agent a budget, a scope, and an expiry — spend up to this, on that, until then — and revoke it in a single move. Autonomy on a leash, which is the only kind anyone should actually want.
• Self-custody. The user holds the keys, so an agent acts within delegated authority rather than by handing some platform control of the funds outright. The difference between lending someone a key to one room and giving them the deed to the house.
• Auditability. Every action an agent takes is a signed, inspectable transaction, not an opaque instruction disappearing into a backend. When something goes wrong — and with autonomous systems, something eventually will — you can see exactly what happened and who authorized it.

Put together, the wallet turns "let the AI handle it" from a leap of faith into a bounded, revocable, auditable delegation. That is the entire difference between an assistant you can trust with money and one you cannot.

The layer underneath: identity and memory

There is a harder problem sitting below the mechanics, and it is the one most agent-payment demos skip: who is the agent acting for, and what does it remember? An agent that pays on your behalf needs a durable identity to act under and a memory of your intent, your limits, and your history — held privately, under your control. This is exactly the durable layer the group builds: one identity, one memory, owned by the user, that an assistant can reason over without any custodian ever holding the keys or the context. An agent with a wallet but no memory is a stranger with your credit card. An agent with a wallet and a private memory of you is something worth having.

Why this is a wallet problem, not a conversation problem

It is tempting to solve all of this by bolting a payment button onto a chatbot and declaring victory. But the trust, the permissions, the settlement, and the memory all live at the wallet layer, not the conversation layer. The chat is where intent gets expressed. The wallet is where intent becomes a safe, final, bounded action. Confuse the two and you get a system that is very good at talking about money and quietly dangerous with it.

As AI agents begin to transact, the wallet becomes the surface where money meets machine intelligence.

We build the wallet and the intelligence in the same group, on the same identity-and-memory backbone, for precisely this reason. When agents need wallets — and within a few years, quietly, many of them will — the money layer and the thinking layer should not be strangers introduced at the checkout.

This piece describes FTG's design thesis. Referenced products are in development; agent-payment infrastructure across the industry is early and in several cases pilot-stage.