Beyond checkout: The missing financial layer in the agent ecosystem

Agents can reason, recommend, and execute, but only to a certain extent. The next bottleneck is financial execution.

Over the past year, the agent ecosystem has made real progress. Tool standards are converging. Anthropic donated the Model Context Protocol (MCP) to the Agentic AI Foundation, which it co-founded with OpenAI and Block. Command Line Interface (CLI) has been gaining traction as the more token efficient way for agents to navigate product capabilities. Production agent tooling is maturing as a result, with OpenAI explicitly framing agents as systems that independently accomplish tasks on behalf of users. And much of the commercial energy has centred on agentic commerce, where Google and OpenAI’s recent work around protocols that facilitate product discovery, merchant integrations, and delegated checkout flows.

That progress matters. But it can also create a misleading impression of what "agent-ready" really means.

Today, many agents can already observe, reason, compare options, plan, and even prepare approvals. They can read invoices, identify likely payment timing, analyse marketplace disbursements, and choose between APIs or vendors. But when a workflow requires moving money, the system often falls back on a human. The bottleneck has moved from reasoning to execution.

The industry has focused first on discovery, orchestration, trust, and checkout. Those are foundational. But there's a deeper layer beneath them: what happens after an agent is allowed to act? Can it access a payment instrument? Can it use funds from the right wallet or account? Can it stay inside policy? Can it move money across the right rails? Can it recover from failure? And can it leave behind an operational record that finance teams can actually reconcile?

Helping a user choose what to buy is a solved problem. Helping an agent move money safely is not.

The execution gap

A useful way to think about this is to separate the five layers of agentic finance: observe, decide, authorise, execute, and reconcile.

Most current agent systems are advancing quickly through layers 1–2. Far fewer can authorise in a native way, or execute and reconcile reliably. The distance between recommendation and settlement is where most agentic workflows still fail.

Three places where agent workflows break

The table above shows where breakdowns happen in theory. Here’s what they look like in practice.

1. Cross-border supplier payouts

An agent can already do a surprising amount of work before money moves. It can parse the invoice, extract terms, check whether the payment is due, compare FX timing, and prepare the approval request.

Then the hard questions begin. Which rail should be used? Which entity should fund the payment? Does the beneficiary setup satisfy internal controls? Does the payment exceed a threshold? What happens if the transfer fails or is returned? How does the payment appear later in reconciliation?

Most of these workflows collapse back into manual handling.

2. Marketplace funds flow

An agent may be able to calculate what a seller should receive, identify reserve requirements, or flag suspicious edge cases. But that isn't the same thing as safely holding value, splitting funds, releasing money under policy, and maintaining a traceable record of what happened and why, and doing so compliantly under each region’s regulatory requirements.

The workflow isn't complete until money movement and post-transaction traceability are both solved.

3. Machine-to-machine commerce

An agent may be able to identify which data provider, compute service, or software/API is the best fit for a task. It may even be able to compare pricing and make the decision autonomously. But if it can't access an approved financial instrument, stay within spend policy, pay programmatically, and explain the spend later, the final mile still depends on a human operator.

What the financial layer needs to do

If we want agents to move from recommendation to real financial action, they need more than a clever interface or a better orchestration layer. The next phase of agent enablement requires a financial layer that gives agents governed access to real economic action. That layer has to do more than expose an API. It needs to combine several capabilities at once:

• Delegated authority: who the agent is acting for, and what it is allowed to do on that principal’s behalf. 

• Scoped permissions and policy controls: budgets, merchant restrictions, risk boundaries, and approval thresholds that let an agent act within defined limits.

• Access to programmable financial instruments: cards, wallets, stored balances, pay-in and payout rails, and cross-border money movement. 

• Post-action traceability: finance and operations teams need to understand what happened and why. Without this, even a successful agent-triggered transaction becomes operational debt.

When these capabilities work together, agents can move from recommendation to execution without falling back on a human. Without the full stack, they remain bottlenecked at the point of action.

Why the gap is widening

This is where I think the industry conversation is still too narrow.

Much of the current narrative around agentic commerce is really about checkout. OpenAI’s recent commerce work, for example, is centred on product feeds, merchant integrations, and a delegated payment flow in which payment credentials are scoped and tokenized for checkout.

That's a meaningful step forward. But it only addresses buying. It doesn't address the larger set of financially consequential workflows that businesses, platforms, and machine actors will want agents to perform.

The more successful agents become at reasoning and orchestration, the more visible this execution gap becomes. Progress at the top of the stack makes the missing middle more obvious. As protocols standardise and tools become easier to connect, more builders will discover the same thing: an agent that can recommend a payment is useful, but an agent that can carry out a governed financial action is transformational.

Teaching agents to move money is the next frontier

The first wave of agent infrastructure taught software how to see, reason, and use tools. The next wave will determine whether software can act with economic consequence.

Agentic financial execution includes approvals, wallets, cards, pay-ins, payouts, cross-border movement, and the controls that make those actions safe and usable in the real world. It applies to enterprise finance operations, to platform and marketplace infrastructure, and to machine commerce between software actors.

Enabling agents to access instruments, move money across rails, stay within policy, and leave audit-ready records is an underbuilt layer that requires regulated financial infrastructure. Airwallex is well-positioned to help define that layer because the problem sits at the intersection of AI interfaces and regulated financial capability. 

Airwallex already offers a Developer MCP aimed at coding assistants and agent environments. This allows developers to use the MCP server with tools like Claude Code, Gemini CLI, OpenAI Codex, Cursor, Replit, V0, and Lovable to build their own integration. 

As for capabilities, Airwallex’s product surface spans business accounts with multi-currency wallets, cards, yield, lending, payouts, pay-ins, billing, and spend. This means that all the capabilities that a finance controller expects to have are available in one single stack, with flexible enough interfaces (MCP, CLI, API, GUI) to support bringing your own model and deploying in your own IT environment, in a way that best suits your needs.

The market has not yet figured out what financially capable agents should look like. At Airwallex, we’re building the infrastructure to find out. If you're building agents that can recommend and orchestrate but still break at the point of payment, credentialing, settlement, or controls, we'd like to design the right financial layer with you.