Flair BuchiMiracle Okonkwo

WritingJune 2026

What Happens When an AI Agent Gets Access to Money?

Giving a model access to a payment API is relatively straightforward. Deciding what happens before that API is called is much harder.


The moment an AI agent can move money, the definition of an “assistant” starts to change. A normal assistant can tell you your balance, explain a transaction, or help you find the right option in an app. An agent can go further: it can interpret what you want and then take an action on your behalf. When that action is financial, the system is no longer just generating information. Something real can happen as a result of what it decides to do.

I've been thinking about this while building Xpend. One of the things that has made the project interesting to me is that the useful part of an agent isn't really the conversation. The useful part is what happens after the conversation. If I can tell a system that I want to pay a bill, send money, buy something, or complete another financial task, the value is in removing the friction between that intention and the eventual outcome.

With a chatbot, a bad answer is mostly a conversation problem. With software that can move money, I keep coming back to a harder question: how much authority should the software have? Giving a model access to a payment API is relatively straightforward. Deciding what happens before that API is called is much harder.

The model shouldn't be the bank

An LLM is good at interpreting language. People are not particularly good at expressing structured instructions, either. We say things like “send John what I owe him” or “take care of my electricity bill,” and expect software to understand what we mean. That's where an agent is useful. It can turn an ambiguous human request into something more concrete: figure out which capability is relevant, ask for information it doesn't have, and prepare an action. The model is doing something computers have historically been bad at: translating messy human intent into a form software can work with.

But understanding intent and authorizing a transaction are different problems.

That distinction became increasingly obvious to me as we built Xpend. If an agent decides that a payment is what the user meant, that shouldn't automatically mean the payment is authorized. The system still needs to establish what is being paid, from where, for how much, and whether the action is permitted under the user's current controls. The model can participate in that process. It shouldn't own the process.

It is an easy distinction to lose when building an agent. The temptation is to give the model a collection of tools and let it figure out the rest. The demo looks impressive because the model appears to “do everything.” The engineering problem begins when you have to decide what happens when it gets something wrong. Financial software doesn't get to treat every mistake as another conversational turn.

Autonomy needs boundaries

I've also stopped thinking about autonomy as a simple yes-or-no property. An agent can be autonomous in one context and require approval in another. It can read information without asking permission, prepare an action without executing it, or execute certain actions automatically while requiring confirmation for others. That seems like a much more useful way to think about agent permissions.

Consider the difference between checking a balance and moving money. Both can be exposed as tools to an agent, but they clearly don't carry the same consequences. Even two money movements can be very different depending on the amount, destination, context, and what the user has previously authorized.

What I care about more is what this particular agent should be autonomous to do. Once you ask it that way, autonomy looks less like a property of the model and more like a property of the system around it. The agent can understand the request, the application can decide what is allowed, the user can confirm when confirmation is required, and the transaction system can execute the action. Those are different responsibilities.

There has to be a point where intent becomes an action

One of the design problems I find most interesting is the boundary between preparation and execution. Imagine someone says, “Pay my electricity bill.” There is a surprising amount hidden inside that sentence. The system may need to determine the provider, identify the relevant account, retrieve the amount, select a source of funds, and prepare the payment. None of those steps necessarily mean that money should move.

That gives you a useful intermediate state: the system understands what the user wants and has prepared what it believes is the appropriate action, but the irreversible part hasn't happened yet. That state matters because it creates a place for the rest of the system to do its job. If confirmation is required, the user can see what is about to happen before it happens. If the request is outside the user's permissions, the system can stop. If information is missing, the agent can ask for it. If something doesn't make sense, the system can leave the action unresolved rather than inventing an answer.

The agent doesn't have to turn every conversation into an execution. Sometimes the correct outcome is to stop.

“I don't know” is an important state

This is another difference between conversational AI and financial software. For a chatbot, uncertainty is mostly a quality problem: if it misunderstands you, you correct it and continue. For a system that can take financial actions, uncertainty becomes a control problem.

Suppose the agent isn't sure which account you meant. Or it has enough information to prepare a payment but not enough to establish that it is authorized. Or an external provider hasn't given the system enough information to know whether an operation actually completed. The system needs somewhere to put those situations. It cannot always be yes or no. Sometimes it has to be not enough information yet.

Uncertainty should be an explicit system state, not something the model hides or improvises around. We shouldn't optimize agents to complete every request. We should optimize them to make useful progress while knowing when they shouldn't continue, especially when the consequences of being wrong are difficult to reverse.

The interesting engineering isn't all inside the LLM

There's a tendency to talk about agents as if the model is the system. It isn't. The model is very good at some parts of the problem: interpreting natural language, reasoning about a request, choosing between available capabilities, and communicating with the user. But authorization, transaction state, execution, reconciliation, and failure handling still need deterministic systems around it.

This is why I find agentic financial software more interesting than simply putting a chat interface on top of an existing product. The conversational interface is only the visible part. Underneath it, you still need a financial system that knows exactly when something has happened and what state it is in.

You don't want “confirmed” to be a concept that exists only in a conversation. You don't want an available balance to change because a model believes a transaction probably succeeded. And you don't want the model to be able to redefine the rules under which it is allowed to spend someone's money. The LLM can make the system easier to use. It shouldn't make the underlying financial state less reliable.

Removing the interface doesn't remove the complexity

Traditional financial applications ask the user to understand the application's structure. If I want to pay a bill, I find the bill-payment section. If I want to transfer money, I find transfers. I fill in the fields and submit the form.

An agent changes that relationship. I can simply describe what I want and let the software figure out which part of the system needs to handle it. That's a much better interface for many tasks. But the complexity hasn't disappeared; we've moved it. Instead of asking the user to understand the application's structure, we're asking the software to understand the user's intention. And once the software can act on that intention, we need to be much more deliberate about the boundaries around those actions.

Natural language can make the interface simpler without making the system simpler. In some cases, it makes the system considerably more complicated.

Money is just the beginning

The same problem exists beyond financial software. An agent that can send an email can cause something to happen outside the system. An agent that can change infrastructure can create consequences that are difficult to reverse. An agent that can purchase something, publish something, or modify data has crossed the same conceptual boundary.

Once software can take consequential actions, capability alone is not enough. The system still needs enough structure around that capability to know when it should act, when it should ask, and when it should stop. That means authority, constraints, preparation, execution, confirmation, and uncertainty have to be designed into the product, not left as conversational improvisation.

Building Xpend made the problem concrete

When we started building Xpend, the appeal of an agent was straightforward: make financial actions feel closer to the way people naturally ask for things. But once software can sit between a person's intention and a financial transaction, the product becomes about more than conversational UX.

You have to decide where authority lives, what the agent can prepare and what it can execute, when a person needs to confirm something and what exactly they are confirming, and how to design the system so that uncertainty doesn't quietly become authorization. That work matters more to me than chasing more autonomy for its own sake.

I don't think the goal should be to give software unrestricted control over money. I think the goal is to make software capable of doing much more on our behalf while keeping the boundaries around consequential actions explicit, understandable, and enforceable.

That's the problem I'm interested in building. And we're still very early in figuring out what the right answer looks like.