AI Catchup

Anthropic Open-Sources a Commerce Agents Blueprint for Claude

By 8 min read

Anthropic's open-source Claude Commerce Agents blueprint, released September 2, 2026, ships a shopping agent and a merchant agent that run on the Messages API, the Agent SDK, or Managed Agents, four runnable verticals, a Claude Code plugin, and an engineering deep-dive. It is Apache-2.0, unmaintained by design, and no demo places an order or charges a card.

Anthropic has open-sourced Claude Commerce Agents, a blueprint for building shopping and merchant agents. The release includes reference implementations across retail, travel, telecom, and ticketing, an engineering deep-dive, and a Claude Code plugin that scaffolds an agent against your own systems. (Anthropic announcement; Commerce Agents repository; ClaudeDevs on X)

Anthropic describes the project as a way to get a commerce agent running in days using the harnesses, patterns, and guardrails included in the blueprint. It is available now, with live demos for each vertical and a deep-dive for teams evaluating the architecture. The repository went public on September 1, 2026 under the Apache License 2.0; on September 17 it showed 2,945 stars and 570 forks, with its last push on September 11. (Anthropic announcement; GitHub API)

Key Takeaways

  • Two agents ship: a shopping agent a business embeds for customers and a merchant agent its staff use for the back office. Each is defined once and runs on the Messages API, the Agent SDK, or Managed Agents.
  • Four runnable verticals: retail, travel, telecom, and entertainment (ticketing), each with a storefront and a merchant portal.
  • Safety is enforced in code, not the prompt: checkout renders the cart for the host to complete, every merchant write is staged until a person approves it, and writes accept only server-issued IDs.
  • The Claude Code plugin is named commerce-builder and adds four slash commands, starting with /scaffold-commerce-agent.
  • The Messages API and Agent SDK paths run on the Claude API, Bedrock, Foundry, Vertex AI, or a gateway. Managed Agents runs only on Anthropic infrastructure and is still in beta.
  • It is a reference implementation: Apache-2.0, not maintained, no contributions accepted, fictional data throughout, and demo backends that Anthropic says are not production hardened.

Two Reference Agents, Not Just a Prompt Pack

The repository contains working implementations of two distinct agent types, each defined once as a prompt, a set of skills, tool contracts, and gates: (Commerce Agents repository)

  • Shopping agent: runs inside an app or website and connects to catalog, cart, checkout, customer preferences, and order history. Its five flows are skills: search-discovery, purchase-research, planning-goals, customer-care, and memory-personalization. Payment stays with the existing checkout or an agentic payments provider chosen by the implementer; the backend interface the agent calls has no charge method.
  • Merchant agent: helps store operators answer questions about sales, inventory, pricing, and promotions. It can flag inventory problems, recommend discounts, and draft marketing campaigns from the store's own data. Its five skills are performance-insights, catalog-listings, inventory-operations, pricing-promotions, and marketing-campaigns.

Anthropic says the shopping agent's guardrails constrain prices and products to actual catalog data and avoid manipulative upsell patterns. The merchant agent requires human approval before a proactively suggested change goes live: every write produces a staged change with a server-generated ID, and the apply step succeeds only for IDs approved through a real surface, such as a portal button, a CLI confirmation, or the Managed Agents tool-approval prompt. (Anthropic announcement; engineering deep-dive)

What Ships in the Repository

As of September 17, 2026, the repository's README describes the following. (Commerce Agents repository)

