NEWZinc Agent — agents buy anything online
Pricing
Login
All Blogs
Guides

Agentic Commerce in 2026: The Complete Developer Guide

Agentic commerce lets AI agents buy on your behalf. Here's the 3-layer stack, the protocols powering it, and what's actually live in production today.

Agentic Commerce in 2026: The Complete Developer Guide

We taught AI to write code, make art, and pass the bar exam. But until very recently, it still couldn't order toilet paper.

That's the disconnect agentic commerce is trying to close. Models can now reason about a purchase, compare options, and draft a checkout form, but executing the actual transaction at a real retailer has been the missing piece. McKinsey projects $3 to $4.4 trillion in agent-mediated commerce by 2030. Most of the infrastructure required to hit that number does not exist yet.

This guide breaks down what agentic commerce actually is, what's live in production today, what's still hype, and the three-layer stack developers need to build it. We'll cover the protocols (ACP, AP2, MCP, MPP), the execution layer everyone skips over, and show real working code.

What is agentic commerce?

Agentic commerce is online shopping where AI agents research, compare, and complete purchases on behalf of a user or business. The human sets the goal ("book me the cheapest nonstop flight that lands before noon"), the agent finds options, negotiates constraints, and executes the transaction.

Three capabilities separate an agentic system from a chatbot or recommendation engine:

  • Autonomy. The agent acts without step-by-step prompts. You set guardrails, it runs inside them.
  • Reasoning. The agent adapts to price changes, stockouts, and shipping delays. It doesn't restart from scratch when a constraint moves.
  • Interoperability. The agent talks to other agents, merchant APIs, and payment rails through open protocols instead of bespoke integrations.

Salesforce calls this the shift from "AI assistance" to "AI autonomy and action." IBM's 2026 Institute for Business Value study found 45% of consumers already use AI for part of their buying journey, mostly for deal hunting and review interpretation. The more consequential shift is what happens when those same agents can click "buy" without the user ever touching a checkout page.

The hype vs. the reality

Not all of this is real yet. If you read consulting decks, agentic commerce sounds like it's already everywhere. If you ask working e-commerce operators, you get a different answer.

What's working today:

  • B2B procurement. Reordering known supplies at best price. Low trust, high frequency, clean specs.
  • Buy-now-pay-later marketplaces. Agent finds a product, user finances it, agent places the order. Abunda processed $19.1M this way.
  • Corporate gifting. Employee anniversaries, client gifts, new-hire welcome kits. Clear inputs, automated output.
  • Rewards redemption. Points redeem for physical items, agent orders and ships them.
  • ChatGPT, Perplexity, and Gemini shopping interfaces. Users ask for a product, the model shows cards with a checkout button. Almost entirely Shopify stores right now.
  • AI shopping agents like Zinc GPT. Open-source reference agents that actually complete the purchase inside the chat.

What's still mostly hype:

  • Autonomous fashion shopping. Nobody's trusting a bot to pick their shoes.
  • High-consideration purchases. Laptops, cars, real estate. Humans want to research.
  • Trust-sensitive categories. Health, baby products, anything where a wrong recommendation has consequences.
  • Pure agent-to-agent negotiation. The demos exist. The production traffic doesn't.

The practitioners on r/ecommerce summed it up well: the agent-makes-all-your-decisions narrative is overhyped, but the "ChatGPT has buy buttons now" shift is real and happening fast. It's less a revolution and more a distribution change. The stores that set up their product data for agent discovery first will win the same way early SEO winners did.

If you're building, ignore the fashion-agent demos and look at procurement, BNPL, gifting, and rewards. That's where real volume is flowing.

The three layers of the agentic commerce stack

Almost every "what is agentic commerce" article treats this as one monolithic concept. It's not. Building an agentic commerce system requires three distinct layers, each with its own providers and protocols.

Layer 1: Model / UX

Where the user interacts with the agent.

  • Foundation models: GPT-5, Claude 4, Gemini 2
  • Agent frameworks: LangChain, LangGraph, Mastra, Anthropic's MCP tool ecosystem
  • Consumer surfaces: ChatGPT, Perplexity, Claude, Gemini
  • Custom agents: your own chatbot, Slack bot, WhatsApp integration

This layer handles conversation, intent parsing, and plan generation. It decides what to buy. It does not handle payment or execution.

Layer 2: Payment protocol

How the agent authenticates and pays.

These protocols solve "how does an agent prove it can pay" without requiring a human to pre-configure accounts, API keys, and credit cards.

