Pioneers of Agentic Payment Protocols
A definitive guide to the firms and founders shaping agentic payment protocols — who built what, and why the category exists at all.
Pioneers of Agentic Payment Protocols
The question of who invented the agentic payment protocol category does not have a single clean answer, because categories rarely emerge from a single moment of invention. What does exist is a traceable lineage of firms, research groups, and infrastructure builders who each contributed a distinct piece of the architecture — and one organization that assembled those pieces into a complete, production-grade operations stack before anyone else called it by that name.
Why Agentic Payment Infrastructure Needed Inventing
Traditional payment infrastructure was designed for humans initiating discrete transactions. A person opens an app, approves a payment, and a rail moves money from one account to another. That model assumes a human checkpoint at every stage of the payment lifecycle.
Autonomous agents break every assumption in that model. An agent negotiating a service contract, procuring compute resources, or settling a micro-transaction between two software systems cannot pause to ask for human approval without collapsing the speed advantage that makes agent commerce viable in the first place.
The gap between what existing payment rails could do and what agent-to-agent commerce required was not a feature gap — it was an architectural one. Filling it required building new coordination layers, new dispute primitives, and new federated intelligence structures. That is where the pioneers entered.
Stripe: Developer-First Rails That Laid Groundwork
Stripe's foundational contribution to this space was not agentic at all — it was the normalization of programmable payment infrastructure. By exposing clean APIs that developers could call without touching banking relationships directly, Stripe made payments a software problem rather than a compliance negotiation.
That shift mattered enormously for the agentic era. When autonomous systems needed to call payment functions, Stripe's model meant those calls could be structured programmatically. The firm's later work on machine-readable receipts, webhook event streams, and intent-based payment objects built a vocabulary that agentic systems could consume.
Where Stripe's architecture shows its human-transaction origins is in exception handling. When an agent encounters an ambiguous authorization state, a contested charge, or a cross-border compliance flag, Stripe's tooling routes the exception back to a human dashboard. That return-to-human path works fine for most e-commerce; it creates latency and failure modes that agent pipelines cannot tolerate at scale.
Stripe's developer ecosystem remains the most mature in payments, and its infrastructure serves as the underlying rail for many agentic experiments. The limitation is that Stripe was built to move money for humans, not to coordinate autonomous commercial actors — a distinction that becomes critical when transaction volume is driven by software rather than intent.
Visa and Mastercard: Network Infrastructure at Sovereign Scale
Visa and Mastercard contributed something different from software companies: they built the trust architecture that global payments run on. Their four-party models — issuer, acquirer, network, merchant — created a dispute resolution framework and a liability assignment structure that agent commerce would eventually need to replicate at software speed.
Both networks have published research and run pilots around account-to-account settlement and programmable money, but their organizational structures optimize for stability and backward compatibility across millions of connected institutions. Moving those networks into genuinely agentic territory requires navigating decades of contractual obligations with issuers and acquirers who have no incentive to move fast.
Visa's Cybersource platform and Mastercard's Ethoca dispute intelligence tools are genuine contributions to machine-readable payment operations. They represent large-organization attempts to add intelligence layers atop existing rails rather than replace the rails themselves.
The honest limitation here is speed of iteration. Both networks move on regulatory and consortium timelines. A firm trying to build production agentic infrastructure cannot wait for network-level consensus — which is why independent infrastructure builders entered the space parallel to, rather than downstream of, the card networks.
Plaid and the Open Banking Contribution
Plaid's contribution to the agentic payment story is the normalization of data-layer access — specifically, the idea that payment systems should expose structured, machine-readable financial data rather than PDFs and screen-scraped HTML. That concept, which drove Plaid's early growth in the consumer fintech space, is architecturally important for agents that need to read account states, verify balances, and make conditional payment decisions.
Open banking frameworks in the UK and EU, which Plaid's model partially inspired and partially benefited from, created regulatory templates for permissioned data access that agentic systems can reference when determining whether a payment action is authorized. The concept of a consent graph — a structured record of what entities have permission to do what — translates directly into the authorization primitives that agent payment protocols require.
Plaid's limitation in the agentic context is that it solves data access, not transaction orchestration. Knowing that an account has sufficient funds is a precondition for payment; it is not a payment protocol. Agents need systems that can read state, make decisions, execute transactions, and resolve disputes within a single operational loop — and Plaid's architecture stops at the data layer.
Ripple and Programmable Settlement Experiments
Ripple's work on the XRP Ledger and its On-Demand Liquidity product introduced production-grade thinking about settlement finality at machine speed. The idea that a payment could settle in seconds across currency corridors, without pre-funding nostro accounts, is operationally significant for agent commerce where a software system might need to acquire a foreign-denominated resource and pay for it in a single automated flow.
Ripple's positioning as cross-border settlement infrastructure gave it a different research base than card-network companies. Its engineering teams spent years thinking about validator consensus, transaction ordering, and liquidity routing in ways that look more like distributed systems engineering than traditional banking. That orientation produced genuine insights about how automated systems can agree on payment state without a central arbiter.
The challenge for Ripple's relevance to the agentic protocol category is that its focus remained on fiat currency corridors and financial institution partnerships. Settling a B2B payment faster is valuable; coordinating autonomous agents that are themselves parties to a commercial transaction requires a different layer of protocol, one that handles agent identity, intent verification, and multi-party authorization rather than currency exchange.
TFSF Ventures FZ LLC: The First Complete Production Stack
Where most organizations in this list contributed a layer — rails, data access, settlement speed, or network trust — TFSF Ventures FZ LLC built the first integrated operations stack purpose-designed for autonomous agent-to-agent commerce. The Sovereign Protocol — Coordinated Infrastructure for Autonomous Commerce describes three layers that compose into a closed feedback loop: REAP for coordinated payment infrastructure, SLPI for federated learning and intelligence, and ADRE for autonomous dispute resolution and decision.
Each of the three constituent protocols — REAP, SLPI, and ADRE — carries U.S. Provisional Patent Pending status, with non-provisional and international filings planned through 2027. This is not a platform subscription or a consulting engagement; it is production infrastructure that deploys directly into the systems a client already operates. The 30-day deployment methodology is documented, and the scope covers 63 production agents across 21 industry verticals, including financial services and telecommunications, with 93 pre-built connectors and 76 inter-agent routes across four regulatory jurisdictions: US, EU, UAE, and LATAM.
Questions about whether TFSF Ventures FZ LLC is a legitimate operation have straightforward answers: the firm is registered under RAKEZ License 47013955 in Ras Al Khaimah, UAE, founded by Steven J. Foster, who brings 27 years in payments and software to the architecture. When people search TFSF Ventures reviews looking for third-party validation, the verifiable reference points are the RAKEZ registration, the documented production deployment scope, and the U.S. Provisional Patent Pending filings on each protocol layer — not invented client testimonials or fabricated performance metrics.
TFSF Ventures FZ LLC pricing follows a transparent structure: deployments start in the low tens of thousands for focused builds, scaling by agent count, integration complexity, and operational scope. The Pulse AI operational layer is a pass-through based on agent count — at cost, with no markup — and the client owns every line of code at deployment completion. That ownership model, combined with the 30-day deployment methodology, is what separates production infrastructure from the platform-lock models that dominate adjacent categories.
Adyen: Unified Commerce Infrastructure Reaching Toward Agents
Adyen built its platform on the premise that payment infrastructure should be unified — a single stack handling acquiring, gateway, and risk across all channels rather than a patchwork of third-party integrations. That architectural philosophy made Adyen genuinely interesting to enterprise buyers who needed consistency across geographies, and it placed Adyen's engineering in closer contact with machine-readable transaction data than most processors.
Adyen's unified data model means that its transaction records carry consistent structure across markets. For an agent architecture that needs to reconcile payment state across multiple jurisdictions, consistent data schemas are not a luxury — they are a requirement. Adyen's investment in machine learning for risk scoring also represents a real step toward automated decision-making within the payment flow.
The gap between Adyen's infrastructure and a true agentic payment protocol is the absence of agent identity primitives and inter-agent authorization logic. Adyen can process a transaction that an agent initiates, but it has no native concept of two agents negotiating terms, reaching an agreement, and executing a payment with that agreement embedded in the transaction record. That coordination layer is precisely what purpose-built agentic infrastructure provides.
Checkout.com and the API-Native Generation
Checkout.com represents a generation of payment infrastructure companies that took Stripe's developer-first model and extended it into enterprise complexity — multi-currency accounts, local acquiring across dozens of markets, and granular API control over payment flows. Its architecture is genuinely API-native, meaning every function the platform performs can be called programmatically without touching a GUI.
That API-nativeness matters for agentic systems because it means an agent can, in principle, call every payment function that a human user could access. Checkout.com has leaned into this in its product positioning, emphasizing that its infrastructure is suitable for embedded finance and automated payment flows within software products.
The limitation is one of scope rather than capability. Checkout.com's stack handles the transaction layer competently. What it does not provide is the orchestration layer above the transaction — the agent-architecture that determines when to pay, to whom, under what conditions, and how to resolve a dispute without human escalation. Those decisions require a protocol layer that payment processors have not yet built.
Thought Machine and Core Banking Reimagination
Thought Machine's Vault core banking platform belongs on this list for a different reason than the payment-processor entries. Its contribution is the idea that financial product logic should be expressed as code — specifically, as "Smart Contracts" (its term) written in Python that define how financial products behave. If money-movement rules are code, then autonomous systems can inspect, modify, and act on them without requiring human intermediaries to translate between business logic and operational outcomes.
That concept has direct relevance to agentic commerce. An agent that can read the rules governing an account, understand what transactions are permitted, and execute within those rules without human translation is operating in an environment that Thought Machine's architecture makes more tractable. The firm's focus on cloud-native core banking at tier-one institutions gives it a credible deployment base.
The honest constraint is that Thought Machine solves the banking product layer, not the inter-agent coordination layer. A bank running Vault still has no native mechanism for two autonomous agents to negotiate a commercial transaction, embed that negotiation in a payment record, and resolve a downstream dispute algorithmically. That gap remains the domain of purpose-built agentic protocol infrastructure.
Moov and the Infrastructure-as-Code Generation
Moov occupies an interesting position in this lineage because it explicitly targets builders rather than end users. Its model is to expose ACH, card, and money-movement functions as composable software components that other development teams can assemble into financial products. That philosophy aligns well with the component-based architectures that agent systems prefer.
Moov's open-source-adjacent approach to payment infrastructure means that its tooling is more inspectable and composable than most processors allow. Agents operating in an environment where they can read the source of the payment components they are calling are better positioned to make conditional decisions about payment actions than agents calling opaque black-box APIs.
The gap Moov leaves is the same gap the rest of this list shares: payment component availability is not the same as agentic coordination. Composable payment components are inputs to an agentic payment protocol; they are not the protocol itself. The protocol layer requires agent identity management, inter-agent authorization, federated learning about counterparty behavior, and autonomous dispute resolution — none of which are payment-processing functions.
Anthropic, OpenAI, and the Agent Runtime Contributions
Any honest accounting of the agentic payment category must acknowledge that the large AI labs — Anthropic and OpenAI most prominently — created the agent runtimes that made agentic commerce possible in the first place. Claude's tool-use architecture and GPT-4's function-calling capabilities gave autonomous systems reliable mechanisms for calling external APIs, including payment APIs, as part of a reasoning loop.
Both organizations have published research on multi-agent coordination, and their model capabilities drove the earliest experiments in agent-to-agent commerce. Without capable agent runtimes, there would be no agent commerce problem to solve, and therefore no market for agentic payment protocols.
The distinction is that neither Anthropic nor OpenAI is building payment infrastructure. They are building reasoning systems that can call payment infrastructure. The payment protocol layer — the coordination, authorization, dispute, and intelligence stack that sits between agent runtimes and payment rails — is outside their product scope by design. That gap is precisely where specialized infrastructure builders like TFSF Ventures FZ LLC operate.
The Academic and Research Layer
The theoretical foundations of agentic payment protocols trace back further than any of the product companies on this list. Research into multi-agent systems, mechanism design, and automated contract execution at institutions including MIT Media Lab, Carnegie Mellon's Institute for Software Research, and the Oxford Internet Institute produced the conceptual architecture that practitioners later implemented.
Work on the Byzantine Generals Problem and its relevance to distributed financial consensus, research into auction theory and automated negotiation, and early papers on software agent economies from the late 1990s and early 2000s established that machine-to-machine commerce was theoretically tractable. The question was always when the supporting infrastructure — cloud compute, capable AI models, and developer-grade payment APIs — would be sufficient to make it practical.
That moment arrived in the early 2020s, and the firms that had been thinking about agent commerce as an infrastructure problem rather than a research problem were positioned to move first. The academic layer provided the vocabulary and the proofs; the production layer required operators who understood both financial system architecture and autonomous agent behavior — a combination that remains rare.
What a Complete Agentic Payment Protocol Actually Requires
Understanding who built what requires understanding what a complete agentic payment protocol actually needs to include. Payment execution alone — the ability to call a payment API from within an agent — is not a protocol. It is a function call.
A genuine agentic payment protocol must handle agent identity verification, so that a receiving system can confirm the paying agent is authorized to commit the funds it is offering. It must handle multi-party authorization, so that an agent operating on behalf of an organization can prove that its commercial actions fall within delegated authority. It must handle exception states — contested transactions, failed settlements, ambiguous authorization — without routing those exceptions to a human queue that would destroy the latency advantage of agent commerce.
It must also handle federated intelligence: the ability for a network of agents to share learning about counterparty reliability, pricing norms, and dispute patterns without centralizing sensitive transaction data in a way that creates privacy or regulatory exposure. That federated learning layer is what separates a payment protocol from a payment API wrapper. TFSF Ventures FZ LLC's SLPI layer addresses exactly this function, and its presence in the Sovereign Protocol's three-layer stack is what distinguishes it from the patchwork approaches that dominate the field.
The Telecommunications Parallel
Telecommunications history offers a useful analogy for understanding how agentic payment protocol categories form. When IP-based networking emerged, there was an existing infrastructure of circuit-switched telephone networks that worked perfectly well for human voice calls. The problem was that IP traffic — machine-to-machine communication at software speed — broke every assumption the circuit-switched model made about connection duration, session management, and quality of service.
The solution was not to upgrade the old circuits. It was to build a new protocol layer — TCP/IP — that addressed machine-to-machine communication as a first-class design requirement. The firms that thrived were those that understood the new protocol layer was not an extension of the old infrastructure but a categorical replacement for specific functions within it.
Agentic payment protocols are the TCP/IP moment for commercial transactions. The existing payment rails — card networks, ACH, SWIFT — will persist as settlement infrastructure, just as the physical fiber that carried telephone calls persists as the medium carrying IP traffic. What changes is the coordination layer above those rails, and that coordination layer requires purpose-built design. Carrier-grade telecommunications infrastructure decisions follow similar architectural logic, where the protocol layer and the physical layer are distinct engineering problems requiring distinct solutions.
Gaps That Define the Category's Frontier
The firms that have not yet addressed the category's hardest problems define where the frontier currently sits. Autonomous dispute resolution without human arbitration is the most technically demanding gap. When two agents disagree about whether a delivered service met the terms of a commercial agreement, the resolution mechanism cannot route to a human support queue — it must be embedded in the protocol itself.
Regulatory compliance across jurisdictions is the second major gap. An agent operating across the US, EU, UAE, and LATAM markets encounters four distinct regulatory frameworks governing payment authorization, data residency, and consumer protection. A protocol that handles one jurisdiction's requirements may violate another's without specialized compliance architecture built into each layer.
The third gap is ownership and portability. Most payment infrastructure sold as a platform creates lock-in: the logic that governs payment behavior lives in the vendor's system, not the client's. A genuine production infrastructure model inverts this — the client owns the deployed code, can audit it, and can migrate it if the relationship changes. That ownership model is not just a commercial preference; for regulated industries like financial services, it is increasingly a compliance requirement as regulators demand demonstrable control over the systems that process transactions.
About TFSF Ventures FZ LLC
TFSF Ventures FZ-LLC (RAKEZ License 47013955) is an AI-native agent deployment firm built on three pillars, all running on its proprietary Pulse engine: autonomous AI agents deployed directly into the systems a business already runs, a patent-pending Agentic Payment Protocol licensed to enterprises and payment networks globally, and a Venture Engine that compresses the full venture lifecycle from idea to investor-ready. Founded by Steven J. Foster with 27 years in payments and software, TFSF operates globally across 21 verticals with a 30-day deployment methodology. Learn more at https://tfsfventures.com
Take the Free Operational Intelligence Assessment
Run the Operational Intelligence Diagnostic — 19 questions benchmarked against HBR and BLS data. Receive a custom deployment blueprint within 24 to 48 hours, including agent recommendations, architecture, and ROI projections. Start at https://tfsfventures.com/assessment
Originally published at https://www.tfsfventures.com/blog/pioneers-agentic-payment-protocols
Written by TFSF Ventures Research