ItemWhat the README says
LicenseApache License 2.0, copyright 2026 Anthropic PBC
Maintenance"This is a reference implementation; it is not maintained and does not accept contributions."
RequirementsPython 3.11 or later and Node 22; the eight web apps share one npm workspace
Verticalsretail (ACME), travel (ACME Travel), telecom (ACME Mobile), entertainment (ACME Tickets), each with a storefront and a merchant portal
Runtime pathsMessages API runtimes, Agent SDK runtimes, and Managed Agents manifests with MCP servers, for both agents
Packagescommerce-common plus a core, a Messages API runtime, and an Agent SDK runtime for each agent, installed from the repository directories, never from the public index
Pluginplugins/commerce-builder/, registered through .claude-plugin/marketplace.json under the marketplace name claude-commerce-agents
Docssafety.md (enforced rules), backends.md (mapping your systems), deployment.md (other platforms)
MCP connectorsNone ship; both agents reach your systems through the backend interfaces
Data"Every company, brand, product, and person here is fictional; the only company is ACME."

Two lines from the README set expectations for anyone evaluating it as a starting point. Nothing in the demos places an order, charges a card, or changes a live listing: checkout renders the cart for the host to complete, and every merchant write is staged until a person approves it. The examples also have no authentication, and the MCP servers bind to loopback. Anthropic's commerce solutions page adds that the demo backends are not production hardened. (Commerce Agents repository; Claude for commerce)

Where the Agents Run

The announcement says the code deploys where teams already build with Claude: the Claude API, Amazon Bedrock, Microsoft Foundry, or Google Cloud Vertex AI. The repository's deployment guide is more precise, and the precision matters if you plan to use Managed Agents. (Anthropic announcement; deployment guide)

PathClaude APIVertex AIBedrockFoundryIn-house gateway
Messages API runtimesYesYesYesYesYes
Agent SDK runtimesYesYesYesYesYes
Managed AgentsYesNoNo (see note)NoThrough a pass-through proxy

The guide's note: Managed Agents runs on Anthropic-operated infrastructure, so it has no Vertex, Bedrock, or Foundry variant; on AWS it is available through Claude Platform on AWS. Managed Agents itself is still in beta as of September 17, 2026, with every endpoint requiring the managed-agents-2026-04-01 beta header. (deployment guide; Managed Agents overview)

The announcement also names Accenture, Mastercard, and Visa as ecosystem or solutions partners working with Anthropic on commerce-agent adoption. Those partnerships do not change the fact that teams still need to connect their own catalogs, policies, checkout, and business data. (Anthropic announcement)

What the Engineering Deep-Dive Recommends

The companion post, "A guide to the anatomy of effective commerce agents" by Ali Shazal and Matthew Koen, is where the design decisions behind the code are argued. Its main recommendations: (engineering deep-dive)

  • One agent with skills, not a subagent per domain. A commerce conversation is one tightly coupled session, and every handoff to a subagent loses state, costs several times the tokens, and adds seconds. Anthropic says a single agent with skills "consistently has outperformed both the one-prompt-for-everything design and the subagent design" across several enterprise deployments. Subagents earn a place for narrow delegated tasks such as deep research.
  • System prompt or skill, decided by frequency. Anything relevant to about a third or more of traffic goes in the system prompt; the rest goes in skills. Safety, legal, brand, and key user facts such as allergies always go in the prompt.
  • UI components are tools. The model calls present_products or present_itinerary with typed arguments; the server validates and the client renders. Because the layout sits in the messages array, "the third one down on the left" resolves without a parser.
  • Design for 90 to 99 percent cache hit rates. Order the request as global, session, then volatile segments; a timestamp at the top of the system prompt "silently breaks the cache on every request."
  • Choose the model by sweeping your evals. Anthropic suggests starting at Opus for merchant agents and Sonnet for consumer agents, then measuring cost per completed task rather than per call.
  • Enforcement lives in the harness. The model proposes; a person or a policy applies. Writes and renders accept only server-issued IDs, caps are enforced on the resulting state, and every third-party read is sanitized and fenced before the model sees it.

A Practical Starting Path

The README's two quick starts, as of September 17, 2026: (Commerce Agents repository)

To run the demos:

git clone https://github.com/anthropics/commerce-agents.git && cd commerce-agents
python3 -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
cp .env.example .env                  # add ANTHROPIC_API_KEY
(cd examples && npm ci)
python scripts/run_demo.py retail     # API :8000 + storefront :3000

