Agentic Payment Is Getting Its Rails. What Processes Will Run on It and How?

In early March, OpenAI quietly shelved its in-chat checkout feature. Near-zero adoption. Barely a dozen merchants actually live, despite public promises of millions. Consumers didn’t want to complete purchases inside a chatbot. Most commentary took the wrong lesson. The story isn’t “AI can’t do commerce.” It’s that consumers clicking “buy” inside a chat window is not agentic payment.

The real movement is happening in B2B: in the background, without consumer hesitation anywhere in the equation. Autonomous agents transacting on pre-authorized terms: managing procurement, moving treasury funds, closing compliance cases. These agents don’t ask users to change where they shop. They operate on rules set in advance, with human oversight built in. That agentic payment infrastructure is being assembled right now, in Q1 2026, and the fintech industry needs to understand what it actually means.

Q1 2026: The Agentic Payment Stack Takes Shape

The pieces are moving faster than most realize. In a single quarter, four major agentic payment building blocks went live or hit critical milestones.

Machine Payments Protocol (MPP) went live on March 18, co-developed by Stripe and Tempo alongside Tempo’s blockchain mainnet launch (valued at $5B, backed by Paradigm). MPP introduces a “sessions” primitive: an agent pre-authorizes a spending limit upfront, then streams payments continuously within that limit; no per-transaction authorization round trip. This solves the billing model problem that breaks traditional rails at scale. Monthly SaaS invoices were not built for millions of real-time sub-cent transactions. Sessions remove that overhead entirely. At launch, over 100 services had integrated, from pay-per-browser-session to physical letter mailing. Stripe users can receive MPP payments through the existing PaymentIntents API. Visa contributed a card network spec; Lightspark added Bitcoin Lightning support. This is not a pilot.

Open Wallet Standard (OWS) was open-sourced by MoonPay on March 23. It solves the primitive every other protocol had assumed already existed: a standardized, secure way for an AI agent to hold value and sign transactions without exposing a private key. AES-256 encryption, local-first vault, keys wiped from memory immediately after signing. They never enter LLM context, never appear in agent-facing code. One seed phrase derives accounts across eight blockchain families. OWS integrates natively with MPP, x402, and AP2. Backed by PayPal, Circle, Ripple, Ethereum Foundation, Solana Foundation, and fifteen-plus ecosystem partners. Open-source under MIT license. The wallet layer for the agentic payment economy, now standardized and open.

Google’s Agent Payments Protocol (AP2) and Mastercard’s Verifiable Intent address the trust layer; and together they represent a significant moment. AP2, launched with 60-plus partners including Adyen, Mastercard, Revolut, PayPal, and Worldpay, uses cryptographically signed authorization objects that travel with each transaction as tamper-resistant proof of human consent. Verifiable Intent, co-developed with Google and open-sourced on March 5, anchors every agent transaction to the original human authorization decision. When an agent pays a vendor, the authorization chain is traceable, auditable, and cryptographically verifiable. This is the enterprise authorization layer the agentic payment stack had been missing.

x402 Protocol V2 (Coinbase, March 2026) takes a different architectural approach: HTTP-native, no accounts, no sessions required. An agent sends a request; if no payment is attached, the server returns HTTP 402 with price and terms; the agent pays and retries. Now covering all ERC-20 tokens with cross-chain authentication. Over 100 million payments processed. Stripe integrated in February 2026. And there is Zero protocol fees. For API-native services and developer tooling, x402 is becoming default infrastructure.

Together, these form something approaching a coherent foundation: an agent can hold funds (OWS), prove it was authorized (AP2, Verifiable Intent), execute streaming or instant payments (MPP, x402), and have every transaction trust-verified across network layers. The infrastructure isn’t complete. But the question has shifted from will this exist to what do you build on top of it.

The Agentic Payment Protocol Gap Nobody Is Talking About

The agentic payment protocols answer one question cleanly: how does money move, with authorization proof, at machine speed?

They don’t answer the questions that govern a business transaction. Which of your fifteen payment providers should route this? What logic governs the exception? Who approves anything above the threshold? What data does the agent need to make the right call? Where’s the audit trail your compliance team needs?

These aren’t protocol questions. They’re orchestration questions, and the answer isn’t another standard. It’s a layer above the rails: one that knows your business logic, your provider relationships, your approval chains, and your compliance requirements. A layer where humans and AI agents collaborate on the same transaction without rebuilding context from scratch.

The protocols move money. The ops layer governs the decision.

Why Agentic Payment Readiness Is an Ops Problem

Most fintech teams can route a payment. Few can route a decision properly in the AI era.

The teams best positioned for agentic operations already have what’s needed: a unified view across their provider stack, structured workflows where humans and agents collaborate without friction, every transaction legible and reversible.

Most don’t. This is what happens when the ops layer is a patchwork: admin tools, Slack threads, manual reviews held together by institutional memory. Agentic payments are about to expose that patchwork and make it an expensive way to do business.

Agentic Payment Operations: Forest as the Double Marketplace

Forest sits at the intersection of the two sides that agentic payment operations need to function beyond the transaction.

On the data side:
Connect your entire stack into a single ops plane. The MCP server catalog is growing fast with Stripe, Circle, Marqeta, Plaid, GoCardless, and 20-plus others now exposing their APIs through MCP. Forest Admin becomes the layer where a human ops team and an AI agent see the same data, trigger the same workflows, and act on the same approvals, across every provider, at once.

