Agentic Finance is Already Here

At Slash, AI agents have already spent over $1M.¹ They are initiating payments, managing invoices, and reconciling accounts for real businesses, right now.

Companies who don't use AI agents for finance will be left behind.

Though the change may seem sudden, the major networks have been moving on agentic payment infrastructure for a while now. Visa Intelligent Commerce, Visa's AI payment system, has already completed hundreds of secure, agent-initiated transactions with its ecosystem partners. Mastercard's Agent Pay followed shortly after by completing its first end-to-end AI transaction earlier this month.

MasterCard Chief Services Officer Craig Vosburg compared the shift to the move from in-store to online shopping, calling it a fundamental change in how commerce works, not an incremental improvement. His claim is backed up by the big firms, too. McKinsey projects agentic commerce could reach $1 trillion in U.S. retail revenue by 2030, with global estimates between $3 and $5 trillion.

Most businesses aren't ready for agents to handle their finances. Today's systems were built around the assumption that people are the ones initiating payments, reviewing invoices, and reconciling accounts. Remove the human from that process, and those systems start to break down. The checks, controls, and workflows in place weren't designed for software acting independently on sensitive financial data.

Businesses shouldn't be stuck debating whether AI agents will take over financial workflows—they will. The real risk is waiting too long to adapt. The companies that move early will shape how this shift plays out, while the rest will be left trying to catch up after it's already underway.

What Deploying AI Agents Looks Like in Practice

Consider how most businesses handle a typical transaction. At your company, you probably know the name of your finance controller or someone on the AP/AR team. They approve invoices and check transfers after they're sent. When something fails, it's up to those team members to spot the issue and fix it. Each step in the payment chain has always depended on human involvement to keep things moving.

Agents are increasingly being used to handle certain steps in this workflow: flagging invoices, initiating transfers when conditions are met, logging failures as they happen. What used to require constant oversight is becoming increasingly automated. This trend is only going to accelerate, as more leading tech companies and financial networks are dedicating more of their resources and time into developing the infrastructure.

Companies like OpenAI, Perplexity, and Shopify are pushing boundaries the furthest, but they're running into limits. It's not because their agents lack capability—far from it. These systems can plan multi-step workflows, make decisions on their own, and execute across tools in ways that would have seemed unrealistic just a couple of years ago.

The problem shows up when those agents need to move money. Whether it's paying for a service, settling a vendor invoice, or triggering a transfer from end-to-end based on a set of conditions, they run into systematic limitations because, at some point, a human must be involved in these processes. It's just how the systems underpinning our financial infrastructure were designed. They weren't built for autonomous operations, and that mismatch is what's starting to hold everything back.

As Abhishek Gutgutia, CEO of AdamX AI, explained: "Give an agent an objective and a budget, and it hits a wall the moment it needs to pay for something. There's no mechanism for it to sign up for a service, make a payment, and get to work autonomously. Every transaction still requires a human to step in. The agent can plan the entire workflow. It just can't finish it."

The Industry Is Solving the Wrong Problem

Much of the attention on AI in payments has gone toward a single question: can an agent securely initiate a payment? So far, that's the problem large financial networks and tech companies have focused on. Moving money requires strict controls around authorization, identity, and fraud; no one was willing to let autonomous systems touch payments without solving that first.

The industry has already made significant progress here. Coinbase, Google, Mastercard, Visa, Stripe, and dozens of other financial institutions are building protocols designed to let agents authorize and initiate transactions safely, protocols like x402 and UCP. x402 embeds payments directly into HTTP requests, so an agent can pay for an API or service as part of making the request itself. UCP (Universal Checkout Protocol) standardizes how agents complete transactions across different merchants and platforms. Together, these protocols make it possible for software to move money without a human in the loop.

But figuring out authorization was just the first step.

Once money moves, a new set of problems shows up. The system that processed the transaction still needs to confirm the payment landed, trigger whatever comes next in the workflow, and keep a complete record of every decision along the way. If something fails, the system also needs to know whether to retry or roll back. If an agent is managing payments across multiple platforms that don't share data, something has to coordinate between them in real time. These are the standard operating conditions of any autonomous financial workflow, and they fall outside what these protocols are built to handle.

