UCP Developer Tools
The complete UCP developer toolchain — validation, live agent testing, control plane infrastructure, merchant registry, and benchmarking. One ecosystem, four products.
Validation, monitoring, and data infrastructure. The ground truth for which stores support UCP — continuously re-checked, historically recorded, and openly published.
Domain Checker & REST API
Instantly validate any domain for UCP compliance. Returns profile status, JSON validation errors, field-level analysis, response latency, and the AI bot policy matrix for GPTBot, ClaudeBot, Google-Extended, and more. Available as a web UI or REST API — no auth required.
- Validates against current UCP spec version
- Parses capabilities, services, payment handlers, signing keys
- robots.txt audit for all major AI crawlers
- Keyless REST API (
POST /api/v1/check) and MCP server — API & MCP docs - Bulk check endpoint for multiple domains at once
Command line & CI gate
npx ucp-check your-store.com — the same verdict as the status page, from a terminal or a CI job, as an exit code. Zero dependencies, no API key, Node 18+. It renders what the API returns and never scores locally, so CI, the website and an agent's MCP call always agree.
- Exit codes are the contract:
0verified ·1not verified ·2usage ·3API unreachable --cachedfor every push, a live check on deploy--jsonprints the API response exactly as served- MIT, source on GitHub under the ucpchecker org
Catalog Validator
Audit what your catalog.search and catalog.lookup endpoints actually return — variant resolvability, product completeness, pricing consistency, response envelope, and cross-capability round-trips. The next layer beyond profile validation: not "is the document well-formed?" but "can an agent actually transact?" Twenty-five rules grounded in the UCP 2026-08-25 schemas.
- Catches the five variant-data anti-patterns from our variant guide
- Spec-required structure:
product_required,variants minItems:1,description minProperties:1 - Pricing consistency, response envelope, search → lookup round-trip
- Works against live domain (REST + MCP) or pasted JSON
UCP Alerts
Monitor domains and receive email notifications when UCP status changes. UCP Checker re-checks daily and fires the moment a store flips: verified → unreachable, invalid → verified, blocked → resolved.
- Monitor up to 3 domains for free
- Email on status change with full error context
- No account required
Chrome Extension
Auto-detect UCP on every site you visit. The extension runs passively and lights up when a profile is found. Click for profile details, version, and capabilities — without leaving the page.
- Passive detection — no manual checking
- Works on any domain, not just indexed merchants
- One-click jump to the full UCP Checker report
Merchant Directory
The largest public index of UCP-enabled stores — 18,824+ merchants, filterable by status, platform, capabilities, and transport. Each store has a permanent status page with current results and check history.
- 18,824+ merchants with daily re-checks
- Filter by status, platform, capability, transport
- Status pages at
/status/{domain}
Dataset Snapshot & Live Stats
An early CSV snapshot of the directory, published on Hugging Face in April 2026 (CC-BY 4.0) and no longer updated — domain, status, platform, version, capabilities, latency, timestamp. Current adoption rates, platform breakdowns, and historical trends are at /stats.
- Hugging Face snapshot: April 2026, CC-BY 4.0, no longer updated
- Live stats: adoption rates, platform splits, capability coverage
- Weekly stats email with ecosystem summary
UCP Checker MCP Server
Connect your agent to ucpchecker.com/mcp for programmatic domain checking, store discovery, cross-store product search and policy reads — all via MCP tool calls. Read-only: it resolves and measures, it never carts or checks out.
check-domain— validate any domain for UCP supportdiscover-store— list all MCP tools at a store endpointsearch-catalog— search products on any UCP storesearch-all— cross-store search across all verified merchants
// Add to your MCP client config
{
"mcpServers": {
"ucpchecker": {
"url": "https://ucpchecker.com/mcp",
"transport": "http"
}
}
}The session engine for UCP — run live AI agent shopping sessions against real stores, inspect every JSON-RPC message, replay any session, and grade stores A–F on real-world agent performance.
Live Agent Shopping Sessions
Run an AI agent against any real UCP-enabled store and watch every step: profile discovery, product search, add-to-cart, checkout. The Playground exercises every declared capability and reports what works and what doesn't.
- Full commerce pipeline: discovery → search → cart → checkout
- Tests every capability declared in the profile
- Shareable session replay URL for every run
- Scores feed back into UCP Checker's runtime leaderboard
Multi-Model Support
Run sessions with different AI models and compare how each navigates the same commerce flow. The Playground supports Claude, Gemini, and other frontier models — useful for testing whether your store's UCP implementation works across the agent ecosystem, not just one model.
- Supports Claude (Anthropic), Gemini (Google), and more
- Compare session outcomes across models
- Identify model-specific parsing differences in your profile
- Session logs include model metadata for reproducibility
JSON-RPC Message Inspection
See every MCP message — requests, responses, and server-initiated notifications — as they flow between the agent and your store endpoint. Inspect the raw JSON-RPC payloads, timing between calls, and any protocol errors. Essential for debugging store-side MCP implementations.
- Raw JSON-RPC request and response for every tool call
- Timing data: TTFB, round-trip per call
- Server-initiated notifications and SSE event stream
- Error codes and stack context for failed calls
- Exportable trace for sharing or filing bug reports
Checkout Flow Testing
Test the full checkout pipeline end-to-end: product search → add-to-cart → real checkout URL. Verifies that your store's cart and checkout MCP tools work under real agent conditions, not just unit tests. Each session produces timing data and a pass/fail verdict for the checkout capability.
- End-to-end checkout: search → cart → checkout link
- Verifies cart tool input/output schema correctness
- Measures checkout latency under agent conditions
- Pass/fail verdict with detailed failure context
Headless API & CI Integration
The Playground exposes a headless REST API for creating and querying sessions programmatically. Trigger sessions from your CI pipeline, compare scores across deploys, and fail builds when runtime performance drops below a threshold.
- Headless session creation via REST API
- Poll session status and retrieve scores programmatically
- OTel export: dual-export to Playground + your OTLP collector
- Session replays accessible via shareable URL
- Integrate with UCP Rails via the Sessions service
The MCP control plane for agentic commerce. Connect your agent once at ucprails.com/mcp and get discovery, memory, guardrails, composable skills, extensions, hooks, loops, and channel integrations — without ever proxying a transaction.
Agent ⇄ ucprails.com/mcp
discovery, memory, skills, guardrails, sessions, hooks, loops
Agent ⇄ Store MCP
cart, checkout, product details — direct, never through Rails
Agent → ucprails.com
side-channel spans via RailsTracer SDK — optional
Discovery
Find stores and products across the UCP ecosystem. Powered by UCP Checker's verified merchant directory and trust scores. Returns store profiles with MCP endpoints, transport recommendations, capabilities, and declared extensions — ready for direct agent connection.
bootstrap— single call to get everything an agent needsdiscover-stores— find stores by category, query, filtersget-store-profile— unified store view with trust score and endpointssearch-products— best-effort cross-store product previews- Trust scores (0–100) from UCP Checker's reliability data
Agent Memory
Persistent, scoped memory for agent state. Three scopes: session (tied to one interaction), agent (survives across sessions for a given agent), and user (per end-user preferences like size, address, payment method). All scoped to your workspace — no cross-tenant leakage.
memory-store/memory-recall— read/write at any scope- Session, agent, and user memory scopes
- Semantic recall via vector search for unstructured memory
- TTL enforcement — anonymous session memory expires after 24h
Guardrails
CEL-based policy enforcement that runs before every tool call. Define rules like "only transact with verified stores", "require user confirmation above $50", or "block checkout if trust score is below 80". Evaluated in microseconds — no network calls, no side effects.
- CEL (Common Expression Language) — sandboxed and deterministic
- Pre-evaluated on
bootstrapandskill-plan - Actions: block, require_user_confirmation, log, transform
- Workspace-wide or per-agent rule sets
- Machine-readable advisories for store-direct steps
Skills & Extensions
Composable agent workflows and store capability extensions. Skills are reusable multi-step plans — skill-plan resolves a skill into an execution plan with extensions pre-loaded, guardrails pre-evaluated, and store endpoints ready. Extensions add custom capabilities to stores beyond the core spec.
skill-plan— resolve a skill into a deterministic execution plan- Same inputs always produce the same plan (cacheable, testable)
- Extensions fetched from UCP Registry, signature-verified
- Public skill/extension registry + workspace-private skills
plan_hashfor detecting when plans change
Hooks & Loops
Hooks are declarative interception points on any tool call — filter, transform, or inspect payloads before or after execution. Hard timeouts, no arbitrary code. Loops are cron-triggered automations that run agent workflows on a schedule without human initiation.
- Hooks: pre/post on any tool call with filter/transform/memory actions
- Hard timeout enforcement — hooks fail safe, never crash the call
- Loops: cron-scheduled, agent-scoped automations
- Loop failure policies: retry with backoff, skip, alert
Channel Integrations
Route agent interactions through messaging channels. Connect WhatsApp, Slack, SMS, and more as inbound/outbound channels. Agents reach users where they are — a loop that monitors a price can alert via Slack; a shopping session can start from a WhatsApp message.
- WhatsApp, Slack, SMS, and more
- Deterministic lane IDs per agent/user/channel combination
- Inbound: receive messages and trigger agent sessions
- Outbound: send alerts, receipts, and confirmations
Sessions & Observability
Managed session lifecycle via the Playground headless API. PII-safe by default — metadata-only recording unless you opt into full payload capture with a redaction policy. Native OTel support for dual-export to Playground and your own observability stack.
session-start/session-end/session-replay- PII safe: metadata-only by default, opt-in full payload with redaction
- OTel dual-export: Playground replays + Dash0, Datadog, Grafana, etc.
- RailsTracer SDK — client-side OTel spans as side-channel telemetry
- W3C Trace Context propagation across store-direct calls
UCP Rails MCP Endpoint
One MCP connection bootstraps your entire commerce session. Rails returns everything your agent needs to start working — guardrails, channel preferences, memory state, rate limits, and recommended first calls — then gets out of the transaction path.
POST ucprails.com/mcp— all JSON-RPC tool callsGET ucprails.com/mcp— open SSE stream for server notifications- Auth: Bearer API key (v1), MCP OAuth 2.1 with PKCE (vNext)
// bootstrap response (single call)
{
"guardrails": [...],
"channel_preferences": {...},
"rate_limits": {...},
"recommended_first_calls": [
"discover-stores",
"memory-recall"
]
}The merchant and agent registry for the UCP ecosystem. Queryable store profiles with trust scores, agent registration and discovery, and the public extensions and skills registry that UCP Rails resolves against.
Merchant Registry API
Queryable API for verified UCP merchant profiles. Each profile includes the store's profile URL, MCP endpoints, supported capabilities, transport options, trust score (from UCP Checker), and reliability data. The source of truth that UCP Rails discovery pulls from.
- Verified merchant profiles with trust scores and reliability history
- Filter by capability, transport, platform, and category
- MCP endpoint discovery — resolve a domain to its agent-ready endpoints
- Directly powers UCP Rails
discover-storesandget-store-profile - Updated continuously from UCP Checker's daily crawls
Agent Registry
Register your agent with the UCP ecosystem so stores and other agents can discover it. Define your agent's capabilities, supported channels, trust level, and endpoint — making it discoverable by UCP Rails-connected partners and integrations.
- Register agent identity, capabilities, and endpoints
- Discovery by UCP Rails-connected stores and partners
- Trust verification for agent-to-agent commerce workflows
- Agent cards compatible with the A2A transport standard
Extensions & Skills Registry
The public registry of UCP extensions (store capability add-ons) and skills (reusable agent workflows). UCP Rails resolves extensions by namespace from this registry and signature-verifies them before injection. Publish your own extensions for other agents to use.
- Browse and search public extensions and skills
- Publish extensions with signing key for cryptographic verification
- Extensions namespaced by reverse-domain convention
- UCP Rails signature-verifies all extensions at resolve time
- Versioned — new versions don't break existing integrations
Quantitative grading of UCP implementations — from static profile quality to live agent performance. The benchmark data is sourced from real agent sessions, not synthetic tests.
Runtime Grading (A–F)
Every UCP Playground session produces a Playground Score (0–100) and a runtime grade (A–F). The score combines three sub-scores: Agent Latency (20 pts), Data Quality (40 pts), and Simulation Success (40 pts). Stores are ranked on the public leaderboard by score.
Capability Adoption Tracking
Track which capabilities are being adopted across the ecosystem — and at what rate. See how many verified stores declare checkout, fulfillment, discounts, order tracking, and each spec capability. Break it down by platform, transport, and spec version.
- Per-capability adoption count across 18,824+ merchants
- Breakdown by platform (Shopify, other) and spec version
- Historical trends: which capabilities are growing fastest
- Compare your store's capability coverage to the ecosystem median
Methodology & Static Analysis
UCP Checker's check methodology is fully documented: two-step crawler (robots.txt audit + profile fetch), response classification (Verified / Invalid / Not Detected / Blocked / Unreachable), JSON validation, and latency thresholds. Static analysis tells you if your profile is valid; runtime performance tells you if it works.
- Dual-layer: static analysis (profile validity) + runtime (agent performance)
- Latency thresholds: <200ms excellent, 200–800ms fair, >800ms slow
- AI bot policy matrix: GPTBot, ClaudeBot, Google-Extended, Applebot, CCBot
- Evidence stored per check — citable HTTP status and response body
Continuous Re-Checks
Every indexed merchant is re-checked on a daily cadence, so the directory reflects live UCP status rather than a one-off snapshot. A store's status page and score always show its most recent result.
- Every verified store re-checked every 24 hours
- Status and score reflect the latest check, not a stale snapshot
- Set up alerts to be notified the moment a store's status changes
Frequently Asked Questions
What UCP developer tools are available?
What is UCP Rails?
ucprails.com/mcp and bootstrap everything they need, then transact directly with stores. Rails is never in the transaction path.What is the UCP Playground?
Is there a UCP API I can use programmatically?
/api/validator?domain={domain} (no auth), the UCP Checker MCP server at ucpchecker.com/mcp, the UCP Rails MCP control plane at ucprails.com/mcp (API key), and the UCP Registry merchant API at ucpregistry.com. Pick the one that matches your layer.Where can I find the UCP open dataset?
/stats.How do I compare these tools to other UCP tools?
Get the agentic commerce digest every Monday
Real adoption data, ecosystem trends, new spec versions, and the stores that broke or recovered this week. Read by founders and engineers building the next generation of commerce.