BridgeToAgent
Get the kit — $49
All posts
Comparison8 min read

UCP, agents.json, MCP — three protocols, three jobs in the 2026 agent stack

Google launched UCP (Universal Commerce Protocol) at NRF in January 2026 with Shopify, Etsy, Wayfair, Target, and Walmart. The first question every site owner asks is which existing standard it replaces. Short answer — none. UCP, agents.json, MCP, and llms.txt solve four different problems for four different audiences. This is the orientation map plus a recommendation for what to ship.

BridgeToAgentEditorial team

UCP, agents.json, MCP — three protocols, three jobs in the 2026 agent stack

Five months after Google unveiled UCP at the National Retail Federation conference, the question I keep getting in inbound email is some version of: "Does UCP replace agents.json? Do I still need llms.txt? Is MCP for me?"

It's the same confusion that hit when MCP, A2A, and agents.json all landed within a six-month window — vendor blogs each frame their own standard as the answer, and a site owner reading three of them gets three contradictory pitches.

The pitches contradict because the protocols don't. They sit at different layers of the same agent journey. This post is the orientation map: what each standard does, who it's aimed at, where it lives, and — for a public website in 2026 — which ones you actually need to ship.

The 30-second version

ProtocolLives atWho reads itPurposePublic-website relevance
UCP (Universal Commerce Protocol)/.well-known/ucpAI surfaces with commerce intent (Gemini, Google AI Mode, ChatGPT browse)Discover what a merchant sells, which actions it exposes, which transports it supportsHigh for commerce sites — native on Shopify, manual elsewhere
agents.jsonhttps://yourdomain.com/agents.jsonGeneral-purpose web agentsAction map — every transactional intent a site offers, typedHigh for any site — direct install
llms.txthttps://yourdomain.com/llms.txtAI search / curated readers (ChatGPT, Claude, Perplexity)Context layer — what the site is, where the canonical content livesHigh for any site — direct install
MCP (Model Context Protocol)A server you runLLM applications via SDKExpose internal tools / data sources to AI clientsLow for static sites; high if you're a SaaS
A2A (Agent-to-Agent)Inter-agent channelOther agentsDirect agent-to-agent coordinationNear-zero for public websites

