
How AI Agents Discover Merchants Through UCP
AI shopping agents are only as useful as the merchants they can find. Without a discovery mechanism, every agent would need hardcoded integrations with every store — an approach that doesn't scale. UCP solves this with a standardized discovery protocol that any agent can use. Here's exactly how it works.
The Discovery Problem
Imagine you're building an AI assistant that helps people find products. A user asks: "Find me sustainable running shoes under $150." Your agent needs to:
- Know which merchants sell running shoes
- Know which of those merchants have UCP endpoints
- Query those endpoints for matching products
- Compare results and present the best options
Without UCP, step 1-3 would require custom integrations with every merchant. With UCP, it's a standard protocol that works the same way everywhere.
How well does this work in practice? Across 560+ real agent sessions we've tracked, agents successfully discovered and interacted with 47 unique stores, making over 2,100 tool calls in the process. The average agent completes its entire workflow — from discovery through product selection to checkout — in just 36 seconds.
For background on the protocol itself, see our complete UCP guide.
How Well-Known Discovery Works
Every UCP-enabled merchant hosts a manifest at a predictable URL:
https://example.com/.well-known/ucp.json
This follows the same pattern as robots.txt or .well-known/openid-configuration — a convention that makes discovery trivial. An agent can check any domain for UCP support with a single HTTP request.
The manifest tells the agent everything it needs to know:
{
"version": "1.0",
"merchant": {
"name": "Example Store",
"domain": "example.com"
},
"capabilities": [
"dev.ucp.shopping.catalog",
"dev.ucp.shopping.cart",
"dev.ucp.shopping.checkout"
],
"transports": ["mcp", "embedded"]
}
The Role of the UCP Registry
While well-known discovery works domain-by-domain, the UCP Registry acts as a centralized index — think of it as Google for UCP endpoints. Instead of checking thousands of domains individually, an agent can query the Registry API to find merchants matching specific criteria:
# Find verified merchants with checkout capability
curl https://ucpregistry.com/api/v1/merchants?status=verified&capability=dev.ucp.shopping.checkout
# Search by category
curl https://ucpregistry.com/api/v1/merchants?category=apparel
# Find merchants on a specific platform
curl https://ucpregistry.com/api/v1/merchants?platform=shopify
This is how most production AI agents work in practice — they use the Registry for broad discovery, then connect directly to individual merchant endpoints for transactions.
The Registry handles millions of queries per day. For routed sessions where the agent selects from multiple stores, we see an average of 3-5 stores presented per query — enough options for meaningful comparison without overwhelming the agent's context window.
Our API documentation covers all available endpoints and query parameters.
Transport Negotiation
Once an agent discovers a merchant, it needs to communicate. UCP supports three transport mechanisms:
- MCP (Model Context Protocol) — the primary transport, where the merchant exposes an MCP endpoint that agents connect to via JSON-RPC 2.0. This enables rich tool-use patterns: product search, cart management, checkout, and more — all through standardized tool calls
- REST — a traditional HTTP API transport for agents that prefer standard request/response patterns over MCP's tool-calling model
- Embedded — a lightweight transport for merchants who want to handle checkout through their existing storefront, with the agent handing off to a hosted checkout page
The merchant's manifest declares which transports they support, and the agent picks the best one for its use case. For a deeper dive on how MCP and UCP work together, see our article on the future of agentic commerce.
Capability Matching
Not every merchant supports every operation. An agent looking to complete a purchase needs merchants with dev.ucp.shopping.checkout capability. One building a price comparison tool only needs dev.ucp.shopping.catalog.
The capability system lets agents filter efficiently:
| Capability | What It Enables |
|---|---|
dev.ucp.shopping.catalog |
Keyword and filtered catalog search, full product information retrieval |
dev.ucp.shopping.cart |
Create and modify shopping carts |
dev.ucp.shopping.checkout |
Complete purchases programmatically |
dev.ucp.shopping.order |
Check order and shipping status |
dev.ucp.shopping.returns |
Initiate product returns |
Browse merchants by capability on the directory page, or explore specific capabilities like the ones tracked in our capability pages.
How Agents Actually Use Capabilities
Real agent session data reveals the distribution of capability usage:
| Tool Category | % of All Calls | Avg Response Time |
|---|---|---|
| Product listing/search | 44% | 460-980ms |
| Checkout creation | 10% | 480ms |
| Product detail | 5.6% | 270ms |
| Cart management | 5% | 540ms |
| Checkout updates | 5% | 420ms |
| Store discovery | 1.6% | 330ms |
The data shows a clear funnel: agents spend most of their time searching and browsing, with a focused conversion to checkout. This maps directly to how consumers shop — lots of browsing, selective purchasing.
Merchants with rich product data in their search results see agents skip the product detail step entirely — the search response is sufficient for purchase decisions. This is why data quality in search results is arguably more important than having a detailed product endpoint.
AI Bot Policies and Access Control
Discovery is one thing — being allowed to interact is another. Merchants control which AI agents can access their UCP endpoints through bot policies, similar to how robots.txt controls web crawlers.
The Registry tracks these policies for major AI platforms:
- GPTBot (OpenAI)
- ClaudeBot (Anthropic)
- Google-Extended (Google AI)
- Applebot-Extended (Apple)
- CCBot (Common Crawl)
Our AI bot-friendly collection lists merchants that welcome all major AI agents. This is particularly useful if you're building an agent and want to know which merchants you can reliably integrate with.
Multi-Model Reality
An important discovery consideration: your agent might use Claude, but the next agent querying the same merchant might use GPT-4o or Gemini. Session data across 16 different AI models shows that all major model families successfully interact with UCP endpoints. The protocol is truly model-agnostic — but error rates and success patterns vary:
- Models with strong tool-calling capabilities (Claude Sonnet 4.5, Llama 3.3 70B) achieve 66-71% checkout success rates
- Models that are less optimized for structured tool use (QWQ-32B, Grok 3 Mini) see lower success rates around 25-29%
- The most common agent error is type mismatches — passing an integer product ID where a string is expected. Merchants who accept flexible input types see fewer agent failures
Building Your Own Discovery Flow
If you're building an AI shopping agent, here's the recommended discovery pattern:
- Start with the Registry API — query for merchants matching your user's intent (category, capability, platform)
- Fetch the merchant's UCP manifest — verify it's live and check capabilities
- Negotiate transport — connect via the best available transport
- Execute the interaction — search products, manage carts, complete checkout
For a hands-on walkthrough, our tutorial on building an AI shopping agent covers this flow end to end with working code examples.
Performance Considerations
When building discovery into your agent, keep these benchmarks in mind:
- Discovery adds ~330ms for store lookups via the Registry
- Product search takes 460-980ms depending on catalog size and endpoint optimization
- The full discovery-to-results pipeline should complete in under 5 seconds for a good user experience
- Parallel merchant queries are essential — agents that query merchants sequentially take 3-5x longer than those that parallelize
In our session data, agents average 6.7 turns per shopping workflow. A well-designed discovery flow handles the first 2-3 turns (discover, search, filter), leaving the remaining turns for product selection and checkout.
Discovery at Scale
The UCP ecosystem is growing fast. With thousands of merchants already indexed, discovery is no longer a bottleneck — it's a solved problem. The next frontier is making discovery smarter: ranking merchants by relevance, response time, and data quality so agents can serve the best results to consumers.
The Registry's benchmark system already supports this. Every merchant gets a UCP Score based on their implementation quality, which agents can use as a signal for ranking and routing decisions.
Start building with the UCP Registry API, or browse the merchant directory to see what's available.