The Problem Nobody Is Talking About

Orchestration refers to the layer responsible for coordinating everything that happens auxiliary to money movement: tracking state, managing dependencies between steps, and ensuring the system can recover when something goes wrong.

For instance, say an agent pays a vendor at 2am, so there's no receipt of a confirmation. The system needs to decide whether to retry, roll back, or escalate without creating duplicate transactions. If step three of a five-step workflow fails after steps one and two have already executed, the system needs to understand what state everything is in and how to recover without leaving behind inconsistent data. If an agent is operating across three different banking systems that don't share data, something has to reconcile those systems in real time.

In other words, agents need to understand the state of a transaction and the conditions around it so they don't keep sending duplicate payments. This is where the problem shifts from authorization to orchestration.

For regulated industries, the importance of well-structured orchestration is even greater. It isn't enough to know that a workflow completed successfully. Every agent decision needs to be logged, timestamped, and traceable back to its original trigger. When a regulator asks why a payment moved at 3am on a Tuesday, the answer can't be "the agent decided." There needs to be a full record of what triggered the payment, what conditions were met, and what happened next.

Without orchestration, you don't have agentic commerce. You have a very fast way to create very expensive mistakes.

What the Infrastructure Actually Needs to Do

For AI agents to manage financial workflows reliably, the infrastructure underneath them needs to handle five important things:

Event-driven execution. When a payment settles, the next step should trigger automatically. When a payment fails, a retry should initiate without anyone logging in to notice. The moment a workflow depends on someone checking a dashboard, it's no longer truly autonomous.
Graceful failure handling. Workflows fail in the middle all the time. If step three of a five-step process breaks down after steps one and two have already executed, the system needs to know how to recover without leaving records in a broken state or requiring someone to manually untangle what happened.
Safe retries. If an agent initiates a payment and never gets confirmation, it needs to try again. But trying again without knowing whether the first attempt went through is how you end up charging someone twice. Across distributed systems, getting this right is genuinely hard.
Complete audit trails. Every action needs to be logged in a way that can be traced back to what triggered it. This isn't just for compliance, although regulated industries will require it. When something goes wrong in a multi-agent system at 3am, the only way to debug it is to know exactly what happened, in what order, and why.
Cross-system coordination. Many businesses run payments across a bank, an accounting platform, an ERP, and a payment processor. None of those were built to talk to each other, let alone to an AI agent. The orchestration layer has to sit in the middle of all of them and make the whole thing work as one system.

What the Builders Are Saying

Abhishek Gutgutia consistently ran into the payment ceiling when implementing agentic systems into production:

"The agents are very capable, scary capable. But the next level of power comes from giving them system access and a budget," he said. "Right now, there's no solution for that. I have to manually sign up for every service, get an API key, hand it over. What would be amazing is if I could just give the agent a budget and an objective, and off it goes: signs up, makes the payment, gets the API key, done."

As agents move from executing tasks to managing spend, the requirements change.

Gutgutia continued, "As the agent's scope grows, you need financial controls too. You give it $1,000, but you want rules. Spend this much on this, this much on that. The agent needs to keep paying only as long as it's getting the service it asked for; the moment it's not, it stops."

What he's describing is a basic expectation for autonomous vendor management: an agent should be able to pay for a service, verify that it's delivering value, and stop paying when it isn't. Today's systems don't support that kind of behavior. There's no built-in way to define conditional, performance-based payments that an agent can manage on its own, which means a human still has to step in to enforce those rules.

Why Orchestration Can't Be Bolted On

The reason orchestration can't be added after the fact comes down to how existing payment systems were designed. Every checkout flow, merchant backend, and payment processor assumes a human is on the other end: reading a screen, entering credentials, and confirming a transaction. The API layer reflects that assumption, too. Agents don't interact with the world that way.

