Multi-agent commerce — when buyers send agents to negotiate

The four quadrants of agent buying

Most discussion of agentic commerce treats the buyer as a single type. It is more useful to split the buyer-side into four quadrants because each quadrant behaves differently and stresses a different part of the seller's stack. The horizontal axis is whether the buyer is acting for one individual (personal) or for an organization (business). The vertical axis is whether the purchase is one-time or recurring.

Personal one-time buying is the personal shopping agent. A user asks the agent to find a flight, a gift, a piece of furniture, a service appointment. The agent compares options, makes the decision (or short-lists for the user), and transacts. Each purchase is its own event with its own context. Personal recurring buying is subscription management. The agent owns the inventory of the user's subscriptions, manages renewals, swaps tiers, cancels what is unused, negotiates retention offers. This quadrant looks like an automated household CFO.

Business one-time buying is procurement. The agent runs an RFP-style flow inside a budget envelope, checks vendor terms, places the order, files the invoice into the AP system. Business recurring buying is the most interesting quadrant in the medium term. It looks like a continuously-optimizing software-and-services stack where the agent reviews every vendor relationship every quarter, renegotiates where leverage exists, and rotates suppliers when the contract structure allows. This is the quadrant that produces the largest absolute spend and the most asymmetric negotiation dynamic.

The four quadrants share a property: the agent is willing to spend more time per decision than a human would, because the marginal cost of agent time is near zero. That changes the seller's problem. The buyer is now arbitrarily patient, arbitrarily thorough, and capable of running parallel comparisons across every competitor simultaneously.

The negotiation surface

In current e-commerce, the negotiation surface is essentially the price tag plus a coupon field. Everything else (terms, bundle composition, delivery timeline, support level, payment schedule) is fixed by the seller in advance. When the buyer is an agent, that one-dimensional surface becomes a multi-dimensional one. Price is one axis. Timeline is another (will the agent wait two extra weeks for a 15% discount). Terms are a third (extended return window, longer warranty, monthly billing instead of annual). Bundle composition is a fourth (which add-ons are included).

An agent can rapidly explore that surface. It can ask 'what is your price if I commit to a 24-month term,' 'what is your price if I take delivery in week three instead of week one,' 'what is your bundle price if I drop feature X,' and integrate the answers into a single optimization. Most sellers have no machinery to answer those questions in real time because their pricing systems were built for the human buyer who clicks add-to-cart at the displayed price.

The early agent-aware sellers are exposing structured negotiation interfaces. They publish machine-readable price-and-terms grids, accept structured offers, and reply with structured counters. The unstructured back-and-forth that a salesperson handles by phone gets replaced with a clean offer protocol. The companies that build this protocol first set defaults that competitors then have to either adopt or fight on lock-in grounds.

Why current e-commerce sites are not agent-ready

A modern e-commerce site is built for a human eyeball. Product pages are images, marketing copy, reviews, and a buy button. The structured data (Schema.org product markup, OpenGraph tags) exists but is shallow; it covers the basics for search engines and link previews, not the granular trade-off space an agent needs to negotiate.

Most sites have no negotiation API. There is no endpoint to POST an offer and receive a counter. There is no machine-readable representation of the seller's price floor, their preferred payment terms, or which line items are negotiable. The CMS-driven product catalog assumes a single price per SKU per region per period. The promotion engine assumes a finite list of pre-authored discount codes. Neither was designed for an interactive negotiation flow.

Inventory and fulfillment systems compound the problem. Even when an agent and a seller agree on a price, the agent has no real-time read on whether the warehouse can guarantee the offered timeline. The data needed to honor a negotiated offer often lives in a separate system that the storefront cannot interrogate cleanly. Building agent-readiness end-to-end is not a single product change. It is a system-level upgrade across catalog, pricing, inventory, fulfillment, and contracts.

The proto-standards forming

Three families of standards are competing to define agent-to-agent commerce. The first is the Model Context Protocol family (MCP), originally for connecting models to tools and gradually expanding into a vocabulary for capabilities, permissions, and structured exchanges. The MCP direction is open, developer-driven, and aligned with how agents already work in practice. It does not yet have a commerce-specific dialect, but the foundations are there.

The second is the platform-defined family from the largest model providers. OpenAI has been quietly extending its developer surface in a direction that looks like an agent-platform: a way for a third-party seller to register a structured offer, expose negotiable terms, and let an agent transact through the platform's identity and billing rails. Anthropic is moving in a similar direction with Claude's tool-use surface and computer-use primitives. The platform-defined family is convenient because it ships with default identity and trust; it is risky because it concentrates the agent-commerce graph inside a single vendor.

The third is the payments-defined family. Stripe has been the most visible here, with primitives like restricted-spend keys, agent-scoped API tokens, programmatic-issuing, and emerging agent-billing affordances. The argument for the payments-defined family is straightforward: the rails already know who is paying whom and can enforce limits at the money-movement layer, which is the layer that actually matters for fraud and accountability. The risk is that the payments family covers payment but not negotiation, and the standard for the negotiation step ends up living somewhere else.

