The Staircase Is Missing a Basement
Stripe built a beautiful staircase. Five levels, clean framing, exactly the kind of structured thinking the industry needed. There’s only one problem: it has no basement.
Stripe’s 2025 agentic commerce letter takes “agentic commerce” out of sci-fi territory and turns it into a framework with distinct capability thresholds. That’s useful work. The framing is mostly right — while still undershooting the weirdness of what’s actually required underneath. So this is a “yes, and.”
The most important shift isn’t agents buying things. It’s the internet learning how to accept intent as a first-class object, with payments as the enforcement mechanism. That’s a different claim than “checkout gets automated,” and it demands different infrastructure.
Stripe’s Five Levels of Agentic Commerce
Stripe’s framework maps agentic commerce as a progression from basic automation to genuine anticipation. In order of autonomy:
- Eliminate web forms — the agent types and clicks on your behalf; you still decide what to buy
- Descriptive search — describe your situation; the system reasons across constraints (price, specs, delivery date, preference)
- Persistence — the agent remembers you across sessions; preferences and prior purchases carry forward; no reintroduction needed
- Delegation — you set a budget and parameters; the agent searches, evaluates, and purchases without you choosing
- Anticipation — no prompt needed; the system reads your calendar, history, and implicit context and acts before you ask
Stripe explicitly compares the current moment to the mid-90s protocol era and argues the future depends on universal interoperability. They’re building toward it with the Agentic Commerce Protocol (ACP, co-developed with OpenAI), Shared Payment Tokens, and machine payments via stablecoin for agent-to-API transactions.
We like this a lot. The instinct is right: don’t bet on a single agent interface; bet on the underlying payment and identity primitives that let many interfaces coexist. Here’s where we push back, level by level — and then on the structure itself.
Level 1: Interface Hack, Not Exit Ramp
Level 1 is a migration path for incumbents, not the end state for new systems.
Stripe describes Level 1 as “typing and clicking ‘buy’ on your behalf,” with the human still making every decision. The value is real — checkout flows are genuinely terrible, and removing manual data entry improves user experience. But it doesn’t change the substrate. The agent is operating as a human proxy: borrowing the user’s session, credentials, and payment method. It’s screen-scraping with better manners.
The risk is mistaking “we automated checkout” for “we built agentic commerce.” Level 1 scales poorly the moment you need reliability at volume, auditability across runs, or anything resembling a business process rather than a one-off transaction. Sessions expire, forms change, authentication breaks, and the automation fails. It’s a bridge worth building if you’re serving legacy systems that can’t be re-architected. It’s not a destination.
"The first barrier was accounts — getting API keys, creating emails, any of that for agents. They couldn't do it on their own. It's like having the brightest nine-year-old on earth. They'd have a really hard time opening an account if they walked into a bank."
Louis Amira, co-founder, ATXPLevel 1 is where most current agent commerce lives. That tells you how early this is.
Level 3: Permission Is Destiny
The bottleneck at Level 3 isn’t whether the model can remember. It’s who owns that memory, and how it travels.
Stripe frames Level 3 as persistence: the agent carries context from prior sessions, learns preferences from past purchases, stops requiring reintroduction. That’s the right surface description. But memory without portability defaults to a walled garden. Every company building agents has structural incentives to be the system of record for your preferences. The one who owns the memory owns the relationship.
Agentic commerce Layer 0 is the composable infrastructure layer for non-human actors: identity that is portable, permissions that are programmable, and payments that are native to machines. Without this basement, every level of the agentic commerce stack either becomes a walled garden or remains a fragile interface hack. It is the precondition for everything above it.
The more useful frame for Level 3 isn’t “an agent that remembers me” — it’s selectively provable claims that can be delegated to agents for specific jobs. Not a unified profile owned by one company. Discrete, verifiable authorizations: “this purchase is within my budget policy,” “this merchant is in my allowlist,” “this item matches my sizing constraints,” “this vendor meets my return requirements.”
Memory is useful, but permissioning is destiny.
The agent doesn’t need to know everything about you. It needs to prove specific things on your behalf, for specific transactions, under specific constraints. That’s a permission system, not a memory system. The technical capability looks similar from the outside. The architecture that enables it is entirely different.
Level 4: Delegation Requires Receipts
Delegation only works at scale if it’s reversible, inspectable, and granular.
Stripe’s Level 4 is “you provide a budget; the agent handles everything.” Compelling description of the capability. What’s missing is the trust mechanism that makes a user comfortable handing over that authority — and comfortable expanding it over time.
Humans don’t trust autonomy in the abstract. They trust clear budgets, constrained authority, receipts, and the ability to unwind mistakes. Between Level 3 and Level 4 there’s an implied step Stripe doesn’t name: policy plus audit. Ramp built a substantial business on this exact insight — most enterprise spend control isn’t about getting 2% cash back; it’s about not spending the other 98% on things that shouldn’t have been bought at all. The policy layer is where the real value is.
The winning primitives here are specific: spend limits as programmable policies (“up to $400, but also: no third-party marketplaces, must arrive by Friday, prefer merchants with easy returns”), cryptographically attributed authorizations (“who approved this, and under what exception”), machine-readable invoices with reason traces (“I chose this vendor because it matched these constraints”). Not just a number — a structured policy the agent can evaluate against.
Delegation is not one big “yes.” It’s lots of small “yeses” that are easy to refine. And revoke.
"Land on an existing shopping cart and every one of them is designed to block bots. Billions of dollars have gone into captchas and fraud detection — designed to ensure a human is typing in the card number. At some point, merchants are going to be able to shake hands with an agent in a trusted way, and they'll actually want to be open for business."
Louis Amira, co-founder, ATXPBuild the policy layer wrong and delegation never gets off the ground, because users won’t hand over authority to a system they can’t inspect or constrain. This is less a technical problem than a design problem — but it requires technical primitives to solve.
The Staircase Is Missing a Basement
Here is what Stripe’s framework doesn’t name: everything above Level 1 assumes a substrate that doesn’t yet exist at scale.
The five levels describe what users experience. What they don’t describe is what has to be true underneath for any of it to work. That lower layer — Level 0, the basement — determines whether the agentic internet becomes a collection of walled gardens with polished UX, or an open economy where agents can roam and transact safely.
That basement layer is:
Identity, permission, and payments as composable infrastructure for non-human actors.
Stripe is clearly building pieces of it — ACP, Shared Payment Tokens, machine payments via stablecoin. These are the right instincts. The “yes, and” is that machine payments isn’t a bullet point in a payment company’s annual letter. It’s the seed of an entirely different market structure.
Once agents are customers, pricing stops being “$20 per month per seat” and starts being per call, per outcome, per delegated action, per verified task completion. The implications go further than they appear:
You don’t just monetize humans more efficiently. You get brand new demand from software that can pay.
That’s not an optimization of existing commerce. It’s a new category of economic actor that needs infrastructure built specifically for it — not borrowed from infrastructure designed for humans.
The question of who builds the basement, and whether it’s portable and open or owned and siloed, determines the structure of everything above it. This isn’t a subtle architectural decision. It’s the same decision the early internet made when it standardized on TCP/IP and HTTP rather than letting each platform own its protocols. The products built on open protocols were remarkable. The protocols made them possible.
ATXP is the basement. An agent account with a persistent agent handle, a payment wallet, an @atxp.email address, and access to 14+ tools — in one command: npx atxp. See how it works →
Intent Wants to Be Routable
| Stat | Figure | Source |
|---|---|---|
| AI agent market size (2025) | $7.84B | IDC |
| AI agent market forecast (2030) | $52.62B | IDC |
| Annual growth rate | 46.3% CAGR | IDC |
| Enterprise agentic AI app adoption | <5% (2025) → 40% (2026) | Gartner |
| Estimated annual business value from agentic AI | $2.6–4.4 trillion | McKinsey |
A few of the things we're excited about in crypto (2025) → An AI needs a wallet of one's own to act agentically → Enter 'decentralized autonomous chatbots' → As more people use AI, we'll need unique proof of personhood → Going from prediction markets… to better information
— a16z crypto (@a16zcrypto) December 4, 2024
The Gartner figure is the one with velocity: under 5% to 40% enterprise adoption in a single year is one of the steepest adoption curves on record. Most of the infrastructure that curve assumes doesn’t fully exist yet. That gap — between the adoption trajectory and the infrastructure maturity — is exactly the basement problem.
The staircase framing is useful because it makes the capability progression concrete. It’s limiting because it focuses on what the user experiences rather than what the infrastructure must provide. The early internet made information linkable. Any document could point to any other across any server, without requiring the two servers to be owned by the same company. That wasn’t a feature. It was the architecture. It’s what made the web a web rather than a set of walled databases with portals.
"All they were really doing was walking the store and tossing stuff into the cart. And once they got to the checkout line, turning around to you and saying: 'Here human, time for you to give them the card.' Really, it was a shopping cart filler."
Louis Amira, co-founder, ATXPThe agentic internet needs the equivalent principle:
If the early internet was “information wants to be linkable,” the agentic internet is “intent wants to be routable.”
A goal expressed by a human or an agent — find this, buy that, complete this task within these constraints — should travel across agents, services, and payment rails without being trapped inside the stack of whoever owns the session. Routable intent means a credential that travels. A permission that can be verified without being surrendered. A payment that can clear without a human in the loop.
None of that is impossible. Some of it is being built right now. What determines whether it produces open commerce or a new generation of platform lock-in is what gets built in the basement — and whether it’s built as composable primitives or as features inside a single platform’s roadmap.
See how the current landscape compares in our agent payment protocols comparison, or read the full explanation of what agents need to function if you’re starting from first principles.
Frequently asked questions
What is agentic commerce Layer 0?
Layer 0 (or the “basement”) refers to the composable identity, permission, and payment infrastructure that non-human actors — AI agents — need before they can participate in commerce at any level. Without it, agent commerce is either a set of walled gardens or a fragile interface hack. Layer 0 makes agent transactions portable, auditable, and trustworthy across systems.
What is Stripe’s Agentic Commerce Protocol (ACP)?
ACP is a shared protocol co-developed by Stripe and OpenAI designed to give agents a common language for initiating commerce transactions — browsing products, selecting them, and completing purchases — across multiple AI interfaces. Stripe is also building Shared Payment Tokens and machine payments infrastructure alongside it. The goal is universal interoperability across agent interfaces rather than a single walled-garden experience.
What does “intent wants to be routable” mean?
It’s a reframe of the early internet’s “information wants to be linkable” principle. On the early web, the fundamental unit was a document you could link to. On the agentic internet, the fundamental unit is an intent — a goal, budget, constraint set, or delegated task — that needs to be expressed in a machine-readable way and routed to the right service. Routing intent requires identity (who is asking), permissions (what they’re allowed to do), and payments (the enforcement mechanism).
Why isn’t agent memory enough for agentic commerce?
Memory — a persistent profile of preferences, past purchases, and constraints — is useful but isn’t the bottleneck. The bottleneck is permissioning: what is the scope of that memory, who owns it, and how does it travel across systems? An agent that remembers your preferences but can’t prove it’s authorized to act on them — or can’t carry those authorizations portably to a new merchant — has good data and no power to use it.
What is “Level 3.5” in Stripe’s agentic commerce framework?
Level 3.5 is an implied step between Stripe’s persistence (Level 3) and delegation (Level 4) that Stripe doesn’t explicitly name: policy and audit. Delegation only becomes trustworthy at scale when spend limits are programmable, authorizations are verifiable, and invoices are machine-readable. Without this layer, delegation is a single large “yes” that’s hard to refine and impossible to revoke cleanly. Ramp built a major business on exactly this insight — spend control, not spend capture, is where enterprise value lives.
How is ATXP related to Stripe’s agentic commerce work?
Stripe is building the rails layer — ACP, Shared Payment Tokens, machine payments. ATXP is building the identity and permissioning layer beneath that: an account system that gives agents an agent handle, a payment account, an email address, and programmable spend policies. The two are complementary. Stripe processes the transaction; ATXP establishes who the agent is and what it’s allowed to do before the transaction starts. See agent payment protocols compared for a full breakdown.
The staircase Stripe describes is real, and Levels 1 through 5 will all happen. They are already happening at the edges. What determines whether they produce open commerce or a new generation of platform lock-in is what gets built in the basement before the upper floors fill in.
The early web’s most consequential decisions weren’t about interfaces. They were about protocols — who owns the address space, who controls the routing, whether one company can wall off the network or whether the network is genuinely common infrastructure. The agentic internet faces the same fork. The window to make the right call is open now, while the stack is still being designed, before the walled gardens are fully built and the incentives to keep them walled overwhelm the instinct to open them up.
Build the basement first. The staircase lands somewhere worth going.
ATXP is the basement. Get started at atxp.chat or run npx atxp to add the infrastructure layer to an agent you’re already building.
Further reading: What is an AI agent? · Agent payment protocols compared · How ATXP works · Stripe’s 2025 agentic commerce letter