--merchant starts the portal instead of the storefront and --all starts both. To build your own, with the repository cloned as above:

claude plugin marketplace add anthropics/commerce-agents
claude plugin install commerce-builder@claude-commerce-agents
claude
/scaffold-commerce-agent a shopping assistant for our store

The scaffold command asks about your stack, plays the plan back, and builds the project. /add-commerce-flow and /author-commerce-evals continue from there, and /review-commerce-agent starts from an agent that already exists. From there, the README's advice is to start small: a shopping pilot implements search and product details and stubs the rest, and a merchant pilot implements the eight read methods and has the writes refuse. Systems you do not have are switched off in the config, which removes their tools and prompt lines on every path.

The project is a blueprint rather than a turnkey storefront. Teams still own the integrations, approval rules, security review, and production operations. (Anthropic announcement; Commerce Agents repository)

What the Release Signals for Agent Builders

Commerce agents need more than a model call: they need catalog and inventory tools, policy constraints, user context, approval gates, and an interface that can explain what the agent is doing. Anthropic's blueprint packages those pieces as reusable implementations and skills rather than leaving every team to design them independently. (Anthropic announcement)

That makes the release useful even for teams that are not building a retailer-facing chatbot. The same structure, domain tools, guardrails, human approval, and a deployable agent workflow, can serve as a reference for other systems where an agent must act on business data without making unreviewed changes. The announcement does not claim that the blueprint is a universal template for every industry, so treat that broader use as an architectural starting point, not a guarantee.

Sources

Related coverage

Frequently Asked Questions

What did Anthropic release?

Anthropic launched an open-source Commerce Agents blueprint on September 2, 2026: working shopping and merchant agent implementations, skills, tool contracts, guardrails, four runnable verticals, a Claude Code plugin named commerce-builder, and an engineering deep-dive. The repository is anthropics/commerce-agents under the Apache License 2.0.

Which commerce scenarios are included?

Four runnable verticals: retail (ACME), travel (ACME Travel), telecom (ACME Mobile), and entertainment or ticketing (ACME Tickets). Each has a storefront for the shopping agent and a portal for the merchant agent. The shopping agent covers catalog, cart, checkout, preferences, and order history; the merchant agent covers sales, inventory, pricing, promotions, and campaigns.

Where can Commerce Agents run?

The Messages API and Agent SDK paths run on the Claude API, Amazon Bedrock, Microsoft Foundry, Google Cloud Vertex AI, or an in-house gateway, per the repository's deployment guide. The Managed Agents path runs on Anthropic-operated infrastructure only; on AWS it is reached through Claude Platform on AWS. Managed Agents is still in beta as of September 2026.

How can a developer get started?

Clone anthropics/commerce-agents, install with Python 3.11 or later and Node 22, add an Anthropic API key, and run a vertical with the demo script. To build your own, add the repository as a Claude Code plugin marketplace, install commerce-builder, and run the scaffold command. The deep-dive at claude.com covers architecture, latency, caching, and evals.

Is the blueprint maintained or production-ready?

No on both counts, by design. The README states it is a reference implementation that is not maintained and does not accept contributions. Every company and product in it is fictional, nothing places an order or charges a card, the examples have no authentication, and Anthropic's commerce page says the demo backends are not production hardened.

What does the Claude Code plugin do?

The commerce-builder plugin adds four commands: /scaffold-commerce-agent builds a new agent on the blueprint's packages against your stack, /add-commerce-flow and /author-commerce-evals extend it, and /review-commerce-agent audits an agent you already have. It reads the cloned repository as its reference and also triggers when a request matches a command's description.

Get an email when Claude Code changes its plans, prices or limits

We check every change against Claude Code's own pages before we send. You also get the weekly AI Catchup; one click unsubscribes.