The Next Marketplace is Agentic

Part 1 - The agentic vendor

A new marketplace is brewing

Each wave in technology produces one marketplace that reorganizes which companies matter. Web 1.0 had the Google search engine moment. Mobile had the App Store. Each time, a new substrate created a new surface where users discovered and paid for things. Historically, the companies that adapted faster to the emerging marketplace became the new incumbents, just as Amazon mastered Google's search algorithms to eclipse legacy retailers like Sears, and brands like Dollar Shave Club capitalized on the Facebook ad feed to bypass traditional retail shelf space.

The agentic marketplace is the next one, and the closest historical analogue is the App Store circa 2008. Before that tipping point, every consumer brand had a website strategy. By 2010, the ones that hadn't shipped an app (newspapers, retailers, banks, even airlines) were losing market share. The mobile app transition also created new business models: Instagram couldn't have existed on the desktop web. Uber couldn't have existed without a phone with GPS in your pocket.

This time, the agentic is similar, but times faster. The first cohort of agent-native businesses whose product exists primarily to be hired by an agent is already shipping at meaningful volume. For instance, Coinbase agentic.market alone is running sixty-nine thousand active agents and ~$50M in annualized stablecoin transactions.¹

This is brewing now, and the 2007-to-2010 window is the right mental model: short, asymmetric, and unforgiving of the companies that wait for it to mature before they move.

In The Everything Store, Brad Stone tells the story of the spring 1994 stat that motivated Bezos to quit his quant career at D.E. Shaw: web usage growing 2,300% per year. "Things just don't grow that fast," Bezos said. "It's highly unusual, and that started me thinking, what kind of business plan might make sense in the context of that growth?" The agentic marketplace is the “2,300% chart” of this decade, and the same question is on the table.

So your next customer is an agent

Conventionally, customers can fall in three categories: human consumers (B2C), other businesses (B2B), and the public sector (B2G). A fourth buyer category is emerging: the agent (B2A). And it's compounding faster than any new channel in the history of commerce. An agentic buyer is basically software with budget, intent, and authority to transact (we will explore more in depth how it works in Part 2). The framework you built for B2C, B2B, and B2G doesn't extend to it cleanly, because the buyer's substrate is different in kind: namely it evaluates differently, it discovers products and services differently, and most importantly it pays differently. If your funnel is designed for a human eyeball, you have a problem you might not have noticed yet: most of your buyers are still humans, but the share of purchase decisions being shaped, narrowed, or executed by an agent is growing faster than any other channel in your stack, and it's growing in a direction your current marketing has no handle on.

The shift is already concrete. ChatGPT's Instant Checkout is selling Etsy and Shopify merchandise to people who have never visited the merchant's website. Coinbase agentic.market has sixty-nine thousand active agents transacting against API endpoints whose owners never published a landing page for them. Salesforce AgentExchange, LangChain Hub, and the MCP registries are filling up with paid services that no human ever sees directly. A meaningful and rising fraction of B2B procurement decisions is being filtered through "what does the LLM recommend" before a human ever evaluates options. Once the agent has narrowed the shortlist, the human almost always picks from it.

The opportunity: the bar for agent-readiness is still low, and the companies that become agentic-ready early will lock in a position that's much harder to dislodge once everyone catches on. Let’s find out how.

The building blocks of the agentic vendor

Becoming an agentic vendor takes architectural commitment. Two questions decide whether an agent can actually transact with you: what shape does your selling interface take, and what does the agent expect from you once it picks you. Most teams collapse these into "let's accept agent payments" and miss the fact that the payment integration is the last 10% of the work. The first 90% is the structural work of becoming agent-ready: picking the right seller paradigm, and honoring the obligations that come with it.

Five seller paradigms

There are at least five ways to expose goods and services to agents in production today. They form a spectrum ranging from pure API endpoint to fully agentic A2A interaction, with everything in between being some mix of the two. There is no “best paradigm”; the choice depends on which one matches what you're selling:

1. The Pure API endpoint. A stateless REST or function-call surface. The agent reads your OpenAPI spec, picks the tool, hits the endpoint, and pays. This is what most x402 endpoints look like: zero intelligence on your side, no negotiation, no clarification, the agent gets exactly what it asked for and nothing more. It's the cheapest to operate, fastest, and deterministic. It's the right answer for commodity utilities (data feeds, compute, lookups, simple model calls) where the agent already knows exactly what it wants.

2. Human storefront with machine-readable annotations. Keep your normal human-facing website, but layer structured metadata on top. Great options include schema.org product data, OpenGraph, ACP integration, OpenAPI alongside your HTML. The agents can parse the structured layer while humans can still browse normally. This is for instance what Shopify/Stripe ACP merchants look like. Recommended when your buyer mix is still mostly human and you don't want to maintain two surfaces.

3. The MCP server. Same fundamental shape as an API, but in this case your service is wrapped with typed tools and natural-language descriptions, namely accessed via MCP. The buyer agent's LLM reads your descriptions and picks. It still bears no intelligence on your side; you're just better-documented and natively discoverable in MCP registries. This is the single lowest-effort way to be agent-native in 2026, and the fastest way for any vendor whose product is an “atomic” service (i.e. a single translation, an OCR scan, etc.) rather than a more structured service like consulting.

4. The Marketplace listed service. In this case you don't run any surface yourself. You can just list on a marketplace like agentic.market. The marketplace itself handles discovery, payment (more in the next section), identity, and basic support. Zero infrastructure to maintain, but you don't own the customer and you live or die by the marketplace's ranking algorithm. This is a faster solution for early-stage vendors who can't yet justify their own surface, or for adding a sales channel without rebuilding your stack.

5. Agent-to-agent (A2A). Your seller is also an agent. An LLM runs on your side and converses with the buyer agent in natural language. For example, a buyer agent says "I need cyber liability coverage for a 50-person fintech startup in California." Your seller agent asks about revenue, the kind of data the company handles, then recommends the right E&O policy and quotes the premium. Google's A2A protocol and AP2's A2A extensions are the early standards. It's generally more expensive and harder to instrument, but this is also the only shape that handles nuance, upsell, recommendation, and clarification. As one early example, Gordon Food Service partnered with one of its key suppliers, Tyson Foods to demonstrate A2A capabilities for product searching and sales tracking. 12 While certain enterprises are starting to explore this paradigm, no commercial success case is currently live in production, leaving great margin to emergent AI startups to take the lead in this field.

Whichever paradigm you pick, you still owe any agent that approaches you six things. Most vendors today honor the first three reasonably well, the fourth badly, and the last two not at all.

1. Discoverability. The agent has to find you in the universe of options. Registry listings, model recall from training-data presence, and orchestrator-default placement are the levers. How to get found is dense enough that it gets its own treatment later in this piece.

2. Legibility. Once found, the agent has to understand when you're the right pick. Schema descriptions written specifically for LLM parsing, capability statements in one tight sentence, examples in the spec, structured metadata about constraints (latency, input limits, regional availability, supported languages). The brutal test is concrete: paste your description into Claude or GPT, give it a task that should select your tool, and ask whether it would pick you. If it hesitates, your description is failing.

3. Comparability. The agent has to be able to evaluate you against alternatives. Machine readable pricing in the schema or in the response (an x-pricing field, pricing hints in your MCP tool description), structured capability metadata, published latency SLAs, and ideally public eval benchmarks. The agent's budget reasoning depends on you exposing your price before the call, not after. If your pricing requires the agent to sign up, log in, and read a PDF, you've removed yourself from the consideration set.

4. Trust. The agent has to be willing to spend money with you, which means its operator has to be willing to let it. Register with Skyfire's Know Your Agent framework, sign your responses with Web Bot Auth (the substrate under Visa Trusted Agent Protocol and Mastercard Agent Pay), publish a status page with SLO data agents can fetch, and expose compliance attestations (SOC 2, ISO, HIPAA, jurisdiction-specific) in machine-readable form. In regulated verticals like permits, filings, healthcare, or finance, this is the single largest determinant of whether an agent picks you over a competitor.

5. Transactability. The agent has to be able to actually pay you on a rail it supports. This is the part most vendors think is the whole job. Support at least one autonomous payment path, such as a scoped API key for known buyers, an x402 endpoint for ad-hoc machine-to-machine traffic, Stripe SPT acceptance if you sell to consumer-facing agents. The more rails you support, the more agent populations you can address; the next chapter walks through the protocol landscape in detail.

6. Supportability. Things will go wrong: bad response, downtime, dispute, refund request, etc. When this happens, there has to be a process in place to “fail gracefully” and recover. This is the part the whole industry is currently bad at. Most vendors have no agent-readable refund flow, no dispute resolution endpoint, no escalation path that doesn't require a human to file a ticket. Build at least the basics: a webhook for refund requests, idempotency on payment retries, an audit log endpoint the buyer can pull. Whoever solves this layer well first will pull ahead of competitors who have great tech but no recourse story.

Payment Protocols

Of the six obligations above, transactability (namely, being able to actually accept money from the agent on a rail it supports) is the one with the most talk and the least practical clarity. Every week brings a new "agent payments" announcement; card networks, payment processors, and AI labs are all shipping protocols and SDKs at a pace that makes any builder trying to actually ship today struggle to tell what's usable from what's a press release.

So instead of cataloging vendors, this chapter sorts the protocols by the only question that matters: can an agent autonomously buy something with this, today, in a real product? That gives us three honest tiers.

Tier 1: Semi-autonomous, humans still have to tap "Buy"

This is where most of the marketing budget is, and where the most user-visible products live. It's also where the word "autonomous" gets stretched the furthest.

OpenAI's Agentic Commerce Protocol (ACP) [link], co-developed with Stripe, powers Instant Checkout in ChatGPT. It works so that ChatGPT presents products, builds the cart, prepares the payment, and then the user clicks. ACP is open source under Apache 2.0.5

Stripe's Agentic Commerce Suite [link] is the practical infrastructure beneath ACP, anchored on a new primitive: Shared Payment Tokens (SPTs). An SPT is a one-time, narrowly scoped credential, bound to a specific seller, a specific amount, a specific time window. The agent gets enough to complete one purchase and nothing more. Stripe is now bridging SPTs into Mastercard Agent Pay, Visa Intelligent Commerce, and BNPL providers like Affirm and Klarna.

Google and Shopify's Universal Commerce Protocol (UCP) [link], announced at NRF 2026, takes a wider view than ACP. Where ACP models a single checkout transaction, UCP models the entire commerce lifecycle: discovery, purchase, returns, tracking, and support.⁶

Why does Tier 1 still need a human tap? Three reasons that aren't technical. First, card network chargeback rules weren't written for non-human buyers; liability is unresolved. Second, fraud-detection systems (Riskified, Signifyd, Forter) are tuned to block automated traffic, the so-called "checkout wall." Third, regulatory expectations around consumer consent vary by jurisdiction.

So Tier 1 is genuinely live, millions of merchants live here with real GMV, but the agent is a sophisticated shopping assistant, not an autonomous buyer.

Tier 2: Fully autonomous & in production today

This tier is real. Agents are paying for things without humans in the loop, at meaningful volume. There's just one catch worth stating upfront: the buyers are almost always other software, not people.

x402 (Coinbase) is the standout. It resurrects HTTP's long-dormant 402 status code: a server returns 402 with a price quote, the client pays in stablecoins, retries with proof. No accounts, no API keys, no subscriptions. As of April 2026, roughly 69,000 active agents have run 165 million transactions across Base, Polygon, Arbitrum, Solana, and World, totaling about ~$50M in annualized volume.¹ Cloudflare joined the x402 Foundation.² Coinbase launched agentic.market, an app store of paid agent services with OpenAI, Bloomberg, CoinGecko, and AWS Lambda among the suppliers.³

Nevermined does the same for MCP. It lets an agent gate its own tools behind sub-cent paywalls. $0.001 per call is economically viable, which simply isn't true on card rails. If you're building an agent that sells its outputs, this is the closest thing to plumbing.

Skyfire layers identity onto stablecoin rails. Its KYAPay product settles in USDC; its Know Your Agent (KYA) framework is the early attempt at agent reputation, a way for the receiving side to decide whether to trust the buyer.

Tier 3: Pilots

This is where the most ambitious work is happening, and where almost no consumers will encounter it for another 12 to 18 months.

Agent Payments Protocol (AP2) is Google's open standard, announced in September 2025 with sixty-plus partners including PayPal, Mastercard, Amex, Adyen, Coinbase, Salesforce, ServiceNow, Worldpay, JCB, UnionPay International, and Etsy.⁷ In early 2026 Google donated it to the FIDO Alliance to make it platform-neutral.⁸ The core primitive is the verifiable mandate: a cryptographically signed credential that proves a specific user authorized a specific agent to spend up to a specific amount with specific counterparties under specific conditions. This is the right abstraction for a world where regulators, insurers, and auditors will eventually demand proof that a purchase was actually authorized.

The current release is v0.2.0 (April 2026), with reference implementations in Python, TypeScript, Kotlin, and Go. Three named deployments exist: PayPal's wallet inside Google's Conversational Commerce Agent, the Mastercard Agent Pay pilot inside PayPal, and an A2A x402 extension for crypto. No consumer-facing product uses AP2 today.

Visa's Trusted Agent Protocol11 (October 2025, with Cloudflare) and Mastercard's Agent Pay (also called Verifiable Intent) build on the same foundation as AP2: Web Bot Auth for agent identity, signed HTTP request context, and delegated mandate credentials. Mastercard and Santander completed Europe's first live AI-agent payment in early 2026 on live infrastructure, now expanding to more use cases.9 American Express has signaled it will adopt the standard. None of these card-network protocols is generally available yet.10

Tier 3 is where the fully autonomous retail future is being built. The actual blockers are liability frameworks, dispute resolution rules, and the boring legal infrastructure that makes a $50B/year consumer payments business possible.

How do I sell to an agent?

A payment rail makes you transactable, but it doesn't elevate your product or service to a “preferred choice.” Getting agents to actually pick you is a whole different deal.

The agent is not your prospect's research assistant. The agent is your prospect. And it behaves nothing like you are used to in B2B or B2C. It doesn't watch your ads. It doesn't read your case studies. It doesn't sit through a thirty-minute demo. It doesn't have brand loyalty, it doesn't get nudged by retargeting, and it definitely doesn't fill out a "request a quote" form. What it does is read your schema, check whether your tool description matches its task, compare your pricing in machine-readable form against alternatives, and either transact or move on in a fraction of a second.

Most agents don't browse, they recall and read, so the entire discovery game is about two things: showing up in the surfaces an agent queries at runtime, and being legible enough to win the comparison once you do surface. That decomposes into a small set of tactics, in roughly the order they pay back.

List your product or services in major agentic marketplaces. Start with the major generic purpose ones, as they're queried by every major MCP-aware client:

1. Coinbase agentic.market (x402-native catalog)
2. Vercel's skills.sh
3. Vercel Marketplace (paid-tier, unified auth and billing)
4. MCP official directory
5. Smithery, Glama
6. LangChain Hub
7. LlamaIndex tool registry

..and if you service is purely B2B, you may publish it on Salesforce Agent Exchange

Optimize for model recall. The unglamorous but largest part of agent discovery. When an agent reasons "what tool can I use for X?" it's pulling from the LLM's weights, not running a search. Your tool name needs to be in the GitHub READMEs, framework tutorials, Stack Overflow answers, and blog posts that ended up in training corpora. Sponsor or contribute to the popular orchestration frameworks so you're cited in their docs and example notebooks. Get featured in the cookbook tutorials Anthropic and OpenAI publish. Run public evals where you're benchmarked head-to-head; eval pages tend to end up in training data and downstream coverage. Brand presence in the training corpus is the moat that doesn't expire when the next marketplace launches.

Your machine-readable listing has to do the selling. Agents pick by reading your schema, not your landing page. The OpenAPI spec or MCP tool description should answer "when would I use this?" in one tight sentence, not pitch the product. A good example of this is the Sentry MCP server. To really make things easier for the agent, expose pricing in the response itself, an x-pricing field or pricing hints directly in the description, so an agent reasoning under budget constraint can compare without fetching your docs. Put examples in the schema. Tag capabilities and constraints (input limits, latency, regional availability) as structured metadata. The ultimate test: paste your description into Claude or GPT, give it a task that should select your tool, and ask if it would pick it. If it hesitates, your description is failing.

Remove first-call friction ruthlessly and accept every payment path agents use. An agent that can use your tool the moment it discovers it beats one that has to onboard. That means an MCP server that works on install, an x402 endpoint that needs no account, a free tier generous enough for an agent to evaluate without asking permission, and SDKs in the two languages every agent stack speaks (TypeScript and Python). On the payment side, every rail you don't support is an agent population you can't address, so pick at least two (typically a scoped API key for known recurring buyers, plus x402 for ad-hoc machine-to-machine traffic) and add more as your buyer mix demands.

Make trust machine-verifiable. As the agent economy formalizes, picking an untrusted tool becomes a liability for the operator. Register with Skyfire's Know Your Agent framework, sign your responses with Web Bot Auth, publish a structured status page with SLO data agents can fetch, and expose compliance attestations (SOC 2, ISO, HIPAA where relevant) in machine-readable form. In regulated verticals this is the single largest differentiator, so an agent filing your taxes will not pick a source it can't attest to.

For the ambitious: become the default in an orchestrator or vertical agent product. This is the highest-leverage move for an early-stage vendor because it shortcuts every other tactic. Most production agents don't choose tools from scratch each call, an orchestrator has pre-selected the toolset. Be the LangChain from langchain_community.tools import YourTool default, the reference implementation in CrewAI's tutorials, the recommended pick in LlamaIndex's docs. Convincing one maintainer once captures every agent built on that framework. For vertical agent products in your category, the same logic applies: get bundled into the product, not just listed in a directory.

Start accruing reputation in the systems that are emerging. Skyfire's KYA tracks tool identity; Coinbase agentic.market is building review and rating signals; AP2 will eventually accrue mandate-bound reputation. None is decisive yet, but bad experiences early compound against you when these systems mature, and being listed early seeds future rankings with usage history.

Don't wait for this marketplace to mature before you move.

At Interpret AI, we're building for the agentic shift, and we can help you with every aspect mentioned in this piece.

If you're working through the same questions, we'd like to hear from you.