Layer 3: Execution / Fulfillment

Where the order actually gets placed and shipped.

  • Merchant-native: Shopify Storefront API, Adobe Commerce, Salesforce Commerce Cloud (for partner-onboarded merchants)
  • Retailer execution: Zinc for programmatic ordering at Amazon, Walmart, Target, Best Buy, and 50+ other retailers
  • Dropship networks: Convictional, Violet (for platforms with pre-onboarded suppliers)

This is the layer most agentic commerce discussions skip. A model can decide to buy an iPad. A payment protocol can settle the payment. But none of that matters if you can't place the order at Best Buy and get it shipped.

The protocols, explained

If you're evaluating agentic commerce architectures, you'll run into four acronyms immediately. Here's what each actually does.

ACP: Agentic Commerce Protocol

Launched by Stripe and OpenAI. Defines how merchant checkout pages communicate with agents.

What it solves: A merchant exposes a structured checkout endpoint. An agent discovers it, submits cart contents, and initiates a payment through Stripe. The user authorizes, the merchant ships.

What it doesn't solve: Only works for merchants who implement ACP. Doesn't help you buy from Amazon, Walmart, or any retailer that hasn't adopted it. Adoption is strong on Shopify (which bakes ACP into checkout) and nonexistent elsewhere.

Full guide: What Is ACP? The Agentic Commerce Protocol Explained. Spec at agenticcommerce.dev.

MCP: Model Context Protocol

Anthropic's standard for how agents discover and call tools. Not commerce-specific.

What it solves: An agent connects to a "commerce MCP server" that exposes tools like search_products, get_product_details, place_order. The agent calls the tools through a structured interface.

What it doesn't solve: MCP is just the plumbing. The server behind the protocol still needs to actually place orders. MCP defines the shape of the conversation, not who fulfills it.

AP2: Agent Payments Protocol

Google's protocol for authorizing agent payments.

What it solves: The user pre-authorizes an agent to spend up to a limit, within a category, with specific guardrails. The agent uses that authorization at merchants that support AP2.

What it doesn't solve: Like ACP, AP2 is merchant-adoption dependent. Still emerging.

Full guide: What Is AP2? The Agent Payments Protocol Explained.

MPP: Machine Payments Protocol

Uses HTTP 402 Payment Required to negotiate payments between services. Zinc integrated MPP so agents can place orders without a pre-provisioned Zinc account or API key.

What it solves: An agent hits Zinc's API, gets a 402 response with a price, pays inline (currently Tempo stablecoins, Stripe coming), and the order is placed. Zero setup required.

Full guide: What Is MPP? A Developer's Guide to Machine Payments. Zinc's own integration story: Zinc MPP launch post. Comparing protocols: MPP vs x402.

How they fit together

None of these protocols solve the whole problem alone. A working agentic commerce flow typically combines:

  1. MCP for agent-to-tool plumbing
  2. MPP or ACP for payment
  3. An execution layer (Shopify Storefront, Zinc, or similar) for fulfillment

Vendors with a single protocol pitch ("use ACP and you're done") are either assuming you only sell through Shopify, or glossing over where the actual order lives.

Why traditional e-commerce APIs break for agents

The biggest surprise for developers building their first agentic commerce app: none of the official retailer APIs let you buy anything.

  • Amazon Product Advertising API (PA-API): Read-only. Built for affiliates driving traffic. You can search, you can't check out. New keys start at 1 request per second and get revoked if you don't generate affiliate revenue in 30 days.
  • Amazon Selling Partner API (SP-API): Only works with your own Amazon seller inventory. You can't browse or buy from other sellers.
  • Amazon Buy with Prime: FBA sellers only. Adds a checkout button to your site. Doesn't let you shop Amazon.com programmatically.
  • Shopify Storefront API: Only works for Shopify-hosted stores. Fantastic for agentic commerce within Shopify. Useless for Amazon, Walmart, Target, or anyone else.
  • Walmart Marketplace API: Seller-side. Same story as SP-API.

If you want an agent to buy a Kindle for a new employee, none of these APIs make that possible. Companies that tried to close the gap with Puppeteer scripts hit the same wall: Amazon's bot detection flags them, CAPTCHAs block them, and checkout UI changes break them weekly.

That gap - "the agent decided to buy, the payment cleared, but nobody could actually place the order" - is exactly what the execution layer exists to solve.

The execution layer, in code