The likely outcome over the next 24 months is convergence around a hybrid: an MCP-compatible negotiation vocabulary, identity and trust primitives anchored at the platform layer, and money-movement enforcement at the payments layer. Whichever specific vendor ships the first end-to-end-working version of that hybrid gets the early-mover advantage.

Source: Model Context Protocol open specification; Stripe Sessions 2026 developer keynote on agent commerce primitives.

The seller's strategic problem

A seller facing agent buyers has three near-term decisions to make. First, whether to expose a negotiation interface or to refuse. Refusing is a defensible short-term posture (and many luxury and brand-driven sellers will choose it) but it leaves the seller invisible to a buyer cohort that is starting to do most of its discovery through agents. Sellers who do not appear in the agent's comparison set lose the deal before the human ever sees the option.

Second, whether to run a counter-agent. The seller's pricing decisions, retention offers, and bundle composition are themselves an optimization problem. An agent on the seller's side, watching the inbound offers and learning from outcomes, beats a static rules engine by a wide margin. The early counter-agent vendors are building exactly this: a pricing-and-offer agent that sits behind the storefront and answers buyer-agent offers in milliseconds.

Third, what price floors and rules to set. A seller cannot let an agent negotiate to zero. The seller has to encode the constraints (minimum margin, capacity utilization targets, strategic-account exceptions) into rules that the counter-agent enforces. Encoding these rules well is a senior pricing-strategist job that most companies have historically done by spreadsheet. Doing it programmatically and in real time is a new operational capability.

What happens to brand and discovery

If a meaningful fraction of buying is mediated by agents, the marketing apparatus that current brands depend on has to be re-examined. Brand-building through display, social, and creator marketing is optimized for human attention and human emotional response. Agents do not have emotional response. They have specifications, prior data on the brand's delivery history, and the buyer's stated preferences.

The pessimistic read is that brand erodes and price becomes the only axis. The optimistic read is that the function of brand shifts from emotional shortcut to verified reliability signal. An agent will repeatedly choose the brand that has historically delivered on its negotiated terms, because the agent has the memory and the patience to track that history. Brand becomes operational trust at machine scale.

Discovery shifts accordingly. The agent does not browse a category page. It runs structured queries against a directory of agent-readable sellers. The SEO surface that has driven e-commerce traffic for two decades stops being load-bearing in the categories that go agent-first. New discovery infrastructure (agent-readable catalogs, structured-review databases, machine-verifiable reputation scores) becomes the equivalent of the SEO infrastructure of the 2010s. Companies are already building it, mostly in stealth.

Regulatory and trust questions

Liability is the most pressing open question. If a personal shopping agent buys the wrong item or commits to a subscription the user did not authorize, who is liable. The platform that hosted the agent, the seller that accepted the order, or the user who deployed the agent. Current consumer-protection law assumes a human-in-the-loop and does not cleanly apply. The EU AI Act's provisions on automated decisions touch this area but do not resolve it. Several US state attorneys general have signaled investigations are coming on agent-initiated charges that consumers dispute.

Disclosure is the second question. Does a seller owe the buyer's human principal a notice that they transacted with an agent rather than a person, and what does the disclosure look like. Does the agent owe the seller a notice that it is an agent rather than a human, and what does that disclosure unlock or restrict. The plausible regulatory direction is that mutual disclosure becomes mandatory in consumer transactions above a threshold, in line with how robocall and automated-trading rules evolved.

Trust infrastructure has to be built. The current internet identity stack (OAuth, passkeys, the various federated-identity standards) was built for human-to-service authentication. Agent-to-service authentication needs delegated-permission primitives that scope the agent's authority precisely (this agent can spend up to $X per month, only on these categories, only from these sellers), revoke cleanly, and audit transparently. The companies that ship the working delegated-permission layer for agents get the same kind of default position that Auth0 and Okta took in the previous identity wave.

Strategic read

Multi-agent commerce is not a UX feature. It is a platform-level rewrite of how buying and selling work, comparable in scope to the e-commerce transition itself. The companies positioning themselves at the negotiation layer (Stripe at the rails end, MCP-aligned tooling at the protocol end, the early counter-agent vendors at the seller end) are competing for the equivalent of payment-processor or marketplace-default status in a new graph that has not yet hardened.

For an operator, the question is not whether to participate. The default position (do nothing, wait for standards) is the position that gets disintermediated. The question is which slice of the agent-commerce stack to build into: pricing engine, counter-agent, agent-readable catalog, delegated-permission layer, agent-aware fraud, or a vertical commerce graph for a specific category. Each is a non-trivial business in its own right.

For an investor, the lens is that the negotiation surface is where most of the new operating margin will sit. Payment processing remains a take-rate business with relatively predictable economics. Negotiation infrastructure is a higher-leverage layer where the margins look more like software than like rails, and where the winner-take-most dynamic is stronger. The bottleneck shifts from payment volume to negotiation-protocol ownership.