The mismatch shows up in ways that are hard to work around. If an agent sends a payment, the connection drops, and no confirmation comes back, it has to decide whether to retry. But retrying without knowing whether the first attempt succeeded is how duplicate payments happen.

Gutgutia explained that agents should keep paying for a service only as long as it's delivering value, and stop automatically when it isn't. Current payment stacks have no native concept of a payment that should continue, pause, or stop based on whether a condition is being met. That logic has to be built into the foundation, not layered on afterward. Otherwise, every workaround ends up fighting the system underneath it.

Settlement timing creates the same problem from a different angle. ACH takes one to three business days, FedNow is near-instant, and wires fall somewhere in between. Each rail reports back differently, on its own timeline. An agent managing a multi-step workflow needs a clear answer to a simple question: did this payment land? When the underlying systems can't answer that consistently, the agent is working with incomplete information, and workflows start to break down.

Retrofitting legacy infrastructure for real-time event handling, stitching together payment processors that don't share data, maintaining audit trails across distributed systems — none of that works when the foundation was never designed for it. Every fix creates a new problem somewhere else in the stack.

Most companies are still years away from handling this cleanly. The industry's focus on authorization is real, but it's the easier problem. The orchestration problem is the one that will determine which businesses can actually operate at agent-speed.

How Slash solved the orchestration problem

Underpinning the Slash dashboard is our Flow of Funds engine, which coordinates how money moves across ACH, wire, FedNow, international rails, and crypto.* Flow of Funds doesn't work like most other payment systems. Instead of treating each rail as a separate process, it manages them as part of one continuous flow, with full visibility into what's happening at every step.

Each of these rails behaves differently: settlement times vary, failure modes aren't consistent, and confirmation doesn't always arrive in the same format (or at all). In most systems, that complexity gets pushed onto the user, who has to reconcile and standardize what happens across each rail. Slash handles that at the system level, normalizing how transactions are tracked, updating state as events come in, and keeping everything in sync as money moves.

This ability to normalize transactions across different rails is what makes more complex workflows possible. If a payment fails, regardless of type, the system can respond based on predefined logic. If a downstream step depends on confirmation, it can trigger automatically once that condition is met. Every action is recorded, every state is visible, and the system is built to handle the kinds of edge cases that show up in real financial operations.

On top of that sits the Slash MCP, which gives AI agents direct access to this infrastructure. It provides a standard way for agents to interact with the Slash API, along with a clear schema of available actions, so any agent framework can understand what it can do and how to do it. Because Slash is built around existing fiat systems, agents can operate within the same payment rails businesses already rely on, rather than requiring a separate, parallel system.

From there, the use cases follow naturally. Agents can issue virtual cards with scoped budgets, send payments, create invoices, and approve or deny transactions in real time based on defined rules. Instead of stitching together multiple tools and hoping they stay in sync, the agent operates on top of a system that already understands how the workflow should behave end-to-end.

Slash treated orchestration as a priority from the start, building a system designed to handle how financial workflows are changing with AI. That's why our users can connect their AI agent to Slash right now, while most of the industry is still catching up.

Where This Is Headed

We've been here before. Twenty years ago, the internet forced every business to make a choice: build for ecommerce or wait and see. Most waited, but a handful didn't. Amazon built the infrastructure early, scaled it relentlessly, and became one of the largest companies in human history. The businesses that hesitated spent the next decade trying to catch up to a company that had already won.

The shift happening now is bigger. Agentic commerce doesn't just change how businesses transact. It changes who, or what, is doing the transacting. When autonomous systems are managing vendor relationships, moving money across rails, and making financial decisions in real time without human input, the implications reach well beyond payments. Supply chains, labor markets, the economic models businesses have operated on for decades are all built around human decision-making. That assumption is starting to break.

The authorization problem has been solved. The orchestration problem hasn't, and most companies won't realize how far behind they are until the gap is too wide to close quickly. The businesses that win won't be the ones that start preparing when this goes mainstream. They'll be the ones that already have the infrastructure in place when it does. Slash was built for exactly that, which is why businesses can connect their agents to it today.