If you run a Shopify store, you have UCP already (it's auto-enabled — curl https://yourstore.com/.well-known/ucp to verify). What you don't have automatically is agents.json, llms.txt, and agent-instructions.md — the layers that handle agent flows UCP doesn't.

If you don't run Shopify, you have none of the above unless you ship them. UCP isn't a single-file install for non-merchant platforms in May 2026; agents.json and llms.txt are.

The rest of this post unpacks why each protocol fits where it does.

UCP — Universal Commerce Protocol

Designed by: Google + retail consortium (Shopify, Etsy, Wayfair, Target, Walmart at launch).

Released: January 2026, NRF conference. Current spec version: 2026-04-08 (ucp.dev, developers.google.com/merchant/ucp).

What it is: A protocol for AI commerce surfaces (Gemini Spark, Google AI Mode, Google Shopping, ChatGPT browse when it transacts) to discover, query, and transact against merchant backends. The discovery file at /.well-known/ucp is a JSON manifest declaring:

  • Organization metadata (name, URL, logo, description)
  • ucp_version (currently 2026-04-08)
  • A capabilities array — checkout, browse_products, inventory, etc.
  • Per-capability transport bindings — REST, MCP, or A2A
  • Payment handlers (which Agent Payments Protocol AP2 surfaces are supported)

The transport bindings are the clever part. A site can expose its checkout capability as a REST API, or as an MCP server, or as an A2A endpoint — UCP just declares which transports are available. Agent surfaces pick the binding they understand.

Where it lives: At /.well-known/ucp on the merchant's own domain.

What problem it solves: Discoverable, structured commerce — an AI agent reading the manifest knows which actions it can take, what data shape they expect, and which transport to use, without needing custom integration per merchant.

Does a public website need to ship UCP? Depends entirely on the platform:

  • Shopify — already shipped. Auto-enabled at /.well-known/ucp on every store. You can verify with curl https://yourstore.myshopify.com/.well-known/ucp and see the manifest Google reads.
  • WordPress / WooCommerce — no native UCP. You'd need to publish the manifest manually, plus implement at least one transport binding.
  • Webflow / Squarespace / Wix / static / custom builds — same situation. No native UCP. Manual implementation only.
  • BigCommerce — partial; check your store admin for UCP-related settings as the rollout is still ongoing.

For the non-Shopify case, generating a valid UCP manifest by hand is non-trivial — you have to model the capabilities correctly, host at least one matching transport binding, and version-track the spec as it evolves.

agents.json

Designed by: Wildcard AI, open spec at agentsjson.org.

Released: 2024, with broader 2025 / 2026 adoption.

What it is: A JSON manifest at /agents.json declaring every transactional intent the site supports — checkout, login, signup, contact, password reset, FAQ lookup, search, and the rest. Each intent has a location (URL the agent navigates to), typed fields (form inputs the agent fills), and a success_indicator (how the agent knows it worked).

agents.json is broader than UCP because it covers every action class, not just commerce. UCP defines checkout and browse_products; agents.json defines those plus contact, support, password_reset, account_create, subscribe, and whatever else the site exposes. A non-commerce site (lead-gen, SaaS marketing, documentation hub, agency portfolio) has no UCP use case but still needs agents.json.

Where it lives: https://yourdomain.com/agents.json. The Lighthouse 13.3.0 Agentic Browsing audit checks agents-json-present + agents-json-actions-typed (cluster-1 pillar covers the full audit grid).

Public-website relevance: High for any site that does transactions, lead capture, or self-service. Ship it.

llms.txt

Designed by: llmstxt.org (Jeremy Howard's community spec).

Released: 2024, with Lighthouse 13.3.0 (May 2026) elevating it to default-audit visibility (cluster-2 pillar).

What it is: A plain-text Markdown file at /llms.txt declaring the site's purpose, canonical sections, and AI-friendly navigation. Where UCP and agents.json are for acting on the site, llms.txt is for reading — it's what ChatGPT browse, Claude, Perplexity, and other curated-reader agents fetch to orient themselves.

Public-website relevance: High for any site that benefits from AI search citations (which is most sites). The free BridgeToAgent llms.txt validator checks well-formedness against the llmstxt.org reference parser if you want to verify yours.

MCP — Model Context Protocol

Designed by: Anthropic, open-spec at modelcontextprotocol.io.

What it is: A protocol for LLM applications to connect to data sources and tools. An MCP server exposes resources, tools, and prompts; an MCP client (Claude Desktop, Cursor, Gemini Spark, GPT custom integrations) connects to the server and uses what it exposes. JSON-RPC wire format, stdio or Streamable HTTP transport.

Relationship to UCP: UCP uses MCP as one of its transport bindings. A Shopify store's UCP manifest can declare its checkout capability as an MCP binding at /api/ucp/mcp — same protocol, dedicated to the commerce capability. This is why curl on a Shopify store's /.well-known/ucp returns a manifest that lists /api/ucp/mcp as an endpoint.

Does a public website need to ship MCP? Generally no, unless your business is a SaaS that other AI applications want to integrate with. Analytics, CRM, project management, dev tools — shipping a public MCP server gets you native distribution into Claude Desktop, Cursor, custom GPTs, Gemini Spark plugins. For a static or e-commerce public site, MCP isn't the right entry point.

A2A — Agent-to-Agent

Designed by: Google's A2A working group (with Anthropic, Microsoft, OpenAI participation).

What it is: A protocol for AI agents to coordinate directly with each other — one agent delegating to another, agents negotiating without human intermediary.

Public-website relevance: Near-zero. A2A is infrastructure for agent platforms, not for public sites. UCP can declare an A2A binding for capabilities that benefit from agent-to-agent flow (e.g., comparison-shopping bots negotiating with merchant agents) but the binding lives on the platform's MCP-shaped backend, not in your <head>.

How the five fit together for a real Shopify store

A typical agent journey on a UCP-enabled Shopify store in 2026:

  1. AI search query — user asks ChatGPT "where can I buy a 4mm winter wetsuit". ChatGPT browse reads the store's llms.txt to confirm the site's relevance.
  2. Intent matching — ChatGPT reads agents.json to find browse_products and add_to_cart actions with typed parameters.
  3. Commerce transaction — for the actual checkout, ChatGPT switches to UCP — reads /.well-known/ucp, picks the REST or MCP transport, and runs the typed checkout capability with the user's authenticated session.
  4. Brand voice + escalation — the runbook at /agent-instructions.md tells the agent how to phrase responses to the user, what the merchant's return policy is, and which contact paths to use if anything goes wrong.

Shopify ships UCP for step 3 automatically. The other three steps require files Shopify does not ship — agents.json, llms.txt, and agent-instructions.md.

What this means for non-Shopify platforms

For WordPress, Webflow, Squarespace, Wix, Magento, BigCommerce, custom static sites — five months after UCP launch, you have no native commerce protocol. The viable path in May 2026:

  1. Ship agents.json + llms.txt + agent-instructions.md (the BridgeToAgent kit generates all three from your DOM in under 2 minutes).
  2. Wait for your platform to ship UCP-native support (likely 6-18 months for mainstream e-commerce platforms outside the Shopify orbit) — or implement it manually if you have the engineering resources.
  3. If you must implement UCP now, the spec is documented at ucp.dev/2026-04-08/specification/overview/. You'll need to model your capabilities, host a transport binding, and version-track the spec quarterly.

For most SMBs the right answer is ship the three files now, let UCP land via platform updates later. Lighthouse Agentic Browsing already audits the three files by default (Lighthouse 13.3.0); no commerce-specific audit yet checks UCP-readiness as a Cloudflare or Chrome default. The visibility-cost of not having agents.json today is higher than the cost of not having /.well-known/ucp.

Why the confusion exists

The five protocols don't compete because they were designed for different layers and different audiences. They look like they compete because:

  • Each vendor frames their standard as comprehensive. Google positions UCP as "the agent commerce standard". Anthropic positions MCP as "the tool integration standard". Wildcard positions agents.json as "the action map standard". Each framing is accurate within scope but ambiguous about what's outside scope.
  • The naming is similar. "Universal Commerce Protocol" sounds like it covers everything. "Model Context Protocol" sounds like it might cover context too. "agents.json" sounds like it could be the canonical action declaration.
  • The vendors' incentive structures differ. Google wants UCP adopted because it strengthens Gemini's commerce layer. Anthropic wants MCP adopted because it strengthens Claude's tool layer. Wildcard wants agents.json adopted because it's the spec they built. The site owner reading three vendor blogs gets three "you need this" messages, and no neutral guide that says they're complementary.

The honest model: UCP for commerce transactions, agents.json for all transactional intents (including non-commerce), llms.txt for context/AI search, MCP for internal tools exposure, A2A for agent-to-agent infrastructure. Five layers. Five files / protocols. They stack.

What to actually ship

For a public website in 2026, in priority order:

  1. agents.json — Direct install. Lighthouse audit by default. Covers every transactional intent. Required as baseline.
  2. llms.txt — Direct install. Lighthouse audit by default. Drives AI search visibility. Required as baseline.
  3. agent-instructions.md — Direct install. Brand voice + escalation logic that no other file covers.
  4. Three <link rel="alternate"> tags in the homepage <head> for auto-discovery-links audit pass.
  5. Schema.org JSON-LD on homepage + primary product / article pages (covers schema-org-density audit + Google's general-search-citation surface).
  6. UCP at /.well-known/ucp — if you're on Shopify, you already have it; otherwise wait for platform support or implement manually if commerce volume justifies the engineering.
  7. MCP server — only if you're a SaaS that other AI applications want to integrate with.
  8. A2A binding — only if you operate an agent platform yourself.

Items 1-5 are the BridgeToAgent kit — one URL, $49, two minutes. Items 6-8 are platform-specific decisions that depend on what your business does.

Related

Keep reading

All posts →