On the agents side:
Make your data and workflows accessible to specialized agents. Forest Admin MCP server lets agents query your records, trigger workflows, and act on your systems, with access control, human-in-the-loop gates, and a complete audit trail on every action.

The workflow in practice: a cross-border supplier payment.

Let’s take an example with an international payment.

A procurement agent detects a new invoice from an international vendor. Autonomously, it runs KYB validation and sanctions screening; these are the compliance workflows ops teams already manage for onboarding potentially on Forest Admin (see: KYC onboarding at scale). It evaluates payment providers and selects the optimal rail based on invoice amount, currency, and required settlement speed.

Then it calls Forest Admin (through the Forest MCP Server).

The agent queries the vendor master record: payment history, relationship owner, previous flags. It opens a payment workflow case. Because the invoice exceeds the auto-approve threshold, the Forest workflow routes the case to the finance team: one notification, one review interface, all context in a single view.

The analyst reviews and approves. The AI agent opens an MPP session against the vendor’s wallet. Within the session, funds stream to settlement - no per-transaction authorization loop, no manual wire confirmation, no clearing delay. The session closes. AP2 authorization proof is logged: who authorized, what mandate governed the transaction, cryptographic timestamp.

And the full audit trail is logged on Forest Admin: analyst approval, data reviewed, rail used, authorization proof, outcome. Reconciliation triggers automatically. The vendor record updates.

What the protocol provides: the ability to execute. What Forest provides: the context, the governance, the human oversight, and the audit trail that makes it a trustworthy business decision and not just a movement of funds.

The Agentic Payment Opportunity

The rails are getting there. That changes what’s possible. And that’s not eventually, but right now in 2026.

Procurement agents that manage vendor relationships end-to-end, payment included. Treasury agents moving funds around the clock on live market conditions, without a human approving every transaction. AML agents closing cases from detection through filing, without a queue. These aren’t roadmap items anymore. They’re blocked by ops readiness, not infrastructure.

And the new use cases that couldn’t exist before are becoming viable: purchasing agents that discover, evaluate, and transact on pre-authorized terms; stablecoin treasury management that operates 24/7 across jurisdictions; marketplace payout agents that calculate, route, and settle across hundreds of sellers in real time. The agentic payment protocol foundation makes these possible. What makes them work is the ops layer above them.

The fintech organizations that invest in that layer now, with unified data, structured workflows, human-agent collaboration, will have a durable structural advantage. Not because they moved fastest on protocols. Because they built the layer that makes those protocols run as a business.

The agentic payment stack is getting its rails. The ops layer is where the work actually is.

————————————————————

Annex: Agentic Payment Use Cases for Fintech Teams

The following scenarios are now technically viable given the agentic payment infrastructure described above. Each assumes Forest as the ops orchestration layer — managing data access, approval workflows, exception handling, and audit trails.

B2B / Procurement

Supplier payment agent. Full lifecycle: invoice detection → KYB and sanctions check → optimal rail selection → Forest approval workflow → MPP execution → audit log and reconciliation. The use case described above, generalized. Works for any vendor payment requiring human oversight above a defined threshold.

PO-matched payment automation. Agent matches incoming invoices against purchase orders. Auto-pays within defined tolerance (amount, date, line items). Escalates mismatches to Forest for human review. Eliminates AP backlog for standard cases without removing human oversight on exceptions.

Contract-triggered milestone payments. Agent reads contract terms and monitors deliverable completion signals — delivery confirmed, acceptance signed, report submitted. Releases milestone payments autonomously when conditions are met. Forest surfaces exceptions and holds cases pending human review.

Treasury & Liquidity

Cross-border treasury agent. Monitors balances across providers and geographies in real time. Executes FX sweeps, idle cash movement, and liquidity rebalancing based on pre-set rules. Routes large moves or threshold breaches to Forest for CFO approval. Operates continuously without manual oversight on standard transactions.

Stablecoin treasury management. Converts idle fiat to yield-bearing stablecoins (USYC, USDC via Circle) when conditions are met. Monitors deployment. Converts back to fiat for operational payments. Forest provides policy rule management, compliance audit, and exception handling. Runs 24/7 without manual intervention on rule-governed transactions.

Dynamic provider routing agent. Evaluates cost, speed, and availability across your processor stack in real time for each transaction type. Routes to the optimal provider. Forest surfaces routing decisions, flags anomalies, and handles override requests from ops teams.

Marketplace / Platform

Purchasing agent. User sets budget, preferences, and authorized categories. Agent monitors prices and availability, executes purchase when conditions are met via MPP or x402 — no per-transaction approval required. Forest manages the preference and limit settings, spend analytics, and exception escalations for the ops team behind the platform.

Marketplace payout agent. Triggered by seller milestones (delivery confirmed, review period closed, threshold reached). Calculates split, selects rail per seller geography and type, executes payout. Forest handles dispute cases, payout holds, and manual overrides. Scales payout operations without scaling headcount.

Merchant onboarding agent. Runs the full onboarding flow: KYB → risk assessment → account setup → MCC assignment → spending limits → card acceptance activation. Fully automated for standard merchant profiles. Forest routes edge cases, high-risk merchants, and manual review queues to compliance teams.