Zinc is the execution layer for retail. Pass a product URL, a shipping address, and a max_price. Zinc handles login, payment, captchas, 2FA, and tracking across Amazon, Walmart, Target, Best Buy, Home Depot, Alibaba, and 50+ other retailers.

Standard order placement

The agent (or the app driving the agent) calls Zinc directly:

POST https://api.zinc.com/v1/orders
Authorization: Bearer zn_live_...

{
  "products": [
    { "url": "https://www.amazon.com/dp/B08F7PTF53", "quantity": 1 }
  ],
  "shipping_address": {
    "first_name": "Jane",
    "last_name": "Doe",
    "address_line1": "123 Main St",
    "city": "San Francisco",
    "state": "CA",
    "postal_code": "94105",
    "country": "US",
    "phone_number": "5551234567"
  },
  "max_price": 39900
}

The max_price is the agent's safeguard. If the cart total goes over it at checkout time (because a third-party seller spiked the price), Zinc fails the order cleanly instead of charging over budget.

Agent-native ordering with MPP

For agents that don't have a pre-provisioned API key, Zinc supports Machine Payments Protocol. The agent posts to /agent/orders without authentication, receives a 402 with price and accepted payment methods, pays inline, and the order is placed.

tempo request -X POST \
  --json '{
    "products": [{ "url": "https://www.amazon.com/dp/B0EXAMPLE", "quantity": 1 }],
    "max_price": 2499,
    "shipping_address": { ... }
  }' \
  https://api.zinc.com/agent/orders

Zinc responds with a 402 if the agent hasn't paid yet:

HTTP/1.1 402 Payment Required
WWW-Authenticate: tempo realm="zinc" amount="25.99" currency="usd"

{
  "error": {
    "code": "payment_method_required",
    "details": {
      "methods": [
        { "method": "tempo", "amount": "25.99", "currency": "usd" }
      ]
    }
  }
}

The Tempo CLI sees the 402, pays USDC on-chain, and re-submits. Zinc confirms:

HTTP/1.1 201 Created
X-Api-Key: zn_live_abc123...

{
  "id": "3f2b8c7e-1a4d-4e6f-9c2b-5d8a3f1e7b9c",
  "status": "in_progress"
}

The response includes a persistent API key tied to the agent's wallet. The same wallet always gets the same key. The agent can now track the order, place more orders, and use every other Zinc endpoint without further setup.

No account. No pre-configured billing. No human in the loop.

Try it live: agent.zinc.com is a working MPP playground where your agent can place a real order with stablecoins.

Tracking and webhooks

Once the order ships, Zinc pulls the tracking number from the retailer and fires a webhook:

{
  "type": "order.shipped",
  "data": {
    "id": "3f2b8c7e-1a4d-4e6f-9c2b-5d8a3f1e7b9c",
    "status": "shipped",
    "tracking_numbers": [
      {
        "carrier": "amazon",
        "tracking_number": "TBA123456789000",
        "created_at": "2026-04-16T09:15:00Z"
      }
    ]
  }
}

The agent now knows the order shipped, when it'll arrive, and can report back to the user without polling.

Who's actually building with this

Real production traffic, not slideware:

  • Abunda built a BNPL marketplace on Zinc. They pull real-time Amazon product and pricing data to power their catalog, and Zinc places the order when a customer finishes financing. They've processed over 40,000 orders worth $19.1M. Zinc handles 60% of those end-to-end automatically. Time from zero to live: 36 hours.
  • Zinc GPT is an open-source shopping assistant. You describe what you want, it finds options across retailers, and when you say yes, it places the real order. Reference implementation for anyone building a shopping agent.
  • Zinc Agent (beta at agent.zinc.com) exposes MPP so any agent framework can place orders without pre-existing infrastructure.
  • Procurement automation platforms reorder office supplies, tools, and consumables when inventory drops below threshold, through Amazon Business via Zinc.
  • Corporate gifting tools ship items automatically for employee anniversaries, client gifts, and event swag.

One pattern across all of these: the user doesn't think of it as "agentic commerce." They think of it as "the app bought me a thing." The agentic part is infrastructure, not UX.

Building an agentic commerce app today

