This agentic commerce glossary defines the 30 terms every practitioner, product leader, and merchant needs to understand as AI agents move from assistant to buyer. The vocabulary here spans the full stack — from the economic logic of intent delegation down to the token-level mechanics of agent authentication — giving you a working reference that covers both the conceptual layer and the engineering layer in one place.
Why does precise language matter here? Because agentic commerce is not e-commerce with a chatbot bolted on. It is a structurally different mode of transacting in which the decision-maker is a machine acting on a human's behalf, and the trust, liability, and payment rails must be redesigned to match. The terms below reflect the emerging consensus from Anthropic's Model Context Protocol specification, Visa's AI commerce research, Google's Agent-to-Agent protocol proposal, and merchant platform integrations already live in production. Fluency with this vocabulary is the baseline for building anything in this space without misunderstanding your own architecture.
Why This Glossary Exists
Agentic commerce is moving faster than its vocabulary. Teams building agent-driven checkout flows are using "autonomous purchasing," "delegated commerce," and "intent delegation" interchangeably, which creates dangerous ambiguity around liability, authorization scope, and regulatory compliance. Platform documentation — from Shopify's Checkout API to Stripe's machine-learning fraud systems — was not written with non-human buyers in mind. The gap between how practitioners talk about this technology and what they actually mean is wide enough to introduce real bugs, real legal exposure, and real broken integrations.
This glossary closes that gap. Each definition is tied to a concrete platform, published protocol, or real-world deployment context. Wherever terms are genuinely contested or still evolving in standards bodies, that uncertainty is noted rather than papered over with false confidence. Use this as a living reference, not a fixed canon — the field is moving, and so is the terminology.
Core Concepts
Agentic Commerce
Agentic commerce is the mode of economic exchange in which an AI agent — acting under explicit or inferred authority from a human principal — discovers, evaluates, negotiates, and completes commercial transactions autonomously. The defining characteristic is that the agent exercises judgment at one or more stages of the purchase funnel rather than merely surfacing options for the human to act on. For a deeper treatment of the category, see our complete guide to what agentic commerce is and how it works.
Unlike traditional e-commerce automation (macros, saved carts, price-alert bots), agentic commerce involves an agent that can reason under uncertainty, handle novel product configurations, and adapt its behavior to changing constraints — budget shifts, inventory changes, competing preference signals — without returning to the human for instruction at each step.
AI Shopping Agent
An AI shopping agent is a software system — typically built on a large language model with tool-use capabilities — that executes the search, comparison, selection, and purchase stages of a shopping workflow on behalf of a user. Examples include Perplexity's shopping mode, OpenAI's GPT-based shopping integrations, and purpose-built agents such as Rabbit's LAM and early deployments from retail platforms like Walmart and Amazon. For a technical breakdown of how these systems operate under the hood, see how AI shopping agents work.
The agent's quality is determined by how well it encodes the user's preferences (explicit rules vs. inferred taste), how reliably it calls external tools (search APIs, product catalog APIs, checkout APIs), and how robustly it handles failure states like out-of-stock items or failed payment authorization.
Autonomous Commerce
Autonomous commerce refers to the broader infrastructure condition in which commercial transactions can be initiated, negotiated, and settled between systems without requiring human approval at the transaction level. It encompasses both business-to-business supply chain automation (e.g., IoT sensors auto-reordering industrial parts when inventory crosses a threshold) and consumer contexts (an AI agent renewing a software subscription when a pricing condition is met). Autonomous commerce is the end-state category; agentic commerce is the human-delegated subset within it.
The term is distinct from "automated commerce" (rule-based triggers) because autonomous systems exercise contextual judgment. A reorder bot that fires when stock drops below 100 units is automated. An agent that evaluates three suppliers, negotiates lead times, and selects the optimal vendor given current exchange rates is autonomous.
Machine-to-Machine Commerce (M2M)
Machine-to-Machine Commerce (M2M) is the exchange of goods, services, or data between two systems with no human in the transactional loop at the time of execution. Classic M2M examples include automated cloud resource procurement (an AWS Lambda function purchasing additional compute capacity) and programmatic ad exchange (DSPs bidding on impression inventory in under 100 milliseconds). The emerging agentic layer extends M2M to general-purpose commercial decisions that previously required human discretion. See our dedicated explainer on machine-to-machine commerce for a full taxonomy of M2M transaction types.
M2M commerce introduces novel challenges around audit trails, fraud detection, and regulatory compliance because traditional KYC (Know Your Customer) frameworks were designed for human counterparties. Visa's 2024 research on AI commerce cited M2M payment settlement as one of the top three unsolved infrastructure problems in the space.
Intent Delegation
Intent delegation is the process by which a human principal encodes their purchasing goals, constraints, and preferences into a form that an AI agent can interpret and act on without requiring per-transaction approval. A user who tells their agent "book me a direct flight under $400 with a window seat and no layovers" has delegated their intent; the agent is then authorized to transact within that envelope. Intent delegation is to agentic commerce what a purchase order is to procurement — a structured, bounded authorization.
The precision of intent delegation directly determines the scope of an agent's authority. Vague delegations ("get me something good") require the agent to infer heavily and create liability ambiguity. Well-formed delegations specify price ceilings, quality thresholds, preferred vendors, and exclusion criteria. Most current agent frameworks — including those built on Anthropic's Claude and OpenAI's GPT-4o — store delegated intent as system prompt instructions supplemented by structured preference files.
Agentic Purchasing
Agentic purchasing is the specific act of an AI agent completing a purchase transaction — not merely recommending or surfacing products, but executing the checkout: selecting the item, applying payment credentials, confirming the order, and handling post-purchase steps like confirmation emails or return registration. It is the transactional leaf node of the broader agentic commerce workflow. Agentic purchasing requires the agent to have both the authorization to spend (delegated authority) and the technical capability to interface with merchant checkout systems (tool use, checkout API access).
The distinction from "AI-assisted purchasing" is material: in AI-assisted purchasing, the human clicks "buy." In agentic purchasing, the agent clicks "buy" — and the merchant, payment processor, and issuing bank must all recognize the agent as a valid transacting party. This is the central unsolved problem in agentic payment rails as of 2025.
Protocols & Standards
Agentic Commerce Protocol (ACP)
The Agentic Commerce Protocol (ACP) is a proposed open standard designed to define how AI agents communicate with merchant systems to discover products, negotiate terms, and execute transactions in a structured, interoperable way. ACP aims to do for agent-merchant interaction what HTTP did for browser-server communication — establish a common message format so that any compliant agent can transact with any compliant merchant without bespoke integration work. As of mid-2025, ACP is in active drafting stages with input from commerce platform vendors, AI labs, and payment networks.
The protocol addresses three layers: discovery (how agents find what merchants sell), negotiation (how agents query for pricing, availability, and terms), and execution (how agents complete authenticated purchase transactions with proper liability attribution). Adoption is nascent, but several commerce infrastructure companies are building ACP-compatible endpoints in anticipation of standardization.
Universal Commerce Protocol (UCP)
The Universal Commerce Protocol (UCP) is a competing or complementary specification to ACP, focused on establishing a vendor-neutral schema for product representation, pricing rules, and transaction records that any AI agent or automated buyer can parse. Where ACP emphasizes the communication handshake between agent and merchant, UCP emphasizes the data schema of the commerce objects themselves — product listings, availability signals, promotional terms — so that agents don't require merchant-specific parsing logic for each catalog.
UCP draws conceptual lineage from GS1 standards (the barcode and product-data organization that governs physical retail) and adapts them for the API-native, machine-readable context of agentic interactions. A merchant that publishes a UCP-compliant product feed is, in theory, immediately legible to any agent trained to consume the protocol.
Model Context Protocol (MCP)
The Model Context Protocol (MCP) is an open protocol published by Anthropic in November 2024 that defines a standard interface for connecting AI models to external tools, data sources, and services. MCP uses a client-server architecture in which the AI model (client) calls MCP servers that expose tools — functions the model can invoke to take actions in the real world, including placing orders, querying inventory, or authenticating with merchant systems. MCP has rapidly become the de facto standard for giving large language models structured access to external capabilities.
In agentic commerce, MCP servers are the mechanism by which an AI shopping agent calls a retailer's checkout API, reads a product catalog, or submits a payment credential. The protocol specifies how tools are described (via JSON Schema), how calls are made, and how results are returned — all in a way that is model-agnostic, meaning any MCP-compatible model can use any MCP-compatible commerce tool without custom glue code.
Agent-to-Agent (A2A) Protocol
The Agent-to-Agent (A2A) Protocol is a specification, initially proposed by Google in early 2025, that defines how autonomous AI agents communicate and coordinate with each other to complete multi-step tasks. In a commerce context, A2A enables an orchestrating "buyer agent" to delegate subtasks to specialized sub-agents: one agent might handle price comparison, another handles payment credential selection, and a third manages post-purchase logistics — all communicating via A2A message formats. The protocol addresses authentication between agents, task handoff semantics, and result verification.
A2A is particularly important in agentic commerce scenarios where a single purchase involves multiple AI systems operated by different organizations — for example, a user's personal AI agent coordinating with a merchant's AI concierge agent and a logistics AI that manages fulfillment routing. Without A2A, these interactions devolve to bespoke integrations; with it, multi-agent commerce pipelines become composable.
llms.txt
llms.txt is a proposed convention, analogous to robots.txt, in which
websites publish a structured plain-text file at domain.com/llms.txt that tells AI agents
and large language model crawlers what content the site makes available for machine consumption, what
actions agents are permitted to take, and what endpoints are agent-accessible. For merchants, an
llms.txt file signals agent-readiness and provides a machine-readable map of the site's
agentic commerce capabilities — checkout APIs, product catalog endpoints, return policy rules — without
requiring an agent to scrape or infer the site's structure.
The convention was proposed by Answer.AI's Jeremy Howard in 2024 and has been adopted by a growing list
of documentation sites and commerce platforms. In the agentic commerce context, llms.txt
functions as a site's "agent welcome mat" — the first file a well-behaved shopping agent should check
before attempting to interact with a merchant's systems.
Agent-Engine Optimization (AEO)
Agent-Engine Optimization (AEO) is the practice of structuring a merchant's product data,
content, and APIs so that AI shopping agents can discover, parse, and transact with the merchant's
inventory with minimal friction. AEO is to agentic commerce what SEO is to search engines — a discipline
of making your content and commerce infrastructure legible to the systems that drive traffic and
transactions. AEO tactics include publishing structured product data, maintaining an llms.txt
file, exposing MCP-compatible endpoints, and writing product descriptions in answer-first, fact-dense
formats that agent reasoning layers can extract and evaluate reliably. AEO is also covered as a standalone
business discipline in the Business & Market Terms section below.
Technical Infrastructure
Tool Use / Function Calling
Tool use (also called function calling) is the capability of a large language model to invoke predefined external functions — APIs, database queries, browser actions, form submissions — as part of its reasoning and execution process. Rather than generating a text answer, the model generates a structured call to a named function with specified parameters, receives the result, and incorporates it into its next reasoning step. OpenAI's GPT-4 function calling (launched June 2023) and Anthropic's Claude tool use API are the dominant implementations; both follow similar JSON Schema-based function description formats.
In agentic commerce, tool use is how an AI shopping agent actually does things: it calls a
search_products function, receives a list of matching items, calls a
get_pricing function for the top candidates, and eventually calls an
initiate_checkout function to complete the purchase. Without tool use, an AI agent is
advisory only; with it, the agent becomes an actor in the commercial system.
AI Orchestration Layer
The AI orchestration layer is the software infrastructure that manages the coordination of multiple AI models, tools, and data sources to complete a complex multi-step task. In agentic commerce, the orchestration layer sequences the steps of a purchase workflow — intent parsing, product search, comparison evaluation, payment credential selection, checkout execution, confirmation handling — and manages error recovery, retries, and state persistence across the workflow. Frameworks such as LangGraph, CrewAI, and AutoGen are commonly used to implement orchestration layers for commerce agents.
The orchestration layer is distinct from the underlying AI model: the model reasons; the orchestration layer decides what the model should reason about next, routes tool call results back to the model, and maintains the session state that lets a multi-step shopping workflow survive interruptions like a failed API call or a merchant timeout.
Virtual Payment Credential
A virtual payment credential is a tokenized, policy-bound payment instrument generated specifically for use by an AI agent, distinct from the human user's primary payment card. Instead of giving an agent access to a real credit card number, the issuing bank or payment platform generates a virtual credential with embedded spending controls: a maximum transaction amount, permitted merchant category codes, a single-use or time-bounded validity window, and geographic restrictions. Visa's 2024 agentic payments research outlined virtual credentials as the primary mechanism for making AI-initiated payments auditable and fraud-resistant.
Virtual payment credentials map cleanly onto the principle of least privilege from information security: the agent gets exactly the payment authority it needs for a specific delegated task, and no more. If a shopping agent is authorized to buy office supplies up to $200, its virtual credential is provisioned with a $200 cap and an MCC restriction to office supply merchants — so a compromised agent cannot spend beyond its mandate.
Scoped Authorization
Scoped authorization is the principle and implementation of granting an AI agent access
only to the specific data, actions, and resources required for a defined task, rather than broad or
open-ended access to a user's accounts or merchant systems. In OAuth 2.0 terms — the framework most
commerce APIs use for authorization — scoped authorization means issuing an access token with a narrow
set of permissions (e.g., read:catalog, write:cart,
execute:checkout) rather than a broad token that grants full account access.
For agentic commerce, scoped authorization is a foundational safety control. An agent authorized to purchase from a specific merchant should not be able to access the user's account history at other merchants, modify their shipping address, or initiate refunds — unless those scopes are explicitly granted. Platforms including Shopify and Stripe already implement granular OAuth scopes that are well-suited to agent integrations; the agentic commerce design pattern is to request the minimum viable scope per task. For a full treatment of how payment APIs handle agent authorization, see AI agent payment APIs.
Checkout API
A Checkout API is a programmatic interface exposed by a merchant or commerce platform that allows external systems — including AI agents — to initiate, populate, and complete purchase transactions without requiring a human to interact with a web-based checkout UI. Shopify's Checkout API, BigCommerce's Checkout API, and Stripe's Payment Intents API are the most widely deployed examples. A Checkout API typically accepts a cart payload (items, quantities, selected variants), applies a payment credential, validates inventory, and returns an order confirmation.
For AI shopping agents, the Checkout API is the final tool call in a purchase workflow — the point at which an agent's product selection becomes a committed commercial transaction. The design of the API determines much of the agent's capability: APIs that support headless cart operations, guest checkout flows, and machine-readable error responses are far more agent-compatible than those that assume a human is navigating a browser session.
Product Catalog API
A Product Catalog API is a structured interface that gives external systems — including AI shopping agents — programmatic access to a merchant's product inventory, including item attributes, variants, pricing, availability, media assets, and fulfillment options. Shopify's Admin API, Amazon's Product Advertising API, and Google's Content API for Shopping are representative examples. A well-designed Product Catalog API returns machine-readable data in a schema that an agent can parse without natural language inference — structured fields rather than marketing prose.
For Agent-Engine Optimization, the quality of a merchant's Product Catalog API is a primary determinant of whether AI agents can accurately represent their inventory. Agents that cannot reliably parse variant-level pricing, real-time stock levels, or bundle configurations will make incorrect purchase decisions, leading to cancellations and poor user experience. Merchants serious about agent readiness prioritize API completeness and schema clarity over API aesthetics.
Identity & Trust
Know Your Agent (KYA)
Know Your Agent (KYA) is the emerging framework for verifying, authenticating, and maintaining audit records of AI agents that participate in commercial transactions, analogous to Know Your Customer (KYC) frameworks in financial services. A KYA process establishes: who built the agent, which human principal authorized it, what spending authority it holds, and what behavioral policies govern its actions. Financial institutions, payment processors, and enterprise merchants are beginning to require KYA-equivalent disclosures as a condition of accepting AI-initiated payment transactions.
KYA is motivated by the fraud and liability questions that arise when a non-human initiates a purchase. If an AI agent commits to a $50,000 enterprise software contract, the merchant needs a verifiable chain of authority connecting that agent's action to a human or organization with contractual capacity. KYA frameworks are being developed by financial industry working groups including those affiliated with SWIFT, Nacha, and the emerging agentic commerce standards bodies.
Agent Identity
Agent identity is the verifiable, persistent representation of a specific AI agent — its origin (which platform built it), its authorization scope, its version, and its operating policies — in a form that merchant systems, payment processors, and other agents can authenticate and act on. Agent identity is to agentic commerce what a user account is to traditional e-commerce: the persistent identifier that anchors transactions, audit logs, and liability records to a specific acting entity.
Current implementations of agent identity range from simple API key schemes (a unique key issued to an agent deployment) to more sophisticated approaches involving signed identity assertions — cryptographically verifiable claims about an agent's origin and authority, analogous to X.509 certificates for web servers. Anthropic, Google, and several commerce infrastructure companies are actively working on interoperable agent identity standards as of 2025.
Non-Human Principal
A non-human principal is an AI agent or automated system that holds and exercises a recognized authority to act within a commercial or legal context, distinct from the human principal who delegated that authority to it. The term comes from principal-agent theory in economics and law, where a "principal" is the party on whose behalf an agent acts. In agentic commerce, recognizing the agent as a distinct (non-human) principal is necessary for correctly attributing liability, structuring authorization tokens, and designing audit trails that distinguish human-initiated from agent-initiated actions.
Regulatory frameworks are beginning to grapple with non-human principals. The EU AI Act's provisions on high-risk AI systems, and emerging FTC guidance on AI in commercial contexts, both implicitly engage with the question of what legal standing an AI agent has when it enters into commercial commitments — a question that resolves differently depending on whether the agent is classified as a tool of the human principal or as a distinct actor.
Delegated Authority
Delegated authority is the specific, bounded grant of permission that a human principal transfers to an AI agent, authorizing the agent to take defined actions — including commercial transactions — within defined limits, on the principal's behalf. Delegated authority is the legal and technical basis for agentic purchasing: without it, an agent's purchase actions have no contractual foundation. Delegated authority frameworks in agentic commerce typically specify: authorized merchant categories, maximum transaction values, validity windows, geographic restrictions, and revocation conditions.
The concept maps onto existing legal doctrines of agency — specifically the law of actual authority and apparent authority — but requires new implementation mechanisms (machine-readable authorization tokens, cryptographically signed delegation chains) because the agent cannot sign contracts or appear in person to demonstrate authorization. Well-designed agentic commerce systems make delegated authority explicit, auditable, and revocable in real time.
Agent Authentication Token
An agent authentication token is a cryptographically signed credential issued to an AI agent that proves, to a merchant or payment processor, that the agent is authorized to act on a specific user's behalf within defined parameters. Unlike a standard OAuth bearer token — which authenticates a user — an agent authentication token authenticates a (user, agent, scope) triple: it asserts that this specific agent is authorized by this specific user to perform this specific class of actions. Payment platforms building agent-native infrastructure (including early work from Stripe and Adyen) are designing token formats that carry embedded spending policy rather than relying on separate authorization checks.
Agent authentication tokens are the core technical mechanism for implementing scoped authorization in practice. They can be short-lived (single-use, expiring after transaction completion), scoped to a merchant, and tied to a virtual payment credential — creating a complete, auditable authorization envelope for each agent-initiated transaction.
Liability Chain
The liability chain in agentic commerce is the documented sequence of responsible parties — human principal, agent platform, AI model provider, merchant, payment processor — whose actions and authorizations contributed to a given transaction, and who bears responsibility if that transaction is disputed, fraudulent, or unauthorized. Establishing a clear liability chain is the central legal engineering challenge in agentic commerce: when an AI agent makes a purchase the user disputes, determining whether liability rests with the agent platform (for acting outside its delegated scope), the AI model provider (for misinterpreting intent), the merchant (for failing to verify agent authority), or the payment processor (for clearing an unauthorized transaction) requires a documented chain of events and authorizations.
Liability chains are constructed through a combination of agent authentication tokens, transaction logs, delegation records, and policy assertions. The more granular and cryptographically verifiable the authorization chain, the cleaner the liability attribution — which is why the KYA, agent identity, and scoped authorization frameworks above are prerequisites for commercially serious agentic deployments.
Business & Market Terms
Agent-Ready Merchant
An agent-ready merchant is a retailer or service provider whose commerce infrastructure
has been deliberately designed or adapted to support AI agent buyers: they expose clean Checkout APIs and
Product Catalog APIs, publish an llms.txt file, support scoped authorization for agent
credentials, and return machine-readable error responses rather than HTML error pages. Being agent-ready
is increasingly a competitive differentiator as AI shopping agents route purchases toward merchants whose
systems they can reliably interact with and away from merchants whose checkout flows require human browser
navigation.
The practical checklist for agent readiness includes: headless checkout support, structured product data with complete variant schemas, real-time inventory signals, support for virtual payment credentials, and documentation oriented toward developer/machine consumers rather than human shoppers. Merchants who invest in agent readiness now are positioning for the wave of AI-driven purchase traffic projected to materialize at scale through 2026–2028.
Agent-Engine Optimization (AEO)
Agent-Engine Optimization (AEO) is the strategic and tactical discipline of making a merchant's products, content, and commerce infrastructure maximally discoverable and transactable by AI shopping agents. AEO operates at three levels: content (writing product descriptions in factual, structured prose that agents can extract and reason about accurately), data (publishing clean, complete, schema-compliant product feeds), and infrastructure (exposing agent-compatible APIs and authentication flows). AEO is the commerce parallel to traditional search engine optimization, with AI agents replacing search engine crawlers as the primary audience.
Concrete AEO tactics include: publishing an llms.txt file at the domain root, implementing
JSON-LD Product schema on product pages, ensuring Product Catalog API responses include all variant-level
attributes (not just top-level item data), writing return and shipping policies in structured formats
agents can parse, and monitoring whether your products appear in AI shopping agent outputs the way you
intended. Early-mover AEO advantage is significant: agents that successfully transact with a merchant are
likely to prioritize that merchant in future recommendations due to reliability signals in their training
and tool-call history.
Agentic Commerce Stack
The agentic commerce stack is the layered set of technologies — model, orchestration, tool integrations, identity, payment, and data layers — that together enable an AI agent to execute end-to-end purchase transactions. A representative agentic commerce stack includes: a foundation model (Claude, GPT-4o, Gemini) at the reasoning layer, an orchestration framework (LangGraph, AutoGen) managing workflow state, MCP servers connecting the agent to external tools, a product discovery integration (Product Catalog API), a payment integration (virtual payment credentials via Stripe or Adyen), and an identity layer (agent authentication tokens, scoped OAuth). The stack concept is useful for diagnosing which layer is responsible for a given failure mode — misidentified products point to the data layer; failed checkouts point to the payment or tool integration layer.
Unlike a traditional e-commerce tech stack (which centers on a storefront, a cart, and a payment gateway), the agentic commerce stack centers on the agent's reasoning capability and its ability to compose tool calls across multiple merchant and payment systems in a single coherent session.
Merchant of Record
The Merchant of Record (MoR) is the legal entity that accepts payment from a buyer, bears the liability for the transaction, handles tax remittance, and is named in the payment processor's records as the seller for a given sale. In traditional e-commerce, the MoR is straightforwardly the retailer. In agentic commerce, MoR designation becomes more complex: when an AI agent platform facilitates a purchase between a user and a third-party merchant, the question of who is the MoR — the agent platform, the underlying merchant, or a marketplace intermediary — has significant tax, liability, and fraud-chargeback implications.
Several agentic commerce platform designs involve the agent platform taking MoR status (similar to how Stripe operates as MoR in some subscription billing contexts), which simplifies the merchant integration but creates regulatory obligations for the platform. Alternatively, the underlying merchant retains MoR status and the agent platform acts purely as a referral or integration layer — cleaner from a regulatory standpoint but requiring the merchant to support the agent's technical interface requirements directly.
Preference Encoding
Preference encoding is the process of representing a user's purchasing preferences, values, and constraints in a structured, machine-readable format that an AI agent can interpret and apply consistently across shopping sessions. Preference encoding goes beyond a simple wishlist: it captures priority ordering among competing criteria (e.g., sustainability > price > speed), hard exclusions (never buy from vendor X, never exceed $Y), style parameters, brand loyalty signals, and contextual rules (business purchases versus personal purchases). The richer and more precise the preference encoding, the more accurately an agent can execute purchases that the user would endorse.
Current preference encoding approaches range from natural language preference statements stored in agent memory (simple but ambiguous) to structured JSON objects with typed fields for price ranges, vendor allowlists, product attribute preferences, and spend policy rules (more reliable but requiring more setup from the user). As agentic commerce matures, interoperable preference schemas — potentially analogous to vCard for contact data — are likely to emerge so that preferences set in one agent platform can be ported to another.
Commerce Delegation
Commerce delegation is the formal act of transferring specific commercial authority — the right to search, negotiate, select, and purchase on one's behalf — from a human principal to an AI agent, including the specification of the scope, duration, and conditions of that authority. Commerce delegation is the commercial-legal instantiation of intent delegation: where intent delegation describes the user's goals, commerce delegation describes the authorization structure that allows the agent to act on those goals within defined boundaries. A well-formed commerce delegation specifies: authorized product categories, maximum spend per transaction and per period, authorized merchants, authorization validity window, and revocation mechanism.
Commerce delegation frameworks are beginning to appear in enterprise procurement platforms (where AI agents are being authorized to place purchase orders within pre-approved vendor and category limits) and in consumer agent platforms (where users configure spending envelopes for their AI assistants). The robustness of the delegation framework — how precisely it constrains the agent and how reliably those constraints are enforced at the payment layer — determines whether agentic purchasing is safe enough for mainstream consumer adoption.
Frequently Asked Questions
What is the difference between agentic commerce and e-commerce?
E-commerce is a channel: a human buyer uses a website or app to discover and purchase products. Agentic commerce is a behavioral shift: an AI agent discovers and purchases products on the human's behalf, exercising judgment at multiple stages of the funnel. The underlying merchant infrastructure may be the same — the same products, the same payment rails — but the buyer identity, the authorization model, the liability chain, and the optimization levers (AEO rather than SEO) are structurally different. Agentic commerce requires merchants to design for machine buyers, not just human ones.
Which AI agents can currently make purchases autonomously?
As of mid-2025, autonomous purchasing capability exists in production at several tiers. Perplexity's shopping mode can complete purchases on certain merchant integrations. OpenAI's GPT-4o with browsing and action capabilities can interact with web checkout flows. Specialized agents from platforms like Rabbit and specific enterprise procurement tools have production purchasing capability within defined merchant networks. However, fully general autonomous purchasing — an agent that can reliably buy from any merchant without human confirmation — remains an active development frontier, constrained primarily by the lack of standardized agent authentication and checkout API compatibility.
How does an AI agent pay for purchases?
AI agents currently pay through several mechanisms, each with different security properties. The most common approach is a stored payment credential (a credit card or digital wallet linked to the user's account in the agent platform) that the agent uses on the user's behalf — functionally similar to a saved card in a browser. The more secure and emerging approach is virtual payment credentials: single-use or policy-bound payment tokens provisioned specifically for the agent, with embedded spending limits and merchant restrictions. See AI agent payment APIs for a detailed breakdown of the payment infrastructure layer.
What is the role of the Model Context Protocol (MCP) in agentic commerce?
MCP is the plumbing that connects AI agents to commerce tools. Without MCP (or a similar protocol), every agent-to-merchant integration requires custom code: the agent developer has to build a bespoke connector for each retailer's API. With MCP, merchants and platform providers publish MCP servers that expose their commerce capabilities (product search, cart management, checkout) in a standard format. Any MCP-compatible agent can then use any MCP-compatible merchant tool without custom integration work. MCP is to agentic commerce what the browser was to the web: it makes the ecosystem composable rather than a collection of isolated proprietary connections.
What legal risks should merchants be aware of with agent buyers?
The primary legal risks are: unauthorized transaction liability (if an agent acts outside its delegated scope, who bears the cost of the unauthorized purchase?), fraud exposure (agent-initiated transactions are a new attack surface for fraud — both agents deceived into making fraudulent purchases and fraudulent agents making unauthorized purchases), and tax compliance (if an agent platform is the merchant of record, the tax remittance obligations may shift). Merchants should require agent authentication tokens as a condition of accepting agent-initiated transactions, implement transaction monitoring calibrated to non-human purchase patterns, and consult with payment counsel on MoR designation in agent-intermediated sales.
How should merchants start preparing for agentic commerce today?
Merchants should prioritize four actions. First, audit your checkout for headless compatibility: can
a system without a browser complete a purchase via your API? Second, publish a clean, complete
product catalog via a structured API or feed that a machine can parse without inference. Third,
publish an llms.txt file at your domain root to signal agent readiness and document
your agent-accessible endpoints. Fourth, engage your payment processor about virtual payment
credential acceptance and scoped authorization support. Merchants who complete these four steps are
structurally positioned to capture agentic commerce traffic as AI shopping agents mature. For a
roadmap, start with
what agentic commerce is and how the ecosystem is evolving.
Further Reading and Related Topics
This agentic commerce glossary is one part of a larger content cluster on agenticcommerce.report. To go deeper on specific topics covered here:
- What Is Agentic Commerce? — the parent pillar covering the full economic and technical landscape, including market sizing, adoption curves, and the key players building the category.
- How AI Shopping Agents Work — a technical deep-dive into the architecture of AI shopping agents: reasoning loops, tool call sequences, memory models, and failure modes.
- AI Agent Payment APIs — a practitioner's guide to the payment infrastructure layer: virtual credentials, scoped authorization, token formats, and the processors building agent-native rails.
- Machine-to-Machine Commerce — a detailed treatment of fully automated commerce between systems, including B2B supply chain automation, programmatic procurement, and the IoT commerce layer.
The vocabulary in this glossary will evolve as protocols are ratified, platforms ship production-grade agent commerce features, and regulators begin formalizing the legal treatment of non-human principals. Bookmark this page — it is updated as the standard language of the field shifts.