Glossary
One vocabulary across the product, the docs and the API. When a term here conflicts with wording you see elsewhere, this page wins. Tell us about the other place.
The four axes
Everything in the harness is one of four things: a Target (the store you test), a Driver (who does the testing: a model plus an identity), a Check (what you assert) and a Result (what comes out, usually a run).
Product and pages
| Term | Means |
|---|---|
| UCP Playground | The product: the whole test harness. |
| Runs | The page at /runs where you start a run and see your recent runs. You pick a store, type a task in the message box, set the run's pills and send. |
| History | The page at /history listing every run and Inspect session in your workspace, newest first, filtered by Everything, Runs or Inspect sessions. |
| Inspect | Where signed-in users call a store's tools by hand and read the raw responses, at /inspect. It has three views (Steps, Tools, Store) and sends calls over MCP, REST, A2A or WebMCP, and opens the store's checkout embedded from a checkout. One sitting is an Inspect session. |
| Inspector | The public tool at /inspector: discover a store and call its tools without signing in. |
| Agent | The thing that shops: a model working through the harness with an identity. Not a page. |
| How the agent reaches the store | A run setting: UCP (the store's APIs, over MCP or REST) or Website (the store's website, in a browser). A UCP run uses MCP when the store declares it and REST when that is all it declares. On a store that offers a store agent (A2A) or its own checkout (Embedded), the same setting also says how checkout goes. |
| Website run | A run where the agent opens the store's page in a browser on our side and uses the tools the page registers. Shown in The agent's browser pane. Signed-in users only; one task per run. |
| WebMCP | Tools a web page registers for agents through document.modelContext. Separate from UCP: UCP does not carry WebMCP, so it is never a UCP transport. Inspect and the public Inspector list a page's tools; a website run uses them. See WebMCP: the store page. |
| Share | The action on a run's page that makes a link anyone can open. Once a run is shared, the button reads Shared and manages the link. |
| Settings | Your account settings: Account, Workspace, Stores & endpoints, Agent, API keys, Appearance and Usage. Open them from the account menu. |
| Workspace | Where your runs, Inspect sessions, saved endpoints and API keys belong: your own (Just you) or a team's. See Switching workspace. |
| API | The programmatic surface: the same harness, headless. |
| Buyer context | Who the agent shops for: the spec's provisional buyer signals (country, region, postal code, language, currency) carried on catalog searches. Saved per account or workspace; hints for localisation, never identity. |
| Held state | What stores are holding for you: carts, checkouts, holds, booking sessions, one row per held item, mirrored from the store's own responses. Status and expiry are the store's; "Expired" means a call failed or a hold ran out. Release cancels a live booking session at the store; Forget and Dismiss only drop the row. |
| Booking session | The lodging counterpart of a checkout (dev.ucp.lodging.booking, draft): the rooms, dates and guests a buyer asked for, priced by the store, with when each amount is paid and the cancellation policy. It is held until it expires, then completed (booked) or canceled. |
| Negotiation | The connect-time readout of version selection and the capability intersection between a store's UCP profile and this platform, with a status and reason per capability. Recorded on every run and shown on its Discovery and negotiation tab. What can be settled: What a run supports. |
| Runtime | Where a run's network calls are made: Cloud (our infrastructure, the default) or Local (your machine, through the local runner, for accounts with access). Web, API, CLI and Desktop are surfaces that drive a runtime, not runtimes themselves. |
Spec alignment: Platform and Business
The UCP specification names the two parties as roles. We keep our product words, but here is the mapping, so nothing needs translating between the spec and this harness:
| UCP term | Our term | Note |
|---|---|---|
| Platform | the harness itself | The intermediary making requests. The Playground is a Platform; its /.well-known/ucp-agent profile is a Platform profile. When you point your own agent at a reference store, you are the Platform. |
| Business | Store (Target) | The merchant receiving requests and advertising capabilities. Use "Business" when quoting the spec, "store" in the product. |
| Payment Credential Provider | — | Tokenisation and payment processing. Outside the harness's boundary. |
| context (catalog search) | Buyer context | The spec's shopping/types/context.json signals. We send them where the store's tool accepts them and show whatever the store does with them. |
| Buyer / user | linked identity | The customer a Platform acts for, attached to a run through identity linking. |
Targets
| Term | Means |
|---|---|
| Target | Anything the harness points at. In the product this is almost always a store; the API keeps the word "target" (saved targets). |
| Store | A real commerce site. A store becomes a target when you point the harness at it. |
| Store type | Retail, Stays or Food: what the store sells, which sets the words and steps a run is read in. |
| Reference store | A real UCP store we host, in a chosen enforcement posture. A demo target for store builders and the validation on-ramp for agent builders. Always pre-production. |
| Test store | A store we host where every tool works end to end, with test payments only: flowers.ucpsandbox.com (Retail), stays.ucpsandbox.com (Stays) and food.ucpsandbox.com (Food). Scenario stores such as flowers-decline.ucpsandbox.com show one specific case. Nothing is charged and nothing ships. |
| Saved endpoint | A local build, staging or reference copy of a store, saved in Settings › Stores & endpoints. Runs use it as the store's pre-production environment, without discovery. |
| Local target | A target on your own machine, reached over a tunnel or, for accounts with access, the local runtime. |
| UCP profile | The store's /.well-known/ucp document: discovery and declared capabilities. The spec calls it the business profile. See UCP profile setup. |
| Environment | Whether a target is production, pre-production or a test store: a property of the target. Undeclared defaults to production, so the strictest probe gating applies. Distinct from the identity directory's production/sandbox split: a sandbox-registered key cannot verify against a production directory. |
| Transport | A way a store's UCP profile says it can be reached: MCP, REST, A2A or embedded. The harness uses all four. |
| A2A | Agent-to-Agent: a transport where the store exposes an agent, the store agent, rather than tools. UCP's A2A binding carries checkout; the harness speaks A2A 0.3 and 1.0. See A2A: the store's agent. |
| Agent card | The store agent's description, at the URL the profile's A2A entry points to (usually /.well-known/agent-card.json): its name, the A2A versions and endpoint it serves, and the UCP extension it supports. |
| UCP extension (A2A) | The A2A extension https://ucp.dev/{version}/specification/reference. A message turns it on with X-A2A-Extensions (0.3) or A2A-Extensions (1.0); a store agent that requires it refuses a message without it (-32008). |
| Conversation (A2A) | The messages that share one contextId. The store agent makes the id on the first message; the harness sends it back on every later one. The trace groups a conversation under one heading. |
| Embedded transport | A profile entry with "transport": "embedded" and a schema, no endpoint. It says the store's checkout page can open inside an agent's window. See Embedded: the store's checkout. |
| ECP | Embedded Checkout Protocol (release 2026-08-25): how a store's checkout page, loaded in a frame, and its host talk. JSON-RPC over postMessage: ec.ready, ec.start, the ec.*.change notifications, delegated requests, ec.complete and ec.error. |
| Embedded binding | An embedded service in a checkout answer's ucp.services, with config.delegate. It says this checkout can open embedded. A checkout without one is redirect only. |
| config.delegate | In the embedded binding: the actions the store lets the host handle, such as payment.credential, fulfillment.address_change, payment.instruments_change and window.open. |
| ec_delegate | The query parameter the host adds to the continue_url to ask for some of those actions. The harness asks for payment.credential and window.open on its test stores, and only window.open elsewhere, since it holds no real card. |
| Delegation | An action the store's page hands to the host. It narrows at each step: what the store allows (config.delegate), what the host asks (ec_delegate), what the page accepts (ec.ready's delegate). Discovery and negotiation shows the chain. |
Drivers
| Term | Means |
|---|---|
| Model | The LLM (Claude, GPT, Gemini and others), chosen with the Model pill. Never "the agent": the agent is the model plus the harness plus an identity. |
| Provider | The model's vendor. |
| Identity | Who the agent is: the credential it presents to a store. UCP platform identity (the default) or Unsigned when you start a run; elsewhere in the harness also Web Bot Auth (community — unsupported). The support label is part of the name. |
Checks
| Term | Means |
|---|---|
| Conformance | The check package: schema quality, identity enforcement and funnel completion, measured live. A testing loop you fix against, never a saved report or certificate. |
| Schema quality | How well a store's tool schemas guide a model: seven weighted checks, graded A–F per tool and overall. |
| Identity enforcement | Whether a store actually enforces the identity scheme it declares: measured, not assumed from the declaration. |
| Funnel | How far a run got: search → details → cart → checkout (→ payment on test stores). A Stays run reads the same steps as search stays → hold room → book → booked. |
| Probe | One deliberately changed request in a differential run. Active probes run only against reference stores, stores you own, or explicit opt-ins, never a cold third-party production endpoint. |
| Verdict | The output of any check. See below. |
Results
| Term | Means |
|---|---|
| Run | One agent attempt at one task, by one model, at one store, and its stored record: every message, tool call and event. Also the verb. Each run has its own page: the chat on the left, and the Trace, Discovery and negotiation, Timeline and Info tabs on the right. |
| Session | The older word for a run. The product now says "run"; the API keeps the old name in places (sessions:read, /api/v1/sessions). "Inspect session" is still the name for one sitting in Inspect. |
| Ending | How far a run got: Searched only, Built a cart, Reached checkout, Tried to place the order, Order placed or Failed. |
| Whose fault | When a run stops short, who caused it: the store, the agent, ours (the harness), or none. |
| Replay | Playback of a run, step by step, from Replay on its page. Shared runs replay too. |
| Trace | The run page's tab with the machine record: every request, response and error in order, with payloads and timing, as opposed to the chat the buyer sees. |
| Step screenshot | On a website run, a picture of the page: when it opened, after each step that changed what a shopper sees (the cart after a cart change, a page a tool moved to), and at the checkout reached. Shown on the run and in its replay, with "What the checkout page showed" at the checkout. |
| Collection | A saved set of targets × models × tasks: the object you create, schedule and run again. Running one is an eval (category language, not an object). |
| Leaderboard | The public ranking of models at /leaderboard, built from runs in the Playground: yours, other users' and automated collection runs alike. |
Verdict vocabulary
One language for every judgement; only the scale changes (grade, score, status, ratio). Underneath every check are five render states:
| State | Means |
|---|---|
pass | Measured, and it met the bar. |
partial | Measured, some criteria met. |
fail | Measured, the bar wasn't met. |
unknown | We could not measure reliably — never rendered as failure. |
not-run | Not attempted yet — distinct from both fail and unknown. |
Three rules apply everywhere: a pass state is a measured fact about the target (facts about our own request render neutral, never green); we report, never shame ("no gating observed", not "failed"); and unknown / not-run are always visually distinct from fail and from each other.
Identity enforcement verdicts
The identity check speaks a five-word domain vocabulary on top of those render states. Deliberately not pass/fail: a store that accepts everything is not failing a scheme, it is ignoring it.
| Verdict | Means | Renders as |
|---|---|---|
| Enforced | Valid requests accepted; every invalid variant treated differently. "Enforced" means the scheme has observable consequences — divergence, not necessarily a rejection. | pass |
| Partial | Some invalid variants are treated differently; others are accepted unchanged. | partial |
| Not enforced | No gating observed — signed and unsigned requests are treated identically. Only ever reported for a target that declares the scheme; a store that never claimed it has no identity verdict at all. | fail |
| Inconclusive | The valid signed request did not succeed, so enforcement could not be assessed. | unknown |
| Not run | Handshake only — the negative probes that produce a verdict have not been run. | not-run |
Postures
A posture is the stance a store is configured to take; a verdict is what the harness measures the behaviour to be. The interesting readouts are the disagreements — a store that believes it is Strict but measures Partial.
| Posture | Means |
|---|---|
| Strict | Valid → allow, missing → reject, invalid → reject. Recommended for production. |
| Permissive | Valid → allow, missing → allow, invalid → reject. The recommended rollout mode — an unsigned-allowed store is not a downgrade, and the missing-signature policy is reported as a characteristic, never folded into the verdict. |
| None | No enforcement. A reference-store posture for testing what "not enforced" looks like from the agent side. |
Something wrong on this page?