If you're starting from scratch, here's the minimum stack:

  1. Model layer. Pick a foundation model (GPT, Claude, Gemini) and an agent framework (LangChain, MCP tools, or direct function calling).
  2. Intent and planning. The model parses user intent into a structured purchase spec: product category, constraints (price, delivery date, brand), shipping address.
  3. Search and discovery. Use the model's own tool use or a dedicated search API to find candidate products. Zinc's search returns structured product data across 50+ retailers.
  4. Payment. For consumer-facing apps, Stripe or ACP. For agent-to-agent flows with no pre-existing account, MPP with stablecoins.
  5. Execution. Zinc for retail, Shopify Storefront for partner merchants, or your own commerce engine if you own the catalog.
  6. Tracking and post-sale. Webhook handlers for order.shipped, order.delivered, order.returned. Surface status back to the user naturally in the chat.

Start at the quickstart guide and you can place your first real order in under 15 minutes. The MPP playground at agent.zinc.com is the fastest way to see an agent actually complete a purchase end-to-end. For a step-by-step build with Claude, MCP tools, and MPP payments, follow our AI shopping agent tutorial.

What to ignore

A few things that get too much airtime in agentic commerce writing but don't change how you build:

  • "Agents will replace all e-commerce UI." They won't. They'll route the easy purchases. Humans still browse for the hard ones.
  • "Every retailer will adopt ACP." Most won't, at least not for years. Amazon, Walmart, and Target aren't on anyone's protocol roadmap. Execution-layer infrastructure exists precisely because that coverage gap is permanent.
  • "Agents will negotiate with other agents." Maybe someday. Right now it's a demo, not a production pattern.
  • "This is going to happen overnight." Distribution shifts take years. SEO didn't happen in a week. Neither will agent-native commerce.

Focus on where there's already volume: procurement, BNPL, gifting, rewards, reorder automation. Build for that. Evolve when the broader consumer behavior catches up.

Bottom line

Agentic commerce is not "coming" - the execution layer is live now, just not where most consulting articles are looking.

The full stack has three layers: models decide what to buy, protocols settle payment, and an execution layer places the order at a real retailer. The hardest layer to replace is execution, because it requires deep integration with bot-protected retailer checkouts. That's the moat.

If you're building anything where an agent needs to complete a purchase - gifting, rewards, BNPL, procurement, or a next-gen shopping assistant - start at the execution layer. The model and payment protocols will keep evolving. Retail fulfillment at scale already works.

Get started with Zinc, read the MPP documentation, or place a real order through an agent at agent.zinc.com.

Go deeper on the protocols

Also read: Amazon Shopping API: The Ultimate Guide (2026) and Zinc MPP: Let Your Agent Buy Anything Online.

Frequently Asked Questions

What is agentic commerce?

Agentic commerce is a form of online shopping where AI agents autonomously research, compare, and complete purchases on behalf of a user or business. The user sets the goal and constraints, the agent handles discovery, decision-making, and checkout without requiring a traditional shopping UI.

How does agentic commerce work?

Agentic commerce works through three layers: a model or agent framework that interprets user intent, a payment protocol (such as ACP, AP2, or MPP) that authorizes and settles payment, and an execution layer (such as merchant-native APIs or Zinc) that places the order at a retailer and handles fulfillment.

What is the Agentic Commerce Protocol (ACP)?

The Agentic Commerce Protocol, launched by Stripe and OpenAI, is a standard for how merchant checkout pages communicate with AI agents. It defines how an agent can discover, submit, and pay for a cart without a human completing the checkout UI. ACP is primarily adopted by Shopify merchants today.

What is the Machine Payments Protocol (MPP)?

MPP is an HTTP 402-based payment protocol that lets services negotiate payment inline with AI agents. An agent can call an API without an account, receive a 402 Payment Required response with pricing, pay with stablecoins or a card, and receive service immediately. Zinc uses MPP to let agents place retail orders without any pre-provisioned account or API key.

Is agentic commerce actually live in production today?

Yes, in specific categories. B2B procurement, buy-now-pay-later marketplaces, corporate gifting, rewards redemption, and chat-based shopping interfaces all run live agentic commerce flows. Abunda, for example, has processed over $19 million in volume through agent-placed orders. Fully autonomous fashion or high-trust consumer shopping is still mostly in demo phase.

How do AI agents pay for purchases?

Agents pay through payment protocols (ACP, AP2, MPP) that let them authorize and settle transactions without a human-facing checkout. Depending on the setup, payment can route through the user's Stripe account, a shared wallet (like Zinc Wallet), or stablecoins via protocols like Tempo. Execution-layer providers like Zinc handle the retailer-side payment so the agent only deals with a single API.

More posts you might like