Your next power user will not visit your website. It will read your API documentation, parse your OpenAPI spec, and decide in milliseconds whether your product can solve its owner’s problem. If your docs are unclear, it moves on. No bounce rate to measure, no exit page to optimize. Just silence.
That is B2A: Business-to-Agent. Y Combinator’s Dalton Caldwell put it bluntly in January 2026: “Not B2B, not B2C, but B2A. We are looking for startups building products where AI agents are the intended customer. Make something agents want.” Kantar projects that agent-driven commerce could rewrite category shares in 18-24 months. Stripe launched its Agentic Commerce Suite. Google is piloting agentic checkout through Gemini. Visa, Mastercard, and PayPal are all demoing agent-ready payment APIs.
Yet according to Nordic APIs research, only 24% of API designers currently optimize for AI agents, despite 89% using generative AI tools daily. That gap between how many people use agents and how many design for them is the single biggest untapped opportunity in product strategy right now.
What B2A Actually Changes About Your Business
B2B and B2C share an assumption: a human evaluates your product. They see your landing page, read your copy, compare screenshots, maybe watch a demo video. B2A breaks that assumption completely. An AI agent evaluating your product does not care about your brand colors, your testimonial carousel, or your “trusted by 10,000+ teams” badge. It cares about three things: Can I access the functionality I need through an API? Is the documentation precise enough that I can use it without guessing? How fast does the system respond?
Kantar’s analysis lays out how the old rules no longer apply:
Emotional storytelling loses to structured data. In B2C, you win share of mind through narrative. In B2A, you win share of algorithm through machine-readable product feeds, structured Schema.org markup, and real-time pricing APIs. If an agent cannot parse your catalog, your product does not exist in its world.
The funnel collapses into loops. Traditional marketing funnels assume awareness leads to consideration leads to purchase. Agents skip all of that. They start with a specific need, query multiple providers simultaneously, compare structured responses, and execute. The entire “funnel” happens in seconds, and the agent may run through it multiple times, iterating on constraints its owner specified.
Loyalty shifts from brand to cost. When a human shops, brand affinity, visual appeal, and past experience all influence the decision. When an agent shops on behalf of a human, it optimizes for the parameters it was given: lowest total cost, fastest delivery, best spec match. Brand loyalty becomes API reliability.
This does not mean branding dies. It means branding moves upstream to the moment the human tells the agent what to buy. “Get me running shoes from Nike” still works. “Get me the best running shoes under $150” lets the agent choose, and that is where B2A design determines who wins.
Agent Experience (AX): The New Design Discipline
Mathias Biilmann, CEO of Netlify, gave this shift a name: Agent Experience, or AX. The concept extends the progression from User Experience (UX) in the 1990s to Developer Experience (DX) in the 2010s. AX is what happens when AI agents become first-class users of your product.
Netlify saw the proof early. Their ChatGPT integration, which lets agents deploy websites directly through the API, generates more than 1,000 sites per day created on Netlify from ChatGPT alone. That is not a side channel. That is a primary acquisition funnel driven entirely by agent-accessible infrastructure.
Designing for AX differs from DX in several critical ways:
Documentation becomes a contract, not a guide. Human developers can infer intent from examples. Agents cannot. If your API documentation uses vague terms like “a few,” “try some,” or “may vary,” an agent will either fail silently or make incorrect assumptions. AX-optimized documentation reads like a legal contract: precise, unambiguous, and machine-parseable.
Authentication must be non-interactive. OAuth redirect flows, CAPTCHAs, and email verification loops are dead ends for autonomous agents. B2A-ready authentication uses short-lived tokens, API keys with minimal permission scopes, and clear failure-recovery paths that an agent can follow without human intervention.
Errors must be actionable. When a human user sees a 500 error, they might retry or contact support. When an agent sees a 500 error with no structured error body, it abandons your service permanently and tries a competitor. AX-optimized error responses include machine-readable error codes, explanations of what went wrong, whether a retry is possible, and what parameters to adjust.
The Infrastructure Stack: MCP, OpenAPI, and Agent-Ready APIs
Three standards are converging to make B2A technically feasible.
Model Context Protocol (MCP)
Anthropic’s Model Context Protocol provides a standardized way for AI agents to discover and interact with external tools and services. Think of it as USB-C for AI applications: instead of every agent building custom integrations for every service, MCP provides a common interface layer. Agents can discover your capabilities, understand your data schemas, and execute actions through a consistent protocol.
The challenge is context window management. An agent cannot load your entire API documentation into its context. MCP servers need to expose capabilities through compressed, well-structured schemas that give agents what they need without consuming their entire token budget.
OpenAPI Specifications
OpenAPI (Swagger) has been the standard for API documentation for years, but B2A raises the stakes. A self-describing API using OpenAPI allows agents to ingest your spec and understand how to use your product without human intervention. Endpoints, parameters, response schemas, authentication requirements, and rate limits all need to be defined precisely enough that an agent can construct valid requests on its first attempt.
Stripe’s Agentic Commerce Suite
Stripe’s Agent Toolkit is the clearest example of B2A infrastructure in production. It enables AI agent frameworks (OpenAI’s Agent SDK, LangChain, CrewAI, Vercel’s AI SDK) to integrate with Stripe APIs through function calling. Agents can create payment links, manage subscriptions, process refunds, and handle checkout flows without any human touching Stripe’s dashboard. The toolkit makes products discoverable to agents, simplifies checkout into agent-callable functions, and processes agentic payments through a single integration.
Google, Amazon, Meta, Visa, Mastercard, and PayPal are building similar infrastructure. Google is piloting agentic checkout through Gemini with auto-cart functionality. Amazon is testing Rufus and Alexa agents for autonomous purchasing. The payment rails for B2A transactions are being laid right now.
Five Steps to Make Your Product B2A-Ready
If you are running a SaaS product, an e-commerce platform, or any service with an API, here is the concrete path to B2A readiness:
1. Audit your API coverage. Map every action a user can take in your UI. If any of those actions are not available through your API, that is functionality invisible to agents. Complete API coverage is the baseline, not a nice-to-have.
2. Publish machine-readable documentation. An OpenAPI spec is the minimum. Add structured descriptions to every endpoint, parameter, and response field. Include example requests and responses for every operation. Document error codes with clear explanations of what triggers them and how to resolve them.
3. Deploy an MCP server. If agents are going to discover your product through MCP, you need a server that exposes your capabilities in a format agents can consume. Anthropic’s documentation provides implementation guides, and the open-source community has reference implementations for most languages.
4. Fix your authentication for agents. If your only auth flow requires a browser redirect, agents cannot use your product. Add support for API keys or machine tokens with scoped permissions. Implement clear token refresh mechanisms. Document the exact permissions each scope grants.
5. Expose structured product data. For commerce companies, this means agent-optimized product catalogs with real-time pricing, inventory levels, and fulfillment estimates accessible through structured APIs. Kantar recommends starting with machine-verifiable trade promotions and analyzing agent-driven SKU selection data to understand how agents choose your products.
Who Is Already Winning in B2A
The early movers paint a clear picture of what B2A success looks like.
Stripe went all-in with its Agentic Commerce Suite, giving every major agent framework direct access to payment processing. Their bet: if agents need to charge money, Stripe becomes the default payment rail for the agentic economy.
Netlify turned AX into an acquisition channel. 1,000+ sites per day created through ChatGPT integration is not a marketing experiment; it is a business model validation.
Clerk (YC-backed authentication provider) is specifically optimizing its auth flows for coding agents from Bolt, Lovable, and Windsurf. When an AI coding agent needs to add authentication to a project, Clerk wants to be the service the agent chooses.
Neon (serverless Postgres) assembled a dedicated AI engineering team to make their database the default choice for agentic infrastructure. CEO Nikita Shamgunov is dogfooding Neon as the database agents provision when they need persistence.
The pattern is consistent: companies that design their developer experience specifically for agent consumption are capturing a distribution channel that their competitors do not even see yet.
Frequently Asked Questions
What does B2A (Business-to-Agent) mean?
B2A stands for Business-to-Agent, a business model where companies design their products and services primarily for AI agents as customers, rather than human users. Instead of optimizing landing pages and UX, B2A companies optimize their APIs, documentation, and data structures so AI agents can discover, evaluate, and transact with their products autonomously.
How is B2A different from B2B and B2C?
In B2B and B2C, a human evaluates your product through websites, demos, or sales calls. In B2A, an AI agent evaluates your product by reading your API documentation, parsing your OpenAPI spec, and testing your endpoints. The agent cares about structured data, API latency, and documentation precision rather than visual design, brand storytelling, or emotional appeals.
What is Agent Experience (AX)?
Agent Experience (AX) is the design discipline focused on making products usable by AI agents. Coined by Netlify CEO Mathias Biilmann, AX extends the progression from User Experience (UX) to Developer Experience (DX). AX requires precise machine-readable documentation, non-interactive authentication flows, actionable error responses, and discoverable API capabilities.
How do I make my API agent-ready?
Start with complete API coverage for all product functionality, then publish machine-readable OpenAPI specifications with precise documentation. Deploy an MCP (Model Context Protocol) server for agent discovery. Replace browser-based auth flows with API keys and scoped machine tokens. Finally, ensure your error responses include machine-readable codes and actionable recovery instructions.
Which companies are leading in B2A?
Stripe launched its Agentic Commerce Suite for agent-driven payments. Netlify generates 1,000+ sites per day through ChatGPT agent integration. Clerk optimizes authentication specifically for AI coding agents. Neon built a dedicated team for agentic database infrastructure. Google, Amazon, Visa, and Mastercard are all building agent-ready payment and commerce APIs.