DEV Community: Peter

Valid JSON, broken discovery: the UCP checks that should fail your build

Peter — Sun, 05 Apr 2026 08:36:11 +0000

If your /.well-known/ucp file is valid JSON but Google AI Mode or other UCP agents still cannot use it, you do not have a formatting problem.

You have a discovery problem.

That distinction matters.

In our Apr 1, 2026 scan of 28 stores, 26 were broken or missing and 2 were unreachable. That means 92% failed before richer commerce capabilities even mattered. We also found 0 fully healthy profiles. The pattern was consistent: merchants are debating payment rails and optional capability coverage while basic UCP discovery is still broken.

This article covers the UCP checks that should fail your build - not warn, not get buried in a dashboard, but stop a deploy until fixed.

Discovery comes before checkout

UCP and ACP solve different problems.

UCP is how Google AI Mode, Gemini, and other UCP-compatible agents discover a merchant and learn which commerce services it exposes.
ACP is OpenAI and Stripe's protocol for delegated payment and ChatGPT commerce flows.

So the implementation order for most merchants is simple:

Make /.well-known/ucp fetchable
Make service endpoints callable over HTTPS
Add signing keys so integrations can verify trust boundaries
Then worry about payment handlers and ACP-specific checkout rails if your channel mix needs them

If step 1 fails, nothing later matters.

The checks that should fail your build

These are the issues I would treat as build-breaking in CI.

1. `/.well-known/ucp` is missing or not fetchable

This is the most obvious blocker and still the most common one.

From the Apr 1 scan, multiple domains scored F because of UCP_FETCH_FAILED. No manifest means no discovery. An agent cannot negotiate capabilities with a merchant it cannot find.

Quick repro:

curl -i https://example.com/.well-known/ucp

What should fail the build:

404 or 403 response
redirect loop
HTML page instead of JSON
timeout or TLS failure

What good looks like:

direct HTTPS URL
200 response
JSON body

2. Endpoint URLs are not HTTPS

UCP requires HTTPS for transport. If your manifest points to an http:// endpoint, that is not a soft warning.

That is a broken integration.

Example of a bad service definition:

{
  "ucp": {
    "version": "2026-01-11",
    "services": {
      "dev.ucp.shopping": {
        "version": "2026-01-11",
        "spec": "https://ucp.dev/specification/shopping/",
        "rest": {
          "schema": "https://ucp.dev/services/shopping/rest.openapi.json",
          "endpoint": "http://store.example.com/api/ucp"
        }
      }
    },
    "capabilities": []
  }
}

Fix it by serving the endpoint over HTTPS only:

"endpoint": "https://store.example.com/api/ucp"

Related validator rule:

UCP_ENDPOINT_NOT_HTTPS

3. Endpoint URLs have a trailing slash mismatch

This looks minor. It is not.

The UCP reference guidance says endpoint URLs should not use trailing slashes. In practice, trailing slash mismatches create annoying agent and proxy bugs, especially when paths are concatenated into checkout routes like /checkout-sessions.

Bad:

"endpoint": "https://store.example.com/api/ucp/"

Safer:

"endpoint": "https://store.example.com/api/ucp"

Related validator rule:

UCP_ENDPOINT_TRAILING_SLASH

This should fail CI because it is the kind of issue that passes visual review and still breaks requests later.

4. `ucp.version` is missing or malformed

UCP uses date-based versioning.

Current stable version in the reference docs:

2026-01-11

If your file omits ucp.version or uses the wrong format, agents cannot reliably interpret your profile.

Bad:

{
  "ucp": {
    "services": {},
    "capabilities": []
  }
}

Also bad:

{
  "ucp": {
    "version": "v1",
    "services": {},
    "capabilities": []
  }
}

Good:

{
  "ucp": {
    "version": "2026-01-11",
    "services": {},
    "capabilities": []
  }
}

Related validator rules:

UCP_MISSING_VERSION
UCP_INVALID_VERSION_FORMAT

5. The root `ucp` object is missing

A surprising number of machine-readable files are still structurally wrong in basic ways.

If the root ucp object is missing, the profile is not a UCP profile.

Bad:

{
  "version": "2026-01-11",
  "services": {},
  "capabilities": []
}

Good:

{
  "ucp": {
    "version": "2026-01-11",
    "services": {},
    "capabilities": []
  }
}

Related validator rule:

UCP_MISSING_ROOT

This is exactly the kind of issue validators should catch instantly and CI should block.

6. Namespace authority and schema origins do not match

UCP uses reverse-domain namespaces for capabilities and services. The schema origin needs to line up with namespace authority.

If it does not, you create ambiguity and trust problems.

Related validator rule:

UCP_NS_ORIGIN_MISMATCH

This is not just tidiness. It is part of how UCP avoids spoofing and keeps capability ownership clear.

7. Signing keys are missing

This is one of the most important examples of a check teams incorrectly downgrade to a warning.

In our Apr 1 scan, several C-grade profiles had a live manifest but were still missing signing keys, including allbirds.com, gymshark.com, kyliecosmetics.com, fashionnova.com, colourpop.com, brooklinen.com, and chubbiesshorts.com.

Those stores are ahead of merchants with no manifest at all. But missing signing keys is still serious because UCP integrations rely on cryptographic verification for trust-sensitive flows like webhook verification.

Related validator rule:

UCP_MISSING_SIGNING_KEYS

Minimal JWK example:

"signing_keys": [
  {
    "kid": "key-1",
    "kty": "EC",
    "crv": "P-256",
    "x": "...",
    "y": "...",
    "use": "sig",
    "alg": "ES256"
  }
]

If your team is deciding what fails CI and what only warns, this belongs in the fail bucket.

What should warn instead of fail

Not every UCP issue should block a deploy.

This is where teams overreact.

Google's merchant guidance makes it clear that capabilities are merchant-selected. That means optional capability gaps should not automatically be treated the same way as discovery failures.

For example:

missing optional capability coverage
extension drift
richer cart or catalog support not yet implemented

Those can be warnings.

The validator should separate:

discovery-critical blockers
trust and endpoint correctness blockers
optional capability drift
non-UCP site quality hints such as Schema.org organization or return policy gaps

That severity split is the difference between a validator developers trust and a noisy checklist they ignore.

A practical CI workflow

A good UCP validation job should do three things:

return stable rule IDs
print copy-paste repro commands
emit machine-readable JSON for diffs and pull request checks

Example shell step:

curl -sS https://example.com/.well-known/ucp | jq .

Example policy:

fail on UCP_FETCH_FAILED
fail on UCP_ENDPOINT_NOT_HTTPS
fail on UCP_ENDPOINT_TRAILING_SLASH
fail on UCP_MISSING_VERSION
fail on UCP_INVALID_VERSION_FORMAT
fail on UCP_MISSING_ROOT
fail on UCP_NS_ORIGIN_MISMATCH
fail on UCP_MISSING_SIGNING_KEYS
warn on optional capability gaps
warn on non-blocking metadata issues

That keeps your build focused on what actually breaks discovery and callable commerce.

Where ACP fits

ACP still matters.

But only after discovery works.

ACP is about delegated payment and ChatGPT-oriented commerce flows. It has its own requirements, such as checkout endpoints, product feeds, and payment handler readiness. It is a separate implementation track from hosting a correct UCP manifest for Google and other UCP agents.

So if your team is debating whether to spend this sprint on Stripe delegated payment support or on fixing /.well-known/ucp, the answer for most merchants is:

Fix UCP discovery first.

Payments headlines are louder.

Discovery bugs are what actually keep you invisible.

Final takeaway

Valid JSON is not the bar.

Discoverable, trustworthy, callable UCP is the bar.

The fastest way to improve merchant readiness is to stop treating discovery blockers like low-priority lint errors. If an agent cannot fetch your manifest, trust your keys, or call your endpoints over HTTPS, your store is not ready for agentic commerce.

Fail those checks in CI.

Everything else can come after.

Valid JSON Valid UCP: 10 Checks That Should Fail Your Build

Peter — Tue, 31 Mar 2026 16:08:40 +0000

Your UCP manifest passes JSON.parse(). Your linter is happy. But Google AI Mode, Gemini, and every other AI shopping agent that hits /.well-known/ucp silently moves on to the next store.

Why? Because valid JSON is not valid UCP. The protocol has structural, security, and network requirements that go beyond syntax. Miss any of them, and you're invisible.

This post covers the 10 checks that actually break AI agent discovery — not the optional capabilities you can safely skip. Each check includes its rule ID, what breaks, and a concrete fix.

The Discovery Hierarchy

When an AI agent visits your store, it follows a strict sequence:

1. FETCH  — Can I reach /.well-known/ucp over HTTPS?
2. PARSE  — Is the response valid UCP (not just valid JSON)?
3. VERIFY — Are endpoints reachable, schemas fetchable, keys present?
4. NEGOTIATE — Do our capabilities intersect?

Fail at level 1, and nothing else matters. Fail at level 2, and the agent can't understand your profile. Levels 3 and 4 are where most subtle bugs hide.

Google's own Merchant UCP guide says capabilities are opt-in: "select the set of capabilities & extensions you want to support." Missing Cart or Catalog is fine. Missing a fetchable endpoint is fatal.

The 10 Discovery-Critical Checks

Level 1: Fetchable

1. `UCP_PROFILE_FETCH_FAILED` — Manifest unreachable

The single most common failure. The agent sends:

curl -s -o /dev/null -w "%{http_code}" https://yourstore.com/.well-known/ucp

If this returns anything other than 200 with Content-Type: application/json, you're invisible.

Common causes:

CDN/reverse proxy strips /.well-known/ paths
Squarespace/Wix can't serve arbitrary well-known paths natively
Docker/nginx misconfiguration blocks the route
SSL certificate issues (agents require valid HTTPS)

Fix: Verify the path is routable in your web server config. For platforms that can't serve /.well-known/, use Shopify's ucp-proxy or a Cloudflare Worker.

2. `UCP_ENDPOINT_NOT_HTTPS` — HTTP endpoint in profile

Every URL in your UCP profile must use HTTPS. No exceptions.

// BAD
"endpoint": "http://api.store.com/ucp"

// GOOD
"endpoint": "https://api.store.com/ucp"

This applies to service endpoints, spec URLs, and schema URLs. Agents won't downgrade to HTTP.

Level 2: Parseable

3. `UCP_MISSING_ROOT` — No `ucp` object

The profile must have a root ucp key. Serving raw capabilities without the wrapper object fails parsing immediately.

// BAD — looks right, isn't
{
  "version": "2026-01-11",
  "capabilities": [...]
}

// GOOD — wrapped in ucp object
{
  "ucp": {
    "version": "2026-01-11",
    "services": {...},
    "capabilities": [...]
  }
}

4. `UCP_MISSING_VERSION` / `UCP_INVALID_VERSION_FORMAT` — Bad version

UCP uses date-based versioning: YYYY-MM-DD. Not semver. Not integers.

// BAD
"version": "1.0"
"version": "2026"
"version": "January 2026"

// GOOD
"version": "2026-01-11"

Agents use the version to negotiate protocol compatibility. No version = no negotiation.

5. `UCP_MISSING_SERVICES` — No services object

Services define your transport bindings (REST, MCP, A2A). Without them, the agent has no API to call.

"services": {
  "dev.ucp.shopping": {
    "version": "2026-01-11",
    "spec": "https://ucp.dev/specification/shopping/",
    "rest": {
      "schema": "https://ucp.dev/services/shopping/rest.openapi.json",
      "endpoint": "https://yourstore.com/api/ucp"
    }
  }
}

6. `UCP_MISSING_CAPABILITIES` — No capabilities array

Capabilities tell the agent what your store supports (checkout, catalog, fulfillment). An empty or missing array means: "I support nothing."

Level 3: Verifiable

7. `UCP_NS_ORIGIN_MISMATCH` — Schema URL spoofing

This is a security check. UCP uses reverse-domain naming (dev.ucp.shopping.checkout), and the spec/schema URLs must match the namespace authority.

// BAD — capability claims dev.ucp.* but schema is on random domain
{
  "name": "dev.ucp.shopping.checkout",
  "schema": "https://evil.com/fake-checkout.json"  // FAILS
}

// GOOD — dev.ucp.* schemas come from ucp.dev
{
  "name": "dev.ucp.shopping.checkout",
  "schema": "https://ucp.dev/schemas/shopping/checkout.json"
}

This prevents a store from claiming official UCP capabilities while pointing to modified schemas.

8. `UCP_ORPHANED_EXTENSION` — Extension without parent

Extensions like Fulfillment or Discount must reference a parent capability via extends. If the parent isn't in your capabilities array, the extension is orphaned and gets pruned during negotiation.

// BAD — fulfillment extends checkout, but checkout isn't listed
"capabilities": [
  {
    "name": "dev.ucp.shopping.fulfillment",
    "extends": "dev.ucp.shopping.checkout"
  }
]

// GOOD — parent capability is present
"capabilities": [
  { "name": "dev.ucp.shopping.checkout", ... },
  {
    "name": "dev.ucp.shopping.fulfillment",
    "extends": "dev.ucp.shopping.checkout",
    ...
  }
]

9. `UCP_MISSING_SIGNING_KEYS` — No webhook verification keys

UCP requires JWK public keys for webhook signature verification. Without them, the agent can't trust your store's callbacks.

"signing_keys": [
  {
    "kid": "key-1",
    "kty": "EC",
    "crv": "P-256",
    "x": "f83OJ3D2xF1Bg8vub9tLe1gH...",
    "y": "x_FEzRu9m36HLN_tue659LNp...",
    "use": "sig",
    "alg": "ES256"
  }
]

Generate a key pair with:

npx @ucptools/validator generate-keys --algorithm ES256

10. `UCP_ENDPOINT_TRAILING_SLASH` — Trailing slash in URL

Small but real. Trailing slashes in endpoint URLs cause path resolution bugs when agents append checkout paths.

// BAD
"endpoint": "https://api.store.com/ucp/"

// GOOD
"endpoint": "https://api.store.com/ucp"

What About Cart, Catalog, and Identity Linking?

Cart and Catalog are draft specs (published March 19, 2026). Identity Linking is stable. But none of them are discovery-critical.

Google's guide is explicit: capabilities are opt-in. A valid UCP profile with only Checkout is fully functional for AI agent commerce. Your validator should:

Error on the 10 checks above — these break discovery
Warn on Cart/Catalog schema drift — draft specs change
Error on Identity Linking config issues — stable spec, strict validation
Ignore missing optional capabilities — not a failure

Running These Checks in CI

Install the validator:

npm install @ucptools/validator

Validate in your build pipeline:

import { validateProfile } from '@ucptools/validator';

const profile = JSON.parse(fs.readFileSync('.well-known/ucp', 'utf-8'));
const report = validateProfile(profile);

if (!report.ok) {
  console.error('UCP validation failed:');
  report.issues
    .filter(i => i.severity === 'error')
    .forEach(i => console.error(`  ${i.code}: ${i.message}`));
  process.exit(1);
}

Or validate a live domain:

npx @ucptools/validator validate --url yourstore.com

Each issue comes with a rule ID (like UCP_ENDPOINT_NOT_HTTPS), a JSON path (like $.ucp.services.dev.ucp.shopping.rest.endpoint), and a fix hint. Designed for CI output, not just dashboards.

A GitHub Action wrapper (ucptools/validate-action@v1) is coming this week — validate on every PR, fail on discovery-critical errors, post results as PR comments.

TL;DR

Check	Rule ID	Level	What Breaks
Manifest unreachable	`UCP_PROFILE_FETCH_FAILED`	Fetch	Everything
HTTP endpoint	`UCP_ENDPOINT_NOT_HTTPS`	Fetch	Agent refuses connection
No `ucp` root object	`UCP_MISSING_ROOT`	Parse	Profile unparseable
Bad version format	`UCP_INVALID_VERSION_FORMAT`	Parse	No negotiation possible
No services	`UCP_MISSING_SERVICES`	Parse	No API to call
No capabilities	`UCP_MISSING_CAPABILITIES`	Parse	"Store supports nothing"
Schema origin mismatch	`UCP_NS_ORIGIN_MISMATCH`	Verify	Security rejection
Orphaned extension	`UCP_ORPHANED_EXTENSION`	Verify	Extension silently pruned
Missing signing keys	`UCP_MISSING_SIGNING_KEYS`	Verify	Webhooks untrusted
Trailing slash	`UCP_ENDPOINT_TRAILING_SLASH`	Verify	Path resolution bugs

Capabilities are opt-in. Discovery is not.

Free validation at ucptools.dev. npm package: @ucptools/validator. CLI, API, and CI integration included.

How to Check Polish Company Insolvency Programmatically (KRZ Scraper)

Peter — Tue, 31 Mar 2026 09:24:13 +0000

TL;DR

Poland's KRZ (Krajowy Rejestr Zadluzonych) tracks all bankruptcy, restructuring, and enforcement proceedings
The government has never released a public API despite 4+ years of promises
The only alternatives are manual web searches or MGBI's paid subscription (200-500 EUR/month)
I built an Apify actor that captures a JWT token from the portal and calls the internal REST API directly - giving you structured JSON for $0.05/entity check

The Problem

If you work in credit risk, compliance, or debt collection in Poland, you need to check the KRZ constantly. Is this company in bankruptcy? Has restructuring been filed? Are there enforcement proceedings?

The government portal at krz.ms.gov.pl lets you search manually - one company at a time, through a slow AngularJS interface. There's no API, no bulk export, no way to automate it.

The only commercial provider, MGBI, charges 200-500 EUR/month for API access. Great for banks, overkill for everyone else.

The Solution

The KRZ portal is a Single Page Application that loads Angular sub-apps in iframes. These sub-apps talk to REST APIs on the government's OpenShift backend. The APIs require a JWT token that's issued during app initialization.

My actor:

Launches a headless browser via Puppeteer
Loads the KRZ portal and triggers the Angular sub-app
Captures the JWT token from the sub-app's first API request
Uses the JWT to call the REST API directly - no DOM interaction, no fragile selectors

The result: structured JSON from 9 different search endpoints, covering everything the KRZ portal offers.

What You Can Search

Search Mode	What It Finds	Example Input
`entity`	Companies with proceedings	`{"entityName": "Getin"}`
`person`	Natural persons by PESEL/NIP	`{"identifier": "12345678901"}`
`soleTrader`	Sole traders (JDG)	`{"entityName": "Uslugi budowlane"}`
`signature`	By court case signature	`{"caseSignature": "WA1M/GUp/44/2023"}`
`announcements`	Court notices and rulings	`{"entityName": "Getin", "dateFrom": "2024-01-01"}`
`shareholders`	Partners in personal companies	`{"identifier": "0000585174"}`
`advisors`	Restructuring advisors	`{"entityName": "Nowak"}`
`proceedingDetails`	Full case deep-dive	`{"proceedingId": "uuid-from-search"}`

Step-by-Step: Check 100 Companies in 10 Minutes

1. Create a free Apify account

Go to apify.com and sign up. You get $5 in free credits - enough for about 70 company checks.

2. Navigate to the actor

Open the KRZ Debtor Registry Scraper in the Apify Store.

3. Configure your input

For a single company check:

{
  "searchMode": "entity",
  "entityName": "Getin Noble Bank",
  "maxResults": 10
}

For a batch check by KRS numbers, use the API:

const { ApifyClient } = require('apify-client');
const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const krsNumbers = ['0000585174', '0000028860', '0000635012'];

for (const krs of krsNumbers) {
    const run = await client.actor('minute_contest/krz-debtor-scraper').call({
        searchMode: 'entity',
        identifier: krs,
        maxResults: 5,
    });
    const { items } = await client.dataset(run.defaultDatasetId).listItems();
    console.log(`KRS ${krs}: ${items.length} proceedings found`);
}

4. Read the results

Each result includes:

{
  "entityName": "GETIN RENT SPOLKA Z OGRANICZONA ODPOWIEDZIALNOSCIA",
  "nip": "8992777278",
  "krs": "0000585174",
  "proceedingId": "96dd6ffc-191c-41ce-bcc4-998524e4efd2",
  "proceedingType": "restructuring",
  "court": "Sad Rejonowy dla Wroclawia-Fabrycznej we Wroclawiu"
}

5. Deep-dive into a specific proceeding

Take the proceedingId from step 4 and get full details:

{
  "searchMode": "proceedingDetails",
  "proceedingId": "96dd6ffc-191c-41ce-bcc4-998524e4efd2"
}

This returns: case signature, court, start/end dates, all participants, judge history, advisor assignments, address history, and all announcements.

Pricing

Volume	Cost	vs MGBI
1 company	$0.15	Free trial vs 200 EUR/month
100 companies	$5.10	30x cheaper
1,000 companies/month	$50	3-7x cheaper
10,000 companies/month	$300 (GOLD tier)	Comparable, no contract

Part of the Polish Business Data Suite

This actor is one of five covering Polish government registries:

eKRS Financial Statements - Balance sheets and income statements from KRS
KRS Board Members - Full (non-anonymized) director names
KNF Financial Registry - Payment institutions, credit intermediaries
MSiG Court Gazette - Bankruptcy and liquidation announcements
KRZ Debtor Registry - Insolvency and restructuring proceedings (this actor)

Together, they give you a complete Polish company intelligence workflow:

Is the company solvent?       -> KRZ
Any court proceedings?        -> MSiG
What's their financial health -> eKRS
Who runs the company?         -> KRS Board Members
Are they properly licensed?   -> KNF

Technical Details

For those interested in how the reverse engineering works:

1. Architecture discovery

The KRZ portal (krz.ms.gov.pl) is an AngularJS shell that loads Angular sub-apps via iframes from OpenShift backends (krz-rejpub-gui-krz-pub-prod.apps.ocp.prod.ms.gov.pl). Each module (entity search, announcements, advisors) is a separate Angular app on the same OpenShift cluster.

2. JWT capture

The sub-app obtains a JWT during initialization. We intercept it from the Authorization: bearer ... header on the first API request using Puppeteer's request interception. The JWT is valid for about 30 minutes.

3. API endpoints

30+ REST endpoints discovered by searching the Angular bundle's compiled JavaScript for URL patterns matching krzPubApiUrl + "...". Key endpoints include:

postepowanie/wyszukaj-po-podmiocie - entity search
postepowanie/wyszukaj-po-of - person search
obwieszczenie/wyszukaj-po-podmiocie - announcements
postepowanie/szczegoly - proceeding details
rdr-api/wyszukiwarka/doradcy - restructuring advisors (different backend)

4. No DOM scraping

After JWT capture, all data comes from direct HTTP calls. The browser is closed. This makes the actor fast (~1s per query after session setup) and resilient to UI changes.

5. The encryption keys

The KRS board members portal (separate project) uses AES-128-CBC encryption with a static key TopSecretApiKey1 and a 512-character steganographic token that embeds the KRS number at specific array positions. Yes, the key is literally hardcoded in the frontend JavaScript.

Built with Apify. Questions? Open an issue on the actor page.

ClickUp + MCP: the practical setup + 5 automation patterns (Claude Desktop / ChatGPT / n8n)

Peter — Fri, 27 Mar 2026 13:50:54 +0000

ClickUp is one of those tools that feels like it should be perfect for AI agents:

tasks are structured
work is already in lists/spaces
there's a clear "read → decide → update" loop

But most "AI + ClickUp" integrations I see fall into two buckets:

Chat-only: the model can talk about tasks but can't actually change anything.
Fragile automations: one webhook + one action; no real planning loop.

If you want an agent that can inspect work, make a plan, and apply changes (create tasks, update statuses, move between lists, write docs, etc.), MCP is a good fit.

This post is a developer-focused walkthrough:

how to connect a ClickUp MCP server to an MCP client (Claude Desktop / ChatGPT / n8n)
what auth scopes you actually need
5 workflows that are worth automating
common failure modes (timeouts, tool naming collisions, rate limits)

I packaged a ClickUp MCP Server on Apify, so you don't need to run a local MCP process:
ClickUp MCP Server on Apify

It exposes 20 tools (not just tasks): spaces, folders, lists, views, and docs.

What you need before you start

1) A ClickUp personal token

In ClickUp: Settings → Apps → API Token (wording varies by plan/UI).

Treat it like a password.

2) IDs you'll use a lot

Most of your flows will start by locating:

team_id (workspace)
space_id
folder_id (optional)
list_id

A good MCP setup gives the model tools to discover these, instead of hardcoding them.

Option A: Use a hosted MCP server (no local Node process)

If your MCP client supports connecting to a remote MCP endpoint (SSE), a hosted server avoids the "my local server died" class of problems.

The Apify actor runs in Standby mode (persistent server) and Batch mode (one-shot runs).

Actor page: apify.com/minute_contest/clickup-mcp-server

Note: MCP client configuration differs across Claude Desktop / Cursor / ChatGPT / n8n. The principle is the same: register the server, provide auth secrets, then let the client call tools.

Option B: n8n pattern (agent-in-the-middle)

If you're already using n8n, one solid pattern is:

n8n receives a trigger (Cron / webhook / Slack)
n8n calls your LLM (planning step)
the LLM calls MCP tools to read/write ClickUp
n8n posts results somewhere (Slack / email)

Why this works:

n8n is great at deterministic orchestration
the model is great at decisions and text generation
MCP tools provide the side effects (ClickUp writes)

5 ClickUp workflows that are actually worth automating

1) Triage new tasks into the right list + fill missing fields

Problem: People dump tasks into an "Inbox" list with no priority, no owner, vague title.

Agent loop:

read newest tasks in Inbox
classify by project
set priority, assignees, due date
move to the correct list

MCP tools you'll use: list tasks → update task → move task

Tip: Keep a "classification rubric" in a ClickUp Doc so the model can read it and stay consistent.

2) Daily standup summary from "In Progress"

Problem: Standups become status theater.

Agent loop:

pull tasks in relevant lists filtered by status
summarize by assignee
detect blockers (stale tasks, no updates)
post to Slack

MCP tools: list tasks + read task details

3) Convert meeting notes into tasks + link to the notes doc

Problem: Action items die in Google Docs.

Agent loop:

watch a "Meeting notes" doc (or paste notes)
extract action items
create tasks in the right list
link back to the doc section

MCP tools: create tasks + create/update docs (if you keep notes in ClickUp Docs)

4) "Release checklist" generator per project

Problem: Every release repeats the same 30 steps.

Agent loop:

read project type (web app / mobile / infra)
generate a checklist as subtasks
attach standard QA template

MCP tools: create task + create subtasks + update description

5) Weekly cleanup: stale tasks + duplicate detection

Problem: ClickUp accumulates zombie tasks.

Agent loop:

find tasks with no activity in N days
mark as "Needs review"
detect near-duplicates (same title, same list)
propose merges or close-outs

MCP tools: search/list + update

Common MCP failure modes (and how to debug fast)

1) Tool collisions (multiple MCP servers enabled)

Some MCP clients have had issues where tools from one server get mis-routed when many servers are enabled.

Debug:

temporarily disable other MCP servers
restart the client
confirm the tool list shows ClickUp tools with consistent prefixes/names

2) Timeouts on "big list" queries

If you ask for "all tasks in a busy space", you'll hit client timeouts or API pagination.

Fix:

fetch by list, not entire space
constrain by updated date
paginate

3) Rate limits

ClickUp APIs will throttle you if you hammer endpoints.

Fix:

batch reads
cache IDs (team/space/list)
add backoff / retry in your orchestration layer (n8n or your agent runtime)

When MCP is overkill

Honest take: if your use case is "create a task when a form is submitted", you don't need MCP. A standard automation tool is simpler.

MCP becomes valuable when you want:

interactive exploration (agent discovers IDs, lists, docs)
multi-step edits (read → decide → write)
structured side effects (no brittle UI automation)

Try it / poke holes in it

If you're building agentic workflows on top of ClickUp, I'd love to see what patterns you're using.

Actor (hosted ClickUp MCP server):
apify.com/minute_contest/clickup-mcp-server

If you want, reply with:

your ClickUp structure (spaces/lists)
one painful workflow

...and I'll suggest a minimal MCP tool-call plan.

UCP Cart, Catalog, and Identity Linking: What to Validate (and What Can Wait)

Peter — Wed, 25 Mar 2026 07:28:47 +0000

Google shipped the first major UCP update on March 19, 2026 - three new capabilities: Cart, Catalog, and Identity Linking. If you're a merchant or platform developer implementing UCP, you now have more to validate.

But here's the thing most guides won't tell you: not all three capabilities have the same stability level. Cart and Catalog are draft specs. Identity Linking is stable. Treating them the same way in your validation pipeline is a mistake.

This post breaks down what changed, what to validate strictly, what to treat as warnings, and provides a minimal checklist for keeping your /.well-known/ucp profile working.

What Changed on March 19

Capability	Namespace	Status	What It Does
Cart	`dev.ucp.shopping.cart`	Draft	Multi-item basket management before checkout
Catalog Search	`dev.ucp.shopping.catalog.search`	Draft	Product search by keyword, category, attributes
Catalog Lookup	`dev.ucp.shopping.catalog.lookup`	Draft	Direct product lookup by ID
Identity Linking	`dev.ucp.common.identity_linking`	Stable	OAuth 2.0 account linking via RFC 8414 discovery

Cart and Catalog are published under ucp.dev/draft/specification/ - note the /draft/ path. Identity Linking shipped in the stable spec at launch in January.

This distinction matters for validation.

Draft vs Stable: Why Your Validator Needs to Know

If you hard-fail on a draft capability's schema mismatch, you'll generate noise. Draft specs change. That's the point of a draft.

If you silently pass a broken /.well-known/ucp endpoint, you'll miss the errors that actually prevent AI agents from discovering your store.

The right approach: severity-aware validation.

Stable capabilities  -> errors on failure
Draft capabilities   -> warnings on failure
Discovery blockers   -> always errors, regardless of capability status

Here's a concrete example. Say a merchant adds Cart support but uses an outdated schema URL that doesn't match the current draft:

{
  "name": "dev.ucp.shopping.cart",
  "version": "2026-01-11",
  "spec": "https://ucp.dev/draft/specification/cart/",
  "schema": "https://ucp.dev/schemas/shopping/cart.json"
}

Should your validator fail this? No - warn. The schema URL might be temporarily ahead of or behind the draft. The capability is structurally valid. The merchant is doing the right thing by declaring Cart support early.

But if that same profile is missing signing keys entirely? That's an error. No agent can trust the merchant without them, draft or not.

The Cart Capability: What to Validate

Cart (dev.ucp.shopping.cart) supports four operations:

Create Cart - initialize a basket with line items
Get Cart - retrieve current cart state
Update Cart - full replacement of cart contents
Cancel Cart - terminate the session

Required Fields in Cart Response

{
  "ucp": {
    "version": "2026-01-15",
    "status": "success"
  },
  "id": "cart_abc123",
  "line_items": [
    {
      "id": "li_1",
      "item": {
        "id": "product_42",
        "title": "Blue Widget",
        "price": { "amount": "29.99", "currency": "USD" }
      },
      "quantity": 2,
      "totals": [
        { "type": "subtotal", "amount": "59.98", "currency": "USD" }
      ]
    }
  ],
  "currency": "USD",
  "totals": [
    { "type": "subtotal", "amount": "59.98", "currency": "USD" }
  ]
}

Validation Checklist for Cart

[ ] Capability declared with correct namespace dev.ucp.shopping.cart
[ ] Version follows YYYY-MM-DD format
[ ] Spec URL points to draft path (ucp.dev/draft/specification/cart/)
[ ] If REST binding: endpoint is HTTPS, no trailing slash
[ ] Cart-to-checkout conversion: if Checkout capability is also declared, verify cart_id can be passed to Create Checkout
[ ] Severity: WARN on schema drift (draft spec may change)
[ ] Severity: ERROR on missing required fields (id, line_items, currency, totals)

Cart-to-Checkout Conversion

A key detail from the spec: when Cart is negotiated alongside Checkout, platforms convert carts to checkout sessions by passing cart_id in the Create Checkout request. The spec requires idempotency - if an incomplete checkout already exists for that cart_id, the business must return the existing session.

This is worth testing if you support both capabilities.

The Catalog Capabilities: What to Validate

Per the official spec, Catalog is split into two sub-capabilities:

Catalog Search (dev.ucp.shopping.catalog.search) - agents query by keyword, category, or attributes
Catalog Lookup (dev.ucp.shopping.catalog.lookup) - agents fetch specific products by ID

Each has its own schema: catalog_search.json and catalog_lookup.json. The value is real-time data - agents check live inventory, current pricing, and variant availability instead of relying on static product feeds.

Validation Checklist for Catalog

[ ] Capabilities declared with correct namespaces (...catalog.search and/or ...catalog.lookup)
[ ] Spec URL points to draft path (ucp.dev/draft/specification/catalog/)
[ ] Schemas point to correct files (catalog_search.json / catalog_lookup.json)
[ ] Endpoint responds with valid product data (not HTML error pages)
[ ] Product fields include required: id, title, description, price_range, variants
[ ] Variant price uses minor currency units + ISO 4217 currency code
[ ] Severity: WARN on schema drift
[ ] Severity: ERROR on unreachable endpoint or non-JSON response

Identity Linking: What to Validate

Unlike Cart and Catalog, Identity Linking is stable. It was part of the UCP spec at launch. Validate strictly.

Identity Linking uses namespace dev.ucp.common.identity_linking - note the common service, not shopping. It's declared as a capability in the capabilities array with a config object containing supported_mechanisms.

The mechanism uses OAuth 2.0 with RFC 8414 discovery - you declare an issuer URI, and OAuth endpoints are discovered automatically via /.well-known/oauth-authorization-server. You do NOT put authorization_endpoint or token_endpoint directly in the profile.

Validation Checklist for Identity Linking

[ ] Capability declared with namespace dev.ucp.common.identity_linking
[ ] config.supported_mechanisms array has at least one entry
[ ] Each mechanism has a type field (currently only "oauth2")
[ ] OAuth2 mechanism has an issuer URI using HTTPS
[ ] Issuer supports RFC 8414 discovery
[ ] Severity: ERROR on all failures (stable spec)

The 7 Rules That Actually Break Discovery

Before worrying about Cart, Catalog, or Identity Linking, make sure the basics work. These are the validation failures that prevent AI agents from discovering your store at all:

1. Missing or malformed `/.well-known/ucp`

Code: UCP_MISSING_ROOT
Fix:  Serve a valid JSON object with a "ucp" property at /.well-known/ucp

If this fails, nothing else matters. The agent can't find you.

2. Missing or invalid version

Code: UCP_MISSING_VERSION / UCP_INVALID_VERSION_FORMAT
Fix:  Add "version": "2026-01-11" (YYYY-MM-DD format, not semver)

Common mistake: using "1.0" instead of a date string.

3. HTTP endpoints (not HTTPS)

Code: UCP_ENDPOINT_NOT_HTTPS
Fix:  All endpoint URLs must use https://

No exceptions. HTTP endpoints are rejected by conformant agents.

4. Trailing slashes on endpoints

Code: UCP_ENDPOINT_TRAILING_SLASH
Fix:  https://example.com/api/ucp (not https://example.com/api/ucp/)

Subtle but real. Some web servers handle this fine. The spec says no trailing slash.

5. Namespace/origin mismatch

Code: UCP_NS_ORIGIN_MISMATCH
Fix:  Schema URLs must match the namespace authority

If your capability uses the dev.ucp.* namespace, schema URLs must come from ucp.dev. Vendor capabilities must use their own domain. This prevents spoofing.

6. Orphaned extensions

Code: UCP_ORPHANED_EXTENSION
Fix:  Every extension needs its parent capability declared

If you declare dev.ucp.shopping.fulfillment (an extension of Checkout) but don't declare dev.ucp.shopping.checkout, agents will prune the extension during capability negotiation. It's dead weight.

7. Missing signing keys

Code: UCP_MISSING_SIGNING_KEYS
Fix:  Add JWK public keys in the signing_keys array

{
  "signing_keys": [
    {
      "kid": "key-1",
      "kty": "EC",
      "crv": "P-256",
      "x": "...",
      "y": "...",
      "use": "sig",
      "alg": "ES256"
    }
  ]
}

Without signing keys, webhook verification fails. Agents can't trust your responses.

Putting It Together: A Severity Matrix

Check	Severity	Why
`/.well-known/ucp` serves valid JSON	ERROR	Discovery completely blocked
Version is valid YYYY-MM-DD	ERROR	Agent can't negotiate
All endpoints HTTPS	ERROR	Spec requirement, agents reject HTTP
No trailing slashes	ERROR	Spec requirement
Namespace/origin match	ERROR	Security - prevents spoofing
Signing keys present	ERROR	Webhook trust broken
No orphaned extensions	ERROR	Extensions pruned, wasted config
Cart schema matches draft	WARN	Draft spec, may change
Catalog Search/Lookup schema matches draft	WARN	Draft spec, may change
Identity Linking has valid mechanisms	ERROR	Stable spec
Identity Linking issuer is HTTPS	ERROR	Stable spec
Cart endpoint returns valid JSON	ERROR	Unreachable = broken
Catalog endpoint returns valid JSON	ERROR	Unreachable = broken

The pattern: structure and reachability are always errors. Schema conformance on draft specs is a warning.

CI/CD Integration

If you're validating UCP profiles in CI, here's what a validation-as-diff output looks like:

$ npx ucptools validate https://example.com/.well-known/ucp

 PASS  Structural validation
 PASS  Version format (2026-01-11)
 FAIL  UCP_ENDPOINT_NOT_HTTPS
       Path: $.ucp.services.dev.ucp.shopping.rest.endpoint
       Found: http://example.com/api/ucp
       Fix: Change to https://example.com/api/ucp

 FAIL  UCP_MISSING_SIGNING_KEYS
       Path: $.signing_keys
       Fix: Add at least one JWK public key (Ed25519 or ES256)

 WARN  Cart schema URL may not match current draft
       Path: $.ucp.capabilities[2].schema
       Spec: https://ucp.dev/draft/specification/cart/

2 errors, 1 warning

Each issue has a rule ID, a JSON path, and a fix. Copy-paste friendly. Greppable. CI-ready.

What About Merchant Center Onboarding?

Google is also simplifying UCP onboarding through Merchant Center, rolling out "over the coming months." One detail worth noting: only product listings with the native_commerce product attribute will display the checkout button in Google's AI experiences.

This is implementation-specific to Google's surfaces - it's not part of the UCP spec itself. But if you're building for Google AI Mode specifically, it's a requirement you'll need to track.

Quick Reference: The Minimal Checklist

Before adding any new capabilities:

[ ] /.well-known/ucp returns valid JSON with Content-Type: application/json
[ ] ucp.version is "2026-01-11" (YYYY-MM-DD)
[ ] All endpoint URLs are HTTPS, no trailing slashes
[ ] Signing keys array has at least one valid JWK
[ ] No namespace/origin mismatches
[ ] No orphaned extensions

Adding Cart (draft):

[ ] Namespace: dev.ucp.shopping.cart
[ ] Spec URL: https://ucp.dev/draft/specification/cart/
[ ] Endpoint reachable and returns JSON
[ ] If also supporting Checkout: test cart-to-checkout conversion

Adding Catalog (draft):

[ ] Namespace: dev.ucp.shopping.catalog.search and/or dev.ucp.shopping.catalog.lookup
[ ] Spec URL: https://ucp.dev/draft/specification/catalog/
[ ] Schema: catalog_search.json / catalog_lookup.json (separate files)
[ ] Endpoint reachable and returns JSON
[ ] Product data includes required fields (id, title, description, price_range, variants)

Adding Identity Linking (stable):

[ ] Namespace: dev.ucp.common.identity_linking (note: common, not shopping)
[ ] config.supported_mechanisms has at least one entry
[ ] OAuth2 mechanism has issuer using HTTPS
[ ] Issuer supports RFC 8414 discovery (/.well-known/oauth-authorization-server)
[ ] Test the full authorization flow

Validate Your Profile

You can run all of these checks at ucptools.dev - paste your profile JSON or enter your domain. It's free, no signup required.

For CI integration, the npm package gives you the same validation with JSON output:

npm install -g ucptools
ucptools validate https://your-store.com

UCPtools is an independent community tool. UCP is an open standard developed by Google, Shopify, and partners. Cart and Catalog spec status as of March 25, 2026.

Have questions about validating the new capabilities? Drop a comment - I'm building this in public and happy to help.

Automating Airtable with AI Assistants Using MCP

Peter — Fri, 20 Mar 2026 17:45:42 +0000

TL;DR: I built an MCP wrapper for Airtable so AI assistants can
work with your bases using tools instead of brittle prompt-only hacks.
If you want Claude, ChatGPT, or another MCP-compatible client to read
records, search data, create rows, and update workflows in Airtable,
this is a practical way to do it.

Airtable MCP Server on Apify Store:
https://apify.com/minute_contest/airtable-mcp-server

Airtable already sits in the middle of a lot of workflows: CRM, content
pipelines, ops tracking, lightweight internal tools, and project
coordination.

The missing piece is often this:

You want an AI assistant to work with Airtable as a system of record,
not just talk about it.

That sounds straightforward until you try it.

Most AI assistant setups hit one of these problems:

they can summarize pasted Airtable data, but cannot act on live records
they rely on custom scripts and one-off API glue
they break when you need both read and write operations
they are hard to reuse across clients like Claude Desktop, ChatGPT tools, or other MCP-compatible runtimes

I built Airtable MCP Server to solve that gap.

It is an MIT-licensed MCP server packaged for Apify, with
15 Airtable tools for reading, writing, searching, and managing
bases. It supports:

Standby mode for a persistent MCP server
Batch mode for one-off jobs or scripted runs

If you are exploring AI-agent-ready tools, this is the pattern I think
is worth using for Airtable.

The problem: AI assistants need tools, not pasted spreadsheets

A lot of Airtable + AI examples still look like this:

export records
paste them into a chat
ask the model to analyze them
manually copy results back into Airtable

That works for demos, but not for workflows.

In practice, teams want things like:

"Look up all leads that have not been contacted in 14 days and draft follow-up actions"
"Find support tickets tagged billing, summarize themes, and create a triage table"
"When I describe a new project in chat, create the corresponding Airtable records"
"Search my content calendar and tell me what is blocked, then update statuses"

Those are not just reasoning tasks. They are reasoning plus data access
plus mutation.

This is where MCP helps.

With MCP, the AI assistant gets a structured set of tools. Instead of
hallucinating around your data model, it can call explicit operations
against Airtable.

What this actor does

The Apify actor wraps an Airtable MCP server and exposes Airtable
operations through the Model Context Protocol.

Apify Store link:
https://apify.com/minute_contest/airtable-mcp-server

At a high level, it gives an AI assistant the ability to:

inspect Airtable bases and tables
read records
search and filter records
create new records
update existing records
manage Airtable-backed workflows from an MCP client

I packaged it on Apify because I wanted:

hosted execution
repeatable runs
a straightforward way to use persistent or one-shot server modes
a cleaner path for developers who do not want to self-host everything from scratch

Two modes

1. Standby mode

Use this when you want a persistent MCP server that your assistant can
connect to and keep using over time.

Good for:

Claude Desktop-style workflows
long-running agent sessions
internal assistant setups

2. Batch mode

Use this when you want to run a single task or automation step and exit.

Good for:

scheduled jobs
testing
pipeline steps
one-off automations

Real use cases

Here are a few practical workflows where this pattern makes sense.

1. AI-assisted CRM cleanup in Airtable

A common Airtable setup is a lead table with fields like:

Name
Company
Last Contacted
Status
Notes
Next Action

An AI assistant can:

search for stale leads
summarize the latest notes
propose next actions
update the relevant records

Example prompt to an MCP-enabled assistant:

Find all leads in the CRM table where Status is "Active" and
Last Contacted is older than 14 days. Summarize the notes for each and
update Next Action with a short follow-up recommendation.

Without MCP, this is a manual export-and-paste process.
With MCP, the assistant can query the data and write the result back.

2. Content pipeline management

Airtable is often used as a content calendar. Typical fields:

Topic
Owner
Status
Publish Date
Draft URL
Notes

An AI assistant can help with:

finding blocked content items
grouping them by issue
updating statuses
creating missing records from a planning session

Example prompt:

Review all content records with Status set to "Blocked". Group the
blockers into themes and update Notes with a short recommended next
step for each record.

This works well when Airtable is the operational layer and the assistant
is the reasoning layer.

3. Support triage and internal ops

If you log support requests or internal operations issues in Airtable,
an assistant can:

search for open high-priority items
identify duplicates
create triage summaries
update assignments or status fields

Example:

Look at open tickets from the last 7 days with category "Billing".
Summarize repeated issues and create a new record in the weekly-review
table with the summary.

That kind of cross-table workflow is where tool-based assistants start
to become useful instead of just interesting.

4. Lightweight internal tools without building a full app

Airtable often becomes the backend for internal workflows before anyone
builds a dedicated UI.

An MCP-enabled assistant can act as the interaction layer:

"Create a new vendor onboarding record"
"Find all overdue approvals"
"Update procurement status to waiting on legal"
"Show me which launches are missing assets"

This is not a replacement for your product UI. It is a practical
interface for operations work that already lives in Airtable.

How I think about the setup

The architecture is simple:

Airtable remains the source of truth
The MCP server exposes Airtable operations as tools
Your AI assistant uses those tools to read and modify data
Apify hosts the MCP wrapper so you do not have to wire everything manually

Diagram you can add as a screenshot

A simple diagram with four boxes:

AI Assistant (Claude, ChatGPT, custom agent)
MCP Client
Airtable MCP Server on Apify
Airtable API / Bases

Arrows:

assistant calls MCP tools
MCP server translates requests
Airtable returns records
assistant reasons over results and optionally writes updates back

Example workflow: stale CRM lead follow-up

Here is a concrete pattern.

Step 1: define the business rule

We want to find all active leads where:

Last Contacted < today - 14 days
Status = Active

Then:

summarize notes
write a recommended next action
optionally create a task elsewhere

Step 2: run the MCP server

From Apify, configure the Airtable MCP Server with your Airtable
credentials and choose the mode you want.

For a persistent assistant setup, use Standby.

Step 3: call it from your MCP client

The exact client setup depends on what you use, but the flow usually
looks like this:

{
  "server": "airtable-mcp-server",
  "mode": "standby",
  "baseId": "appXXXXXXXXXXXXXX"
}

Then your assistant can issue tool calls such as:

{
  "tool": "search_records",
  "arguments": {
    "baseId": "appXXXXXXXXXXXXXX",
    "table": "Leads",
    "filter": {
      "Status": "Active"
    }
  }
}

And later:

{
  "tool": "update_record",
  "arguments": {
    "baseId": "appXXXXXXXXXXXXXX",
    "table": "Leads",
    "recordId": "recXXXXXXXXXXXXXX",
    "fields": {
      "Next Action": "Send follow-up email focused on pricing questions"
    }
  }
}

The exact tool names and payload shape depend on your MCP client and
server configuration, but this is the practical pattern:
search, reason, update.

Example: using the actor in an automation script

If you want to trigger the Apify actor programmatically, here is a
Node.js example using the Apify API client.

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({
  token: process.env.APIFY_TOKEN,
});

const input = {
  mode: 'batch',
  // Add your Airtable auth and server-specific config here.
  // For example:
  // airtableToken: process.env.AIRTABLE_TOKEN,
  // baseId: 'appXXXXXXXXXXXXXX',
};

const run = await client
  .actor('minute_contest/airtable-mcp-server')
  .call(input);

console.log('Run finished:', run.id);
console.log('Dataset:', run.defaultDatasetId);

And a simple Python version:

from apify_client import ApifyClient
import os

client = ApifyClient(os.environ["APIFY_TOKEN"])

input_data = {
    "mode": "batch",
    # Add Airtable auth and config here.
}

run = client.actor(
    "minute_contest/airtable-mcp-server"
).call(run_input=input_data)

print("Run finished:", run["id"])
print("Dataset:", run.get("defaultDatasetId"))

Screenshot idea

Add a screenshot of the Apify actor input screen showing:

mode selection
Airtable token field
base/table configuration
run button

Why MCP is a better fit than ad hoc Airtable AI glue

What I learned building this is that Airtable + AI gets messy fast if
every workflow is custom.

You can absolutely call the Airtable API directly. I have done that too.
But once you want assistants to interact with Airtable across multiple
workflows, MCP gives you a cleaner interface.

Benefits:

one tool layer instead of scattered scripts
reusable across multiple assistant clients
better fit for agent workflows
less prompt-only guessing about your data

It also helps separate concerns:

Airtable handles storage and structure
the assistant handles reasoning
MCP handles tool access

That separation is useful.

Honest limitations

This is not magic, and there are a few things worth saying plainly.

1. Your Airtable schema still matters

If your fields are inconsistent or overloaded, the assistant will
struggle just like a human would.

2. Permissions need attention

If you let an assistant write to production tables, think through scope
and guardrails.

3. Not every workflow should be agent-driven

If you just need one deterministic update, a direct script may be
simpler.

4. MCP adoption is still early

Interest is rising, but the ecosystem is still settling. Different
clients support MCP in slightly different ways, so you should expect
some setup work.

That said, if you already think in terms of AI assistants with tools,
Airtable is a good candidate for this model.

When I would use this

I would reach for Airtable MCP Server when:

Airtable is already central to the workflow
I want an assistant to both read and write records
I need something reusable across AI clients
I do not want to maintain custom Airtable glue for every use case

I would probably not use it when:

the task is a single fixed API call
there is no need for assistant reasoning
the workflow is too sensitive to allow AI-triggered writes

Getting started

If you want to try it, start with one contained workflow:

stale lead follow-up
blocked content triage
weekly support summary
record creation from chat notes

That gives you a clean way to validate whether AI + Airtable tool access
is useful in your setup.

You can find the actor here:

Apify Store link:
https://apify.com/minute_contest/airtable-mcp-server

Conclusion

I built Airtable MCP Server because I wanted Airtable to be usable
by AI assistants as an actual tool layer, not just as exported context
pasted into a prompt.

If your team keeps operational data in Airtable and you are
experimenting with agent workflows, this is a practical starting point.
It gives you hosted MCP access to Airtable with read/write/search
capabilities, plus both persistent and one-shot execution modes.

If you test it and hit rough edges, that is useful feedback too. This
category is still early, and practical usage patterns matter more than
hype.

Apify Store link:
https://apify.com/minute_contest/airtable-mcp-server

I Built a Validator for a Protocol That Didn't Exist 8 Weeks Ago

Peter — Thu, 19 Mar 2026 14:06:00 +0000

In January 2026, Google and Shopify announced the Universal Commerce Protocol (UCP) at NRF - an open standard that lets AI agents like ChatGPT, Gemini, and Copilot discover products, browse catalogs, and complete purchases on e-commerce stores.

Within hours, I knew there'd be a tooling gap. Merchants would need to validate their UCP profiles. Developers would need to test their implementations. And nobody was building it yet.

So I did. Here's what 8 weeks of building on an emerging standard actually looks like.

Week 1: Racing the Spec

The UCP spec was published alongside the announcement. I read the whole thing that weekend. The core concept is elegant: serve a JSON manifest at /.well-known/ucp that tells AI agents what your store can do.

{
  "version": "2026-01-11",
  "capabilities": [
    { "name": "checkout", "version": "1.0" }
  ],
  "payment_handlers": [
    { "type": "stripe" }
  ]
}

The first validator was 200 lines of TypeScript. Parse JSON, check required fields, validate URLs. Ship it.

Lesson learned: Perfect is the enemy of shipped. The first version had exactly one feature: paste JSON, see errors. That was enough.

Week 2: Four Levels of Validation

The simple JSON checker wasn't enough. Merchants had profiles that looked valid but failed in practice - wrong URL formats, HTTP instead of HTTPS, missing signing keys.

I built a 4-level validation pipeline:

Structural - Is the JSON valid? Are required fields present?
Rules - Do namespaces match origins? Are endpoints HTTPS?
Network - Can we actually fetch the referenced schemas?
SDK - Does it pass the official @ucp-js/sdk compliance check?

Each level catches errors the previous one can't. A profile can pass structural validation but fail at the network level because its schema URLs are dead.

Week 3: First Users from Google Search

This surprised me. Within 3 weeks of launching, Google was sending organic traffic for "ucp validator" and "ucp checker."

The lesson: when you build tooling for an emerging standard before anyone else, SEO is almost free. There's no competition for keywords nobody has targeted yet.

Traffic grew from 0 to ~230 sessions/week in the first month. Not viral, but consistent.

Week 4: The Agent Simulator

Validation tells you if your profile is correct. But does your store actually work for AI agents?

I built an agent simulator that tests the full workflow:

Discovery - fetch /.well-known/ucp like a real agent would
Capability inspection - parse capabilities and verify endpoints
Checkout simulation - test the checkout flow end-to-end

This caught a whole category of bugs that static validation missed: endpoints returning HTML instead of JSON, timeouts on product APIs, CORS blocking agent requests.

Week 5-6: The Monetization Experiment

Free tools get traffic. But can they generate revenue?

I added a $9/month monitoring tier:

Weekly auto-validation of your UCP profile
Email alerts when your score drops
Validation history and trend tracking
AI agent traffic analytics

The result so far: 9 trial signups, 0 paid conversions. Users explore the dashboard for 5-10 minutes, find value, and... never come back.

The problem isn't the product - it's the trial experience. Users get full value in one session. There's no reason to return until something breaks. And by then, they've forgotten about us.

I'm currently building better retention hooks: personalized Day 2 emails showing their actual scan results, "next scan" countdowns on the dashboard, and more visible upgrade prompts.

What I'd Do Differently

1. Build the monitoring first, not the validator.

The one-time validator is useful but commoditizable. Three other validators launched within weeks. The monitoring - weekly scans, alerts, history - is the defensible moat.

2. Ship the email sequence on day one.

I launched without trial nurture emails. For 3 weeks, every trial user signed up and... silence. No welcome email, no quick start guide, no reminder. By the time I fixed it, those users were gone.

3. Don't underestimate competitors building on the same trend.

Within 8 weeks, at least 3 other UCP validators appeared: UCPChecker.com (with a browser extension), Nextwaves (40+ test claims), and several WooCommerce plugins. First-mover advantage is real but temporary.

The Numbers (8 Weeks In)

Metric	Value
Weekly sessions	~120
Total trial signups	9
Paid conversions	0
Monthly cost	$5 (Hetzner VPS)
Revenue	$0
Tools built	7 (validator, simulator, generator, security scan, feed analyzer, ACP checker, schema generator)
Platform guides	6 (Shopify, WooCommerce, Magento, BigCommerce, Wix, Squarespace)

Am I profitable? No. Am I building something people use? Yes. The gap between those two is where the real work happens.

What's Next

The agentic commerce space is heating up. Visa launched Intelligent Commerce. Mastercard has Agent Pay. Meta is building shopping into its AI. McKinsey projects $1 trillion in AI-driven commerce by 2030.

UCP is still early. Most e-commerce stores don't have a profile yet. But the ones that do will have a head start when AI agents become the primary shopping interface.

If you want to check where your store stands: ucptools.dev - free, no signup required.

I'm building UCPtools in public. Ask me anything in the comments.

UCPtools is an independent community tool. UCP is an open standard by Google, Shopify, and partners.

How to Make Your WooCommerce Store AI-Ready with UCP (2026 Guide)

Peter — Tue, 17 Mar 2026 14:33:00 +0000

AI agents are shopping for your customers. ChatGPT, Google's Gemini, and Microsoft Copilot can now browse products, compare prices, and complete purchases - if your store speaks their language.

That language is UCP (Universal Commerce Protocol), an open standard by Google, Shopify, and 25+ retailers. And if your WooCommerce store doesn't have it, AI agents will skip you entirely.

Here's how to fix that in under 10 minutes.

What is UCP?

UCP is a JSON manifest served at /.well-known/ucp on your domain. It tells AI agents:

What your store sells
How to browse products
How to complete checkout
Which payment methods you accept

Think of it like robots.txt but for commerce. Without it, AI agents can't interact with your store programmatically.

{
  "version": "2026-01-11",
  "business": {
    "name": "My WooCommerce Store",
    "url": "https://mystore.com"
  },
  "capabilities": [
    {
      "name": "checkout",
      "version": "1.0",
      "schema": "https://ucp.dev/schemas/checkout/1.0"
    }
  ],
  "payment_handlers": [
    {
      "type": "stripe",
      "supported_methods": ["card", "apple_pay", "google_pay"]
    }
  ]
}

Option 1: Use a WooCommerce UCP Plugin (Easiest)

Several plugins now handle UCP for WooCommerce:

Plugin	What It Does	Setup Time
UCP Adapter for WooCommerce	Auto-generates `.well-known/ucp` from your catalog	~5 min
UCPReady by Zologic	Full UCP manifest + monitoring	~10 min
AI Merchant Pro	UCP + product feed optimization	~15 min

After installing, the plugin maps your WooCommerce products, categories, and payment gateways into the UCP manifest format automatically.

Option 2: Manual Implementation (More Control)

If you prefer full control, create the manifest yourself:

Step 1: Create the Manifest File

Create a file at /.well-known/ucp in your WordPress root. You can use a custom rewrite rule or a simple PHP file:

// In your theme's functions.php or a custom plugin
add_action('init', function() {
    add_rewrite_rule(
        '^\.well-known/ucp$',
        'index.php?ucp_manifest=1',
        'top'
    );
});

add_filter('query_vars', function($vars) {
    $vars[] = 'ucp_manifest';
    return $vars;
});

add_action('template_redirect', function() {
    if (get_query_var('ucp_manifest')) {
        header('Content-Type: application/json');
        header('Access-Control-Allow-Origin: *');

        echo json_encode([
            'version' => '2026-01-11',
            'business' => [
                'name' => get_bloginfo('name'),
                'url' => home_url(),
            ],
            'capabilities' => [
                [
                    'name' => 'checkout',
                    'version' => '1.0',
                    'schema' => 'https://ucp.dev/schemas/checkout/1.0',
                    'endpoint' => home_url('/wp-json/wc/v3/checkout'),
                ]
            ],
            'services' => [
                [
                    'name' => 'product_discovery',
                    'version' => '1.0',
                    'schema' => 'https://ucp.dev/schemas/discovery/1.0',
                    'endpoint' => home_url('/wp-json/wc/v3/products'),
                ]
            ],
        ], JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES);
        exit;
    }
});

Step 2: Add CORS Headers

AI agents need to fetch your manifest from different origins. Add CORS headers to your .htaccess or nginx config:

# .htaccess
<IfModule mod_headers.c>
    <FilesMatch "\.well-known/ucp">
        Header set Access-Control-Allow-Origin "*"
        Header set Content-Type "application/json"
    </FilesMatch>
</IfModule>

Step 3: Validate Your Implementation

Run your domain through a UCP validator to check for errors:

# Using the free UCPtools validator
curl -s https://ucptools.dev/api/v1/profiles/validate-remote \
  -H "Content-Type: application/json" \
  -d '{"url": "https://yourstore.com"}'

Or use the web validator at ucptools.dev - paste your domain and get an instant A-F grade with actionable fix suggestions.

Step 4: Test with the AI Agent Simulator

Validation confirms your manifest is correct, but does your store actually work for AI agents? The Agent Simulator tests the full workflow:

Discovery - Can agents find your UCP manifest?
Browsing - Can they search and view products?
Checkout - Can they complete a purchase?

This catches issues that static validation misses, like broken API endpoints or timeout errors.

Common WooCommerce UCP Mistakes

From validating hundreds of WooCommerce stores, here are the top errors:

Missing version field - Must be in YYYY-MM-DD format (e.g., 2026-01-11)
HTTP endpoints instead of HTTPS - All UCP endpoints must use HTTPS
No CORS headers - AI agents can't fetch your manifest cross-origin
Trailing slashes on endpoints - /wp-json/wc/v3/products/ should be /wp-json/wc/v3/products
Missing payment_handlers - Even if you only support card payments, declare them

What Happens After Setup

Once your UCP manifest is live:

ChatGPT Shopping can list your products in purchase recommendations
Google AI Mode can include your store in shopping results
Microsoft Copilot can browse and compare your products
Any UCP-compatible AI agent can discover and transact with your store

Monitor Your AI Commerce Readiness

UCP implementation isn't set-and-forget. The spec evolves, your catalog changes, and new AI agents launch constantly.

UCPtools monitoring ($9/mo) scans your store weekly and alerts you if:

Your UCP manifest breaks
Your score drops
New capabilities become available
AI agent traffic patterns change

Try it now: Run your WooCommerce store through the free validator and see your AI Commerce Score in 30 seconds.

UCPtools is an independent community tool. UCP is an open standard by Google, Shopify, and partners.

Generative Engine Optimization (GEO): How to Make Your Store Visible to AI Shopping Agents

Peter — Thu, 12 Mar 2026 14:00:00 +0000

TL;DR

SEO gets you in front of humans. GEO gets you in front of AI agents that buy things.

	SEO	GEO
Optimized for	Search engine crawlers	AI shopping agents
Goal	Rank in SERPs	Get discovered, selected, and purchased through
Outcome	Human clicks through to your site	AI agent completes a purchase on your store
Key signals	Keywords, backlinks, page speed	Structured data depth, protocol compliance, API reliability
Metrics	Rankings, CTR, organic traffic	Agent discovery rate, browse rate, checkout rate, AI-attributed revenue
Timeline	Weeks to months	Data improvements: 2-4 weeks. Protocol implementation: immediate
Content format	HTML pages for humans	JSON-LD, product feeds, UCP profiles for machines

The shift is already happening. 70% of consumers are using AI assistants for shopping in 2026, and 93% of AI Mode searches result in zero clicks back to merchant websites. The purchase happens inside the AI interface. If your store is not optimized for AI agents, you are invisible to a growing share of commerce.

This article covers what GEO is, how it differs from SEO, the 5 pillars of GEO optimization, and a practical audit checklist you can run today.

What is Generative Engine Optimization?

Generative Engine Optimization (GEO) is the practice of making your online store discoverable and actionable by AI agents. Not just appearing in AI-generated summaries, but being the store that AI agents select when a user says "buy me wireless earbuds under $80."

Traditional SEO answers the question: "How do I rank higher in Google search results so humans click my link?"

GEO answers a different question: "How do I make my store so well-structured, so data-rich, and so reliable that AI agents choose me over competitors when completing a purchase?"

The distinction matters because the transaction flow is fundamentally different. In SEO, you rank in search results, a human clicks through, browses your site, adds items to a cart, and checks out. In GEO, an AI agent discovers your store through a protocol endpoint, reads your product data through structured APIs, creates a checkout session programmatically, submits payment, and completes the order. The human never visits your website. They never see your homepage, your product photos, or your checkout page. They said "buy me earbuds" to an AI assistant, and the assistant handled everything.

This is not theoretical. Google AI Mode launched agentic shopping in early 2026. ChatGPT has shopping capabilities through ACP (Agent Commerce Protocol). Perplexity, Claude, and Copilot are all building commerce integrations. The AI agents are live, they are completing purchases, and the merchants they choose are the ones with the best structured data, the most complete product information, and the most reliable APIs.

As commercetools put it in their 2026 commerce report: "The most valuable commerce capability will be supporting autonomous agent-completed transactions."

GEO is how you build that capability.

SEO vs GEO: Key Differences

How SEO Works

You optimize your pages for search engine crawlers (keywords, meta tags, backlinks, page speed)
Crawlers index your content and rank it in search engine results pages (SERPs)
Humans see your listing, click through to your website
Humans browse your site, add products to cart, and check out

SEO metrics: keyword rankings, click-through rate, organic traffic, bounce rate, pages per session, conversion rate from organic search.

How GEO Works

You optimize your store's structured data, product feeds, and protocol endpoints for AI agents
AI agents discover your store through /.well-known/ucp, product feeds, and Schema.org markup
AI agents evaluate your product data, pricing, availability, and policies
AI agents select your store, create a checkout session, submit payment, and complete the order

GEO metrics: agent discovery rate, browse rate (agents that go past discovery to product browsing), checkout rate, AI-attributed revenue, average order value from agents, error rate, capability match rate.

The Critical Shift

In the SEO model, your website is the destination. Everything you build leads the human to your site, where you control the experience.

In the GEO model, your data is the product. The AI agent never sends the user to your site. It reads your data, makes a decision, and completes the transaction. Your structured data, your product feed completeness, your API response times, and your protocol compliance are what determine whether you get the sale.

This is why 93% of AI Mode searches result in zero clicks. The click is obsolete. The data is what matters.

The 5 Pillars of GEO

Pillar 1: Structured Data Depth

Schema.org Product markup is the foundation of GEO. But not the bare minimum markup that most stores ship today. AI agents need deep, complete markup to make purchase decisions on behalf of users.

Here is the difference between markup that AI agents can work with and markup they cannot.

Bad markup (what most stores have):

{
  "@type": "Product",
  "name": "Earbuds",
  "offers": {"price": "79.99"}
}

An AI agent sees this and knows almost nothing. What brand? What condition? Is it in stock? What is the currency? What is the return policy? Are there images? What does it weigh? The agent cannot confidently recommend this product to a user because it lacks the information needed to make a decision.

Good markup (what AI agents need):

{
  "@type": "Product",
  "name": "Wireless Earbuds Pro",
  "description": "Active noise cancelling wireless earbuds with 24-hour battery life",
  "sku": "WE-PRO-001",
  "brand": {
    "@type": "Brand",
    "name": "AudioTech"
  },
  "offers": {
    "@type": "Offer",
    "price": "79.99",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock",
    "itemCondition": "https://schema.org/NewCondition",
    "seller": {
      "@type": "Organization",
      "name": "AudioTech Store"
    }
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.7",
    "reviewCount": "2341"
  },
  "image": [
    "https://example.com/earbuds-front.jpg",
    "https://example.com/earbuds-side.jpg"
  ],
  "weight": {
    "@type": "QuantitativeValue",
    "value": "5.2",
    "unitCode": "GRM"
  },
  "color": "Midnight Black",
  "material": "ABS Plastic + Silicone",
  "hasMerchantReturnPolicy": {
    "@type": "MerchantReturnPolicy",
    "returnPolicyCategory": "https://schema.org/MerchantReturnFiniteReturnWindow",
    "merchantReturnDays": 30
  }
}

This markup gives the AI agent everything it needs: product identity (SKU, brand), purchase conditions (price, currency, availability, condition), social proof (ratings, review count), physical attributes (weight, color, material), visual confirmation (multiple images), and post-purchase confidence (return policy).

The depth of your structured data directly determines whether AI agents surface your products. An agent choosing between two wireless earbuds at the same price will pick the one with complete data every time, because it can make a more confident recommendation to its user.

What to include in every Product markup:

name, description, sku, brand
offers with price, priceCurrency, availability, itemCondition, seller
aggregateRating with ratingValue and reviewCount
Multiple image URLs (front, side, detail shots)
Physical attributes: weight, color, material, size where applicable
hasMerchantReturnPolicy with return window and conditions
gtin, mpn, or isbn for product identification

Pillar 2: Product Feed Quality

Your product feed is the bulk data source AI agents use to evaluate your entire catalog. Incomplete feeds with missing attributes, inconsistent pricing, broken image URLs, or stale inventory data cause agents to deprioritize your store.

Complete attributes matter. Every product in your feed should have: title, description, price, currency, availability status, condition, brand, category (Google Product Category), image URL, and unique identifier (GTIN/MPN/SKU). Products missing any of these core attributes may be excluded from agent consideration entirely.

Consistent pricing. The price in your feed must match the price on your product page and in your Schema.org markup. AI agents cross-reference these sources. Discrepancies signal unreliability.

Valid images. Every image URL must return a 200 status with an actual image. Broken images (404s, redirects to placeholder images) are a negative signal. AI agents that render product information for users need working visuals.

Accurate inventory. If your feed says "in stock" but the checkout fails because the item is actually out of stock, the agent records a failed transaction. Repeated inventory mismatches cause agents to reduce trust in your store's data.

Pillar 3: Protocol Compliance

Two agentic commerce protocols are live in 2026:

UCP (Universal Commerce Protocol) — developed by Google and Shopify with 25+ partners. Your store publishes a UCP profile at /.well-known/ucp that declares your capabilities, endpoints, and signing keys.
ACP (Agent Commerce Protocol) — developed by OpenAI and Stripe. Provides a merchant listing and checkout flow through Stripe's infrastructure.

Protocol compliance means your store is properly registered, your profile is valid, and your capability declarations are accurate.

For UCP, this means:

GET https://yourstore.com/.well-known/ucp

Returns a valid UCP profile with:

Correct version format (YYYY-MM-DD)
namespace matching your domain origin
Complete capabilities array with valid endpoints
All endpoints using HTTPS (no trailing slashes)
Valid Ed25519 or ES256 signing keys

If your UCP profile is missing, malformed, or declares capabilities you do not actually support, AI agents cannot transact with your store. Protocol compliance is not optional in the GEO model. It is the equivalent of having a working website in the SEO model.

Pillar 4: API Reliability

AI agents deprioritize unreliable merchants. Every interaction between an agent and your store is an API call, and agents track success rates, response times, and error patterns across merchants.

Response times. AI agents are completing transactions in seconds. If your product API takes 3 seconds to respond, the agent may time out or move to a faster competitor. Target under 200ms for product endpoints and under 500ms for checkout operations.

Proper error handling. Return correct HTTP status codes. A 200 OK with an error message in the body confuses agents. A 404 Not Found for a product that exists confuses agents. Use 200 for success, 400 for bad requests, 404 for missing resources, 429 for rate limiting (with Retry-After header), and 500 for server errors.

Consistent availability. Downtime during peak hours means missed transactions. AI agents do not bookmark your store and come back later. They move to the next merchant. 99.9% uptime on UCP endpoints is the target.

Rate limiting awareness. AI agents send bursts of requests during product browsing. If your rate limiter treats agent traffic like bot attacks, you are blocking customers. Whitelist known AI agent User-Agent patterns on your commerce endpoints, or set higher rate limits for these routes.

Pillar 5: Agent-Readable Policies

AI agents need to communicate return policies, shipping information, and privacy policies to users before completing a purchase. If these policies are buried in unstructured HTML pages, agents cannot parse them reliably.

Structured return policies. Use MerchantReturnPolicy schema markup:

{
  "@type": "MerchantReturnPolicy",
  "returnPolicyCategory": "https://schema.org/MerchantReturnFiniteReturnWindow",
  "merchantReturnDays": 30,
  "returnMethod": "https://schema.org/ReturnByMail",
  "returnFees": "https://schema.org/FreeReturn"
}

Structured shipping information. Use OfferShippingDetails to declare shipping rates, delivery times, and geographic coverage:

{
  "@type": "OfferShippingDetails",
  "shippingRate": {
    "@type": "MonetaryAmount",
    "value": "0",
    "currency": "USD"
  },
  "deliveryTime": {
    "@type": "ShippingDeliveryTime",
    "handlingTime": {
      "@type": "QuantitativeValue",
      "minValue": 0,
      "maxValue": 1,
      "unitCode": "DAY"
    },
    "transitTime": {
      "@type": "QuantitativeValue",
      "minValue": 3,
      "maxValue": 5,
      "unitCode": "DAY"
    }
  },
  "shippingDestination": {
    "@type": "DefinedRegion",
    "addressCountry": "US"
  }
}

When an AI agent can read your return policy and shipping details in structured format, it can confidently tell the user "free returns within 30 days, ships in 3-5 business days" before completing the purchase. Without structured policies, the agent either guesses, escalates to the human, or picks a competitor with clearer terms.

Practical GEO Audit Checklist

Here are 10 items to audit on your store today. Each one directly impacts whether AI agents discover, browse, and buy from you.

1. Check Schema Markup Completeness

Run your product pages through the UCPtools Feed Analyzer to see which Schema.org attributes are present and which are missing. Target 100% coverage on the core attributes listed in Pillar 1.

Test it:

curl -s https://yourstore.com/products/your-product | grep -o '"@type":"Product"'

2. Validate Your UCP Profile

Use the UCPtools Validator to check your /.well-known/ucp profile for structural errors, missing fields, namespace mismatches, and endpoint issues.

Test it:

curl -s https://yourstore.com/.well-known/ucp | python -m json.tool

If this returns a 404, you do not have a UCP profile and AI agents using UCP cannot discover you.

3. Test ACP Readiness

If you use Stripe, check whether your store is listed in the ACP merchant directory. ACP powers ChatGPT shopping and is growing rapidly.

4. Audit Product Data Completeness

Export your product feed and check the fill rate for each attribute. Calculate: how many products have brand? SKU? GTIN? Multiple images? Weight? Color? Target 95%+ fill rate on core attributes.

Common gaps:

Missing brand (37% of stores)
Missing gtin or mpn (52% of stores)
Single image instead of multiple (61% of stores)
Missing weight and physical attributes (78% of stores)

5. Verify Checkout Flow with AI Agent Simulation

Use the UCPtools AI Agent Simulator to walk through the full agent interaction flow: discovery, capability inspection, product browsing, and checkout simulation. This catches issues that static validation misses, like endpoints that return 200 but with empty responses, or checkout flows that require human-only interactions.

6. Test Response Times Under Load

AI agents send concurrent requests. Test your UCP endpoints with a load testing tool:

# Test discovery endpoint response time
curl -o /dev/null -s -w "%{time_total}\n" https://yourstore.com/.well-known/ucp

# Test product endpoint response time
curl -o /dev/null -s -w "%{time_total}\n" https://yourstore.com/api/products/1

Target: under 200ms for product endpoints, under 500ms for checkout operations. If you are over these thresholds under load, AI agents may deprioritize your store.

7. Review Structured Return and Shipping Policies

Check whether your return policy and shipping information are available as Schema.org structured data, not just as HTML pages. Search your page source for MerchantReturnPolicy and OfferShippingDetails.

8. Monitor AI Agent Traffic

Check your server logs for AI agent User-Agent strings:

chatgpt, openai, gptbot        -> ChatGPT/OpenAI
gemini, google-extended         -> Google Gemini
perplexitybot                   -> Perplexity
anthropic, claude               -> Claude
copilot                         -> Microsoft Copilot

Also check for requests to /.well-known/ucp — this is the primary discovery endpoint. If you see traffic here, AI agents are already trying to shop on your store.

9. Check Capability Gaps

Review what capabilities AI agents request versus what your store supports. If agents frequently request fulfillment tracking or discount application but your UCP profile does not declare these capabilities, you are losing transactions at the browse stage. UCPtools Analytics tracks these gaps automatically.

10. Compare Against Competitors

Check whether your competitors have UCP profiles:

curl -s https://competitor.com/.well-known/ucp | head -5

If they do and you do not, AI agents are routing commerce to them instead of you. If they do not, you have a first-mover advantage in your category.

Results Timeline

GEO improvements show results on two timescales:

Product data improvements (2-4 weeks). Enriching your Schema.org markup, completing your product feed attributes, and adding structured policies takes effect as AI agents re-index your data. Most agents refresh merchant data every 1-2 weeks, so you should see changes in agent behavior within 2-4 weeks of implementation.

Protocol implementation (immediate). Publishing a valid UCP profile at /.well-known/ucp has an immediate effect. The moment the profile is live and valid, AI agents can discover your store on their next scan. There is no waiting period for protocol compliance. You go from invisible to discoverable the day you deploy.

API reliability improvements (immediate to 1 week). Fixing error responses, improving response times, and adjusting rate limits for AI agents shows results immediately for agents that have already discovered your store. New agents will pick up the improvements on their next visit.

Cumulative effect. GEO is not a one-time optimization. Each improvement compounds. Better structured data leads to more agent discoveries. More discoveries with reliable APIs lead to more checkouts. More successful checkouts build agent trust, which leads to higher selection rates in future transactions.

Tools for GEO

Free Tools

UCPtools Validator — Validate your UCP profile for structural errors, missing fields, namespace mismatches, endpoint issues, and protocol compliance. Supports all four validation levels: structural, rules, network, and SDK validation.

UCPtools Feed Analyzer — Analyze your product feed and Schema.org markup for completeness. Identifies missing attributes, broken images, and data quality issues across your entire catalog.

UCPtools AI Agent Simulator — Simulate the full AI agent interaction flow: discovery, capability inspection, product browsing, and checkout. Tests real-world functionality, not just spec compliance.

Paid Tools

UCPtools Analytics V2 ($9/mo) — Track the complete agentic commerce funnel: discovery, browse, checkout, payment, and order. Agent-by-agent comparison (Gemini, ChatGPT, Perplexity, Claude, Copilot), error analysis with fix suggestions, capability gap analysis, and AI-attributed revenue tracking. Try the interactive demo with sample data.

Conclusion

GEO is the future of e-commerce optimization. Not a replacement for SEO, but a parallel discipline that addresses a fundamentally different commerce channel.

SEO brought your store in front of humans searching on Google. GEO brings your store in front of AI agents shopping on behalf of humans. The mechanics are different. The optimization levers are different. The metrics are different.

Start with the two highest-impact actions:

Structured data depth. Enrich your Schema.org Product markup beyond the bare minimum. Add brand, SKU, availability, ratings, images, weight, color, material, and return policies to every product. This is the single most impactful GEO optimization because it affects every AI agent across every protocol.
Protocol compliance. Publish a valid UCP profile at /.well-known/ucp. This makes your store discoverable by every UCP-compatible AI agent immediately. Use the UCPtools Validator to check your profile before deploying.

The merchants who invest in GEO now will capture the growing wave of AI-mediated commerce. The merchants who wait will wonder why their revenue from "direct" traffic in Google Analytics keeps growing while they cannot explain where it comes from.

The AI agents are already shopping. The question is whether they are shopping on your store.

Resources

UCPtools Validator — validate your UCP profile and product feeds (free)
UCPtools Analytics Demo — explore the agentic commerce dashboard with sample data
UCP Specification — the official Universal Commerce Protocol spec
ACP Specification — the official Agent Commerce Protocol spec
Google UCP Developer Guide — getting started with UCP
Schema.org Product Markup — complete reference for Product structured data

What is your GEO readiness score? Run your store through the UCPtools Validator and share your results in the comments.

Disclaimer: UCP is an open standard by Google and Shopify. ACP is an open standard by OpenAI and Stripe. UCPtools is an independent community tool.

UCP vs ACP in 2026: A Technical Comparison of AI Commerce Protocols

Peter — Thu, 05 Mar 2026 14:05:00 +0000

TL;DR

Two protocols now power AI shopping. Google's UCP (Universal Commerce Protocol) and OpenAI's ACP (Agent Commerce Protocol) take fundamentally different approaches to the same problem: how do AI agents discover, browse, and buy products on behalf of users?

Here is the side-by-side comparison:

Dimension	UCP	ACP
Created by	Google + Shopify	OpenAI + Stripe
Announced	January 2026 (NRF)	February 2026
Architecture	Decentralized (merchant-hosted)	Centralized (platform-controlled)
Discovery	`/.well-known/ucp` JSON on your domain	OpenAI product catalog
Payment processor	Merchant's choice (Google Pay, Stripe, Shop Pay, custom)	Stripe only
Transaction fees	Payment processor fees only	4% OpenAI + ~2.9% Stripe + $0.30
Total cost per $100 sale	~$3.20 (Stripe)	~$7.20 (OpenAI + Stripe)
Profile control	Merchant owns and hosts	Platform controls listing
Protocol compatibility	A2A, AP2, MCP, REST	Standalone (open-sourced)
Signing/auth	Ed25519/ES256 JWK keys	Stripe API keys
Partners	20+ (Etsy, Target, Walmart, Visa, Mastercard, Best Buy)	OpenAI, Stripe, select merchants
Availability	Global	US only (expanding 2026)
Open standard	Yes	Yes (open-sourced)
Implementation time	Hours (host JSON + endpoints)	Days (apply + review process)

If you are a merchant deciding which to support: support both. They target different agent ecosystems, the implementation overlap is significant, and dual-protocol merchants see up to 40% more agentic traffic than single-protocol stores.

Read on for the full technical breakdown.

The Two Protocols

Two weeks apart in early 2026, two announcements reshaped how AI agents will interact with online commerce.

UCP: The Decentralized Standard

Google and Shopify unveiled the Universal Commerce Protocol (UCP) at the National Retail Federation (NRF) conference in January 2026. The protocol defines how AI shopping agents discover merchants, browse product catalogs, create checkout sessions, and complete purchases through structured API interactions.

UCP's core design principle is decentralization. Merchants host their own UCP profile as a JSON file at /.well-known/ucp on their domain. Any AI agent can discover it. No middleman controls who gets listed, no platform takes a cut on top of payment processing, and no review board decides which merchants are allowed.

The launch partner list included over 20 companies: Etsy, Wayfair, Target, Walmart, Best Buy, Visa, Mastercard, American Express, Adyen, and more. Shopify merchants got native UCP support in their dashboards. Google AI Mode and the Gemini App began using UCP for agentic shopping immediately.

ACP: The Platform Approach

OpenAI and Stripe announced the Agent Commerce Protocol (ACP) in February 2026. Where UCP is a decentralized discovery protocol, ACP is a platform-mediated commerce layer. Merchants submit product data to OpenAI, Stripe handles all payments, and ChatGPT surfaces products to users during conversations.

ACP takes a different philosophical approach. Instead of asking merchants to build and host infrastructure, it provides a managed experience: submit your catalog, connect Stripe, and OpenAI handles the rest. The tradeoff is control. OpenAI decides what gets surfaced, Stripe is the only payment option, and the combined fee structure is approximately double what UCP costs.

OpenAI open-sourced the ACP specification, published 8 RFCs extending the core protocol, and announced plans to expand beyond the US in 2026.

Both protocols are open. Both are production-ready. And they solve the same fundamental problem differently enough that understanding the distinctions matters for every merchant entering the agentic commerce space.

Architecture Comparison

This is where the protocols diverge most sharply.

UCP: Decentralized, Merchant-Hosted

UCP follows the same architectural pattern as robots.txt, sitemap.xml, and /.well-known/ URIs. The merchant hosts the protocol artifact on their own domain. Any agent that knows where to look can discover it.

Agent                          Merchant Domain
  |                                  |
  |  GET /.well-known/ucp            |
  |--------------------------------->|
  |                                  |
  |  200 OK (UCP Profile JSON)       |
  |<---------------------------------|
  |                                  |
  |  GET /products                   |
  |--------------------------------->|
  |                                  |
  |  POST /checkout-sessions         |
  |--------------------------------->|

The merchant controls everything: what capabilities are advertised, which services are exposed, what payment methods are accepted, and how the checkout flow works. There is no central registry to apply to. If your profile is valid and your endpoints work, any UCP-compatible agent can transact with your store.

This architecture means:

No gatekeepers. You do not need approval to participate.
No platform fees. You pay only your payment processor.
No vendor lock-in. Switch payment providers without changing your UCP profile structure.
Full data ownership. Agent interactions hit your servers, not a third-party platform.

The downside is that you build and maintain the infrastructure yourself. You host the profile, implement the endpoints, handle validation, manage signing keys, and ensure uptime.

ACP: Centralized, Platform-Mediated

ACP uses a hub-and-spoke model. The merchant submits product data to OpenAI (via feeds or API). OpenAI indexes the catalog, surfaces products during ChatGPT conversations, and Stripe handles payment processing.

User         ChatGPT/Agent         OpenAI Catalog        Merchant
  |               |                      |                   |
  | "Buy X"       |                      |                   |
  |-------------->|                      |                   |
  |               |  Search products     |                   |
  |               |--------------------->|                   |
  |               |                      |                   |
  |               |  Results             |                   |
  |               |<---------------------|                   |
  |               |                      |                   |
  | Show options  |                      |                   |
  |<--------------|                      |                   |
  |               |                      |                   |
  | "Buy this"    |                      |                   |
  |-------------->|  Initiate checkout   |                   |
  |               |--------------------------------------------->|
  |               |                      |    Stripe payment |
  |               |                      |<------------------|

The platform controls discovery. OpenAI decides how products are ranked, which merchants appear for which queries, and what the user experience looks like. The merchant's job is to submit accurate product data and have a working Stripe integration.

This architecture means:

Lower implementation effort. Submit data, connect Stripe, done.
Built-in distribution. ChatGPT's user base is your discovery channel.
Managed experience. OpenAI handles the agent-side UX.

The tradeoffs:

Platform dependency. If OpenAI changes ranking algorithms, your visibility changes.
Stripe-only payments. No Google Pay, Shop Pay, or custom payment handlers.
Higher fees. 4% OpenAI fee on top of Stripe processing.
Limited control. You do not control how your products are presented to users.

Neither architecture is inherently better. They optimize for different priorities: UCP for control and interoperability, ACP for simplicity and built-in distribution.

Discovery Flow

How an AI agent finds your store is the first — and arguably most important — difference.

UCP Discovery

UCP discovery works like DNS for commerce. The agent fetches a well-known URI on the merchant's domain:

GET https://example.com/.well-known/ucp

The response is a JSON profile that describes everything the agent needs to know: what the store sells, what capabilities it supports, how to interact with its APIs, and how to verify its identity.

{
  "ucp": {
    "version": "2026-01-11",
    "merchant": {
      "name": "Example Store",
      "domain": "example.com",
      "description": "An AI-ready online store"
    },
    "capabilities": [
      {
        "name": "dev.ucp.shopping.checkout",
        "version": "2026-01-11",
        "spec": "https://ucp.dev/specs/shopping/checkout"
      }
    ],
    "services": {
      "checkout": {
        "version": "2026-01-11",
        "rest": {
          "endpoint": "https://example.com/api/ucp/checkout",
          "schema": "https://ucp.dev/schemas/checkout/v1"
        }
      }
    }
  }
}

The agent parses this profile, understands what the store can do, and then decides how to interact. The discovery is deterministic: if the profile is at the well-known URI and it is valid, the agent will find it.

Key discovery properties:

Version format: YYYY-MM-DD (e.g., 2026-01-11)
Namespace governance: Capability names must match the origin domain authority
Signing keys: Ed25519 or ES256 JWK keys for profile authentication
Extension chains: Capabilities can extend other capabilities, enabling composable functionality
Multiple transports: REST, MCP (Model Context Protocol), A2A (Agent-to-Agent), or embedded

ACP Discovery

ACP discovery is catalog-based. The merchant submits product data to OpenAI through feeds or API calls. OpenAI indexes this data and makes it searchable within ChatGPT and other OpenAI-powered agents.

{
  "products": [
    {
      "id": "prod_abc123",
      "name": "Wireless Earbuds Pro",
      "description": "Noise-cancelling wireless earbuds with 24h battery",
      "price": {
        "amount": 7999,
        "currency": "usd"
      },
      "images": ["https://example.com/images/earbuds-pro.jpg"],
      "url": "https://example.com/products/earbuds-pro",
      "category": "Electronics > Audio > Headphones",
      "availability": "in_stock",
      "shipping": {
        "free_shipping": true,
        "estimated_days": 3
      }
    }
  ],
  "merchant": {
    "name": "Example Store",
    "stripe_account_id": "acct_xxx",
    "return_policy_url": "https://example.com/returns"
  }
}

There is no well-known URI. There is no file on your domain that agents fetch directly. Instead, ChatGPT queries the OpenAI catalog when a user asks about products, and the platform decides which merchants and products to surface.

The merchant goes through an application and review process. OpenAI verifies the business, checks product data quality, and then activates the merchant in the catalog. This means there is a human (or automated) gating step before your products are discoverable.

The Practical Difference

With UCP, an AI agent from any vendor — Google Gemini, Perplexity, Claude, a custom enterprise agent — can discover your store by fetching a single URL. You do not need to register with each agent platform individually.

With ACP, discovery is currently limited to OpenAI's ecosystem. ChatGPT and OpenAI-powered agents can find your products. Agents from other vendors cannot query the OpenAI catalog (though the open-sourced spec could change this over time).

If you want to be discoverable by the broadest range of AI agents, UCP's decentralized model has a structural advantage. If you want to reach ChatGPT's user base specifically, ACP provides a direct path.

Checkout and Payment

This is where the fee structures diverge and the business implications become concrete.

UCP Checkout

UCP profiles declare one or more payment handlers. The merchant chooses which payment methods to support:

{
  "services": {
    "checkout": {
      "version": "2026-01-11",
      "rest": {
        "endpoint": "https://example.com/api/ucp/checkout",
        "schema": "https://ucp.dev/schemas/checkout/v1"
      },
      "payment_handlers": [
        {
          "type": "google_pay",
          "handler": "https://example.com/api/payments/google-pay"
        },
        {
          "type": "shop_pay",
          "handler": "https://example.com/api/payments/shop-pay"
        },
        {
          "type": "stripe",
          "handler": "https://example.com/api/payments/stripe"
        }
      ]
    }
  }
}

The checkout flow:

Agent creates a checkout session via POST /checkout-sessions
Agent adds line items, shipping address, preferences
Agent submits payment through the merchant's declared payment handler
Merchant processes payment using their chosen provider
Agent receives confirmation with order ID

Fees: Only your payment processor's standard fees. If you use Stripe, that is 2.9% + $0.30 per transaction in the US. If you use Adyen, it might be lower. If you negotiate volume rates, those apply. There is no protocol-level fee.

On a $100 sale: ~$3.20 total (Stripe standard).

ACP Checkout

ACP routes all payments through Stripe. The checkout flow is delegated: the agent initiates the transaction, Stripe processes the payment, and OpenAI takes a 4% platform fee.

The checkout flow:

User confirms purchase intent in ChatGPT
ChatGPT creates a Stripe Checkout Session via ACP
User completes payment (Stripe handles the payment UI)
Stripe processes the charge and distributes funds
OpenAI retains 4% as a platform fee

Fees:

4.0% OpenAI platform fee
2.9% + $0.30 Stripe processing fee

On a $100 sale: ~$7.20 total ($4.00 OpenAI + $3.20 Stripe).

Fee Comparison at Scale

Monthly GMV	UCP Cost (Stripe only)	ACP Cost (OpenAI + Stripe)	Difference
$10,000	$320	$720	$400/mo
$50,000	$1,600	$3,600	$2,000/mo
$100,000	$3,200	$7,200	$4,000/mo
$500,000	$16,000	$36,000	$20,000/mo
$1,000,000	$32,000	$72,000	$40,000/mo

At $1M monthly GMV through agentic channels, the fee difference is $40,000 per month. That is material. Even at $50K/month, the extra $2,000 adds up to $24,000 per year.

Whether the ACP premium is worth it depends on the volume of transactions ChatGPT drives to your store. If ChatGPT sends you $50K/month in sales you would not otherwise get, the $2,000/month cost is a reasonable customer acquisition cost. If you would have gotten those sales anyway through UCP-compatible agents, it is an unnecessary expense.

Implementation

Here is what it takes to get each protocol running.

Implementing UCP

UCP requires three things: a valid JSON profile, working API endpoints, and proper authentication.

Step 1: Create your UCP profile

{
  "ucp": {
    "version": "2026-01-11",
    "merchant": {
      "name": "Example Store",
      "domain": "example.com",
      "description": "An AI-ready online store",
      "logo": "https://example.com/logo.png",
      "support_email": "support@example.com"
    },
    "capabilities": [
      {
        "name": "dev.ucp.shopping.checkout",
        "version": "2026-01-11",
        "spec": "https://ucp.dev/specs/shopping/checkout"
      },
      {
        "name": "dev.ucp.shopping.product_catalog",
        "version": "2026-01-11",
        "spec": "https://ucp.dev/specs/shopping/product_catalog"
      }
    ],
    "services": {
      "checkout": {
        "version": "2026-01-11",
        "rest": {
          "endpoint": "https://example.com/api/ucp/checkout",
          "schema": "https://ucp.dev/schemas/checkout/v1"
        }
      },
      "product_catalog": {
        "version": "2026-01-11",
        "rest": {
          "endpoint": "https://example.com/api/ucp/products",
          "schema": "https://ucp.dev/schemas/products/v1"
        }
      }
    },
    "signing_keys": [
      {
        "kty": "OKP",
        "crv": "Ed25519",
        "x": "...",
        "kid": "key-2026-01"
      }
    ]
  }
}

Step 2: Host the profile

Serve this JSON at https://yourdomain.com/.well-known/ucp with Content-Type: application/json. On most web servers, this is a static file in a .well-known directory. On Shopify, it is generated automatically. On Vercel or Netlify, you add a rewrite rule.

Step 3: Implement API endpoints

Your profile declares endpoints. Those endpoints need to actually work. At minimum, a checkout-capable store needs:

GET /products — Return product catalog
GET /products/:id — Return single product
POST /checkout-sessions — Create a checkout session
PUT /checkout-sessions/:id — Update session (add items, set shipping)
POST /checkout-sessions/:id/complete — Process payment and complete order
GET /orders/:id — Return order status

Step 4: Validate

npx @ucptools/validator validate -r yourdomain.com

This runs structural, compliance, and network validation against your live profile. Fix any errors, re-validate, and you are live.

Timeline: If you have an existing e-commerce backend with product and checkout APIs, adding UCP can take a few hours. Shopify merchants can deploy in under 48 hours using the native integration.

Implementing ACP

ACP requires a Stripe account, product data submission, and going through OpenAI's merchant application.

Step 1: Connect Stripe

If you already use Stripe, you connect your existing account. If not, you create one and integrate it with your store.

Step 2: Submit product data

Provide your product catalog to OpenAI through their merchant portal or API. This includes product names, descriptions, prices, images, categories, availability, and shipping information.

Step 3: Apply and wait

Submit your merchant application through OpenAI's portal. OpenAI reviews your business, verifies product data quality, and activates your listing in the catalog. The timeline varies — some merchants report days, others weeks.

Step 4: Monitor

Once live, track performance through OpenAI's merchant dashboard. Monitor which products are being surfaced, conversion rates, and revenue.

Timeline: The Stripe integration and product feed setup can be done in a day if you have clean product data. The review process adds an unpredictable delay.

Implementation Effort Comparison

Task	UCP	ACP
Profile/data setup	2-4 hours	1-2 hours
Endpoint implementation	4-8 hours (if APIs exist)	N/A (Stripe handles it)
Authentication setup	1-2 hours (signing keys)	30 min (Stripe keys)
Deployment	1 hour	Submit and wait
Validation/testing	1-2 hours	Limited pre-launch testing
Total (existing backend)	8-16 hours	2-4 hours + review wait
Total (from scratch)	2-5 days	1-2 days + review wait

ACP is faster to implement because the platform handles more. UCP requires more upfront work but gives you more control over the long term.

Protocol Compatibility

UCP: The Interoperability Play

UCP was designed to work alongside other AI agent protocols, not replace them. A UCP profile can declare multiple service transports:

REST — Standard HTTP API endpoints
MCP (Model Context Protocol) — Anthropic's protocol for tool use by LLMs
A2A (Agent-to-Agent) — Google's protocol for inter-agent communication
AP2 — Agent Platform Protocol for platform-level integration
Embedded — For agents running within the merchant's own environment

A single UCP profile can expose all of these simultaneously:

{
  "services": {
    "checkout": {
      "version": "2026-01-11",
      "rest": {
        "endpoint": "https://example.com/api/ucp/checkout",
        "schema": "https://ucp.dev/schemas/checkout/v1"
      },
      "mcp": {
        "endpoint": "https://example.com/mcp/checkout",
        "tools": ["create_checkout", "add_item", "complete_purchase"]
      },
      "a2a": {
        "endpoint": "https://example.com/a2a/checkout",
        "agent_card": "https://example.com/.well-known/agent.json"
      }
    }
  }
}

This means a Google Gemini agent can discover your store via /.well-known/ucp and interact through A2A. A Claude-based agent can use MCP tools. A custom enterprise agent can use REST. Same store, same profile, multiple agent architectures.

ACP: Standalone but Open

ACP is a standalone protocol. It does not integrate with MCP, A2A, or other agent communication standards. However, OpenAI open-sourced the specification and published 8 RFCs that extend the core protocol. These RFCs cover:

Capability negotiation between agent and merchant
Delegated payment flows
Product feed specifications
Merchant verification
Refund and return handling

The open-sourcing means other agent platforms could adopt ACP in the future. But today, ACP is primarily an OpenAI/ChatGPT protocol. Other agent vendors have not announced ACP support.

What This Means for Merchants

If you implement UCP with REST endpoints, you can later add MCP and A2A transports to the same profile without changing your core infrastructure. You write the business logic once and expose it through multiple protocols.

If you implement ACP, you get access to ChatGPT's ecosystem. But if you want to support Gemini, Claude, Perplexity, or custom agents, you still need UCP (or direct integrations with each platform).

Ecosystem and Partners

UCP Partners (20+)

The UCP launch coalition is broad and includes major players across retail, payments, and technology:

Retailers: Etsy, Wayfair, Target, Walmart, Best Buy
Payments: Visa, Mastercard, American Express, Adyen
Platforms: Shopify (native integration), Google Merchant Center
Technology: Multiple e-commerce platforms announcing UCP support

Shopify's native integration is particularly significant. Shopify powers millions of merchants, and built-in UCP support means those merchants can go live without writing code. The Shopify app generates the UCP profile, handles endpoint routing, and manages the checkout flow.

ACP Partners

ACP's ecosystem is currently smaller but includes:

Platform: OpenAI (ChatGPT distribution)
Payments: Stripe (exclusive payment processor)
Early merchants: Etsy (notably supporting both protocols), select Shopify merchants

The smaller partner list is partly because ACP launched a month after UCP. The ecosystem will grow as the review process scales. But structurally, ACP will always have a more curated partner list because the platform controls merchant admission.

Notable: Etsy Supports Both

Etsy is in both the UCP and ACP partner lists. This is not a coincidence. Etsy is betting that both protocols will drive meaningful commerce and that supporting both maximizes their discoverability across all agent ecosystems. This is the dual-protocol strategy in action.

The Third Player: Microsoft Copilot Checkout

It is worth noting that Microsoft announced Copilot Checkout in early 2026 as well. While not as thoroughly documented as UCP or ACP at this stage, Microsoft is integrating shopping capabilities directly into Copilot and Bing, with its own merchant onboarding process.

Microsoft's approach leans closer to ACP's platform-mediated model: merchants connect through Microsoft Merchant Center, and Copilot handles product discovery and purchase flows within its ecosystem.

For merchants, this means the agentic commerce landscape is not a two-horse race. It is at least three platforms, with UCP being the only protocol that works across all of them (since any agent can fetch a /.well-known/ucp profile regardless of which company built it).

Dual Protocol Strategy

Supporting both UCP and ACP is not twice the work. The overlap is significant.

Why Support Both

Different agent ecosystems. UCP is the default for Google AI Mode, Gemini, and the growing ecosystem of independent agents. ACP is the path to ChatGPT's user base. Missing either means missing a portion of agentic traffic.
Measurable impact. Early data from merchants supporting both protocols shows up to 40% more agentic traffic compared to single-protocol stores. The audiences are largely additive — users who shop through ChatGPT are often different from those using Google AI Mode.
Shared infrastructure. Both protocols need the same underlying components: product catalog API, checkout flow, order management, payment processing. The protocol-specific layer is thin compared to the commerce infrastructure underneath.

Three-Step Implementation Guide

Step 1: Build the Commerce Layer (shared)

If you already have e-commerce APIs for products, checkout, and orders, this step is done. If not, build them once and expose them through both protocols.

Your E-Commerce Backend
├── Product Catalog API
├── Checkout Session API
├── Order Management API
└── Payment Processing
    ├── Stripe (works for both UCP + ACP)
    ├── Google Pay (UCP only)
    └── Shop Pay (UCP only)

Step 2: Add UCP (your domain)

Generate a UCP profile (use UCPtools or build manually)
Host at /.well-known/ucp
Map UCP service endpoints to your commerce APIs
Add Ed25519 signing keys
Validate with npx @ucptools/validator validate -r yourdomain.com

Step 3: Add ACP (Stripe + OpenAI)

Connect Stripe account (you likely already have one from UCP payment setup)
Export product catalog in ACP feed format
Submit through OpenAI merchant portal
Wait for review and activation

Total incremental effort for adding ACP after UCP: roughly 2-4 hours of setup plus the review wait. Total incremental effort for adding UCP after ACP: roughly 8-16 hours, most of which is hosting and validating the profile.

Validation and Monitoring

Once you have deployed one or both protocols, you need to verify they work and track their performance.

Validating UCP Profiles

The UCPtools Validator runs four levels of validation against your live UCP profile:

# Full remote validation
npx @ucptools/validator validate -r yourdomain.com

# Quick structural check
npx @ucptools/validator validate-quick profile.json

# Simulate agent interaction
npx @ucptools/validator simulate -r yourdomain.com

The validator checks:

Structural validity — JSON structure, required fields, version format
UCP compliance — Namespace/origin binding, extension chains, HTTPS endpoints, signing keys
Network verification — Remote schema fetching, endpoint reachability
Agent simulation — Runs a full discovery-browse-checkout flow like a real AI agent would

Common validation errors and what they mean:

Error Code	What It Means
`UCP_MISSING_ROOT`	No `ucp` root object in profile
`UCP_INVALID_VERSION_FORMAT`	Version is not YYYY-MM-DD format
`UCP_NS_ORIGIN_MISMATCH`	Capability namespace does not match your domain
`UCP_ENDPOINT_NOT_HTTPS`	Endpoint uses HTTP instead of HTTPS
`UCP_ENDPOINT_TRAILING_SLASH`	Endpoint URL has a trailing slash
`UCP_MISSING_SIGNING_KEYS`	No Ed25519/ES256 keys in profile

Checking ACP Readiness

ACP validation is more limited since the platform controls the profile. Your checklist:

Stripe account active — Verify your Stripe account is in good standing with payouts enabled
Product data quality — Check that all submitted products have complete titles, descriptions, images, accurate pricing, and correct availability
Checkout flow tested — Run test transactions through your Stripe integration
Merchant portal status — Check your application status in the OpenAI merchant dashboard

Monitoring AI Agent Traffic

Traditional analytics tools like GA4 cannot see AI agent interactions — there is no browser, no JavaScript execution, no cookies. You need purpose-built analytics for agentic commerce.

UCPtools Analytics V2 tracks the full agentic commerce funnel:

Discovery events — Which agents found your /.well-known/ucp profile
Browse events — What products agents queried
Checkout events — Sessions created, items added
Payment events — Payment submissions and outcomes
Order events — Completed purchases and revenue

Key metrics to watch:

Agent conversion rate — What percentage of agent discoveries result in purchases
Revenue by agent — Which AI agents drive the most revenue (Gemini vs. ChatGPT vs. Claude vs. Perplexity)
Protocol split — What percentage of agentic traffic comes through UCP vs. ACP
Error rate — Where agents fail and why (missing capabilities, endpoint errors, payment failures)

This data tells you whether your protocol implementations are working and where to invest optimization effort.

Conclusion

The UCP vs. ACP comparison is not really about which protocol is "better." They make different architectural tradeoffs for different use cases.

Choose UCP if you value:

Control over your commerce experience
Interoperability with multiple AI agent platforms
Lower transaction fees
No platform dependency or gating

Choose ACP if you value:

Faster implementation with less infrastructure
Direct access to ChatGPT's user base
Managed experience with less operational overhead

Choose both if you value revenue. The protocols are complementary, the implementation overlap is significant, and the agentic commerce market is growing fast enough that limiting yourself to one agent ecosystem is leaving money on the table.

The protocol war benefits merchants. Both Google and OpenAI are competing to make their protocol easier to adopt, more feature-rich, and more widely supported. Both protocols are open. And the shared infrastructure underneath — product APIs, checkout flows, payment processing — means that supporting both is incrementally less work than building either from scratch.

The AI agents are already shopping. The question is whether they can find your store.

Get started: Validate your UCP profile | Generate a UCP profile | Monitor agent traffic

Disclaimer: UCP is an open standard by Google and Shopify. ACP is an open standard by OpenAI and Stripe. UCPtools is an independent community tool -- not affiliated with Google, Shopify, OpenAI, or Stripe.

Zero-Click Retail Is Here: What Every E-Commerce Merchant Needs to Know in 2026

Peter — Thu, 26 Feb 2026 14:00:00 +0000

TL;DR

AI agents are buying products on behalf of users without ever loading your website. Google AI Mode, ChatGPT, Perplexity, and Copilot are completing full purchase flows through API calls. No browser. No clicks. No page views.

Here is how fast the shift is happening:

Metric	What it means
93% of AI Mode searches end without a click	Users get answers — and now purchases — without visiting your site (Amsive, 2026)
Organic CTR down 61% from AI Overviews	Google is answering queries directly, collapsing the click-through funnel (Position Digital, 2026)
70% of consumers using AI for shopping	Not a niche — the mainstream is already there (DataDome, 2025-2026)
4x increase in AI bot traffic since Jan 2025	AI agents are crawling and transacting at scale (DataDome)
1M+ Shopify merchants coming to UCP	The protocol is not theoretical — it is rolling out across the largest e-commerce platform on earth (Shopify)

If you are an e-commerce merchant, this article explains what is happening, how AI shopping actually works at a technical level, which protocols matter, and the five things you should do right now.

The Zero-Click Shift

For twenty years, e-commerce has followed a simple model: drive traffic to your website, convert visitors into buyers. SEO, paid ads, social media, email marketing — every channel is designed to generate clicks that land on your storefront. Your analytics stack measures those clicks. Your conversion funnel starts with a page view.

That model is breaking.

In February 2026, Amsive published research showing that 93% of queries in Google's AI Mode result in zero clicks. The user asks a question, the AI answers it, and no one visits the source website. This is not limited to informational queries. Google AI Mode now supports agentic shopping — the AI browses products, compares options, and completes purchases directly inside the AI interface.

Position Digital found that organic click-through rates have dropped 61% on queries where AI Overviews appear. When Google provides the answer (or the product) inline, there is no reason for the user to click through. The click itself is becoming optional.

This is not a temporary dip. It is structural.

Google announced in February 2026 that AI Mode shopping now includes merchants from Etsy and Wayfair, with shoppable product results appearing directly in AI conversations. Users can browse catalogs, compare prices, read reviews, and complete checkout — all without leaving the AI interface.

Meanwhile, 70% of consumers report using AI tools for shopping tasks according to DataDome research. Not "considering" or "experimenting with" — actively using. And AI bot traffic has quadrupled since January 2025, meaning the infrastructure for AI-driven commerce is scaling faster than most merchants realize.

The search box used to be the front door to your store. Now it is the entire store. The AI handles discovery, browsing, selection, and purchase. Your website is the backend.

How AI Shopping Actually Works

To understand why this matters, you need to understand how an AI shopping agent completes a purchase. The flow is fundamentally different from a human shopper visiting your website.

The Traditional Flow (Human Shopper)

User searches "wireless earbuds under $80"
  → Clicks a Google result
    → Lands on your product page (page view)
      → Browses products (click events)
        → Adds to cart (JS event)
          → Enters payment info (form submission)
            → Completes checkout (conversion)

Every step generates a page view, a cookie, a JavaScript event. Your analytics sees everything.

The AI Agent Flow (Zero-Click)

User says "buy me wireless earbuds under $80"
  → AI agent queries your /.well-known/ucp endpoint (API call)
    → Agent parses your capabilities, products, payment methods (JSON)
      → Agent browses product catalog (API call)
        → Agent creates checkout session (API call)
          → Agent submits payment credentials (API call)
            → Order completed (API response)

No browser opens. No JavaScript runs. No cookies are set. No page view is recorded. The entire transaction happens through API calls between the AI agent and your store's UCP (Universal Commerce Protocol) endpoints.

From the user's perspective, they said "buy me earbuds" and received a confirmation. From your GA4 dashboard's perspective, nothing happened. The sale exists in your payment processor and your order management system, but your analytics attributes it to "direct" or "other" — if it sees it at all.

This is not a theoretical future. Google AI Mode is doing this today with Gemini. ChatGPT is doing this through its own protocol. Perplexity, Claude, and Copilot are all building or shipping agent commerce capabilities.

The transaction happens. The revenue appears. But your traditional analytics stack is blind to how and why it happened.

The Three Protocols

Three competing (and partially overlapping) protocols are enabling AI agent commerce in 2026. Understanding them matters because each has different technical requirements, different ecosystems, and different merchant adoption paths.

UCP — Universal Commerce Protocol

Developed by: Google and Shopify, with 25+ launch partners
Powers: Google AI Mode shopping, Gemini agent commerce
How it works: Merchants publish a JSON profile at /.well-known/ucp describing their store's capabilities, products, checkout flow, and payment handlers. AI agents discover this profile, parse it, and transact through the defined API endpoints.
Scale: Over 1 million Shopify merchants are expected to gain UCP support as Shopify rolls out the protocol across its platform. Google's integration means any Gemini-powered surface — Search, AI Mode, Android, Google Assistant — can discover and shop UCP-enabled stores.
Key detail: UCP is an open specification. Any AI agent can implement it, not just Google's. The protocol is designed for a multi-agent future.

ACP — Agent Commerce Protocol

Developed by: OpenAI and Stripe
Powers: ChatGPT shopping, ChatGPT Instant Checkout
How it works: Merchants integrate through Stripe's payment infrastructure. AI agents use ACP endpoints to discover products and complete purchases using Stripe as the payment rail.
Scale: OpenAI launched ChatGPT Instant Checkout in January 2026 with a 4% transaction fee on AI-initiated purchases (PYMNTS, Jan 2026). The initial rollout includes select merchant categories, with broader availability planned for mid-2026.
Key detail: ACP ties closely to Stripe's existing merchant base. If you already use Stripe, ACP adoption has a lower barrier. The 4% fee is on top of standard Stripe processing fees.

Microsoft Copilot Checkout

Developed by: Microsoft
Powers: Copilot shopping across Bing, Edge, Windows, and Microsoft 365
How it works: Integration through Microsoft's merchant ecosystem, including Bing Shopping and Microsoft Advertising.
Scale: Still in earlier stages compared to UCP and ACP, but Microsoft's distribution through Windows, Edge, and Office means it reaches a large installed base by default.
Key detail: Copilot's commerce capabilities are expanding with each release. Microsoft has been less public about the protocol specifics but is actively onboarding merchants.

Which Protocol Should You Support?

The honest answer: probably all of them, eventually. In practice, UCP is the priority for most merchants because Google Search is still the dominant product discovery channel, and Shopify's adoption means the tooling and infrastructure will mature fastest. ACP matters if ChatGPT is a significant discovery channel for your product category. Copilot matters for B2B and enterprise scenarios where Microsoft's ecosystem dominates.

You do not need to choose one. The protocols are not mutually exclusive. A single store can serve UCP, ACP, and Copilot agents simultaneously.

What This Means for Merchants

The instinctive reaction to "clicks are declining" is panic. If fewer people visit your website, revenue must be declining too. Right?

Not necessarily. Here is the more nuanced picture:

Traffic Is Declining, but Revenue Is Shifting

The AI agent that buys wireless earbuds from your store without generating a page view still generates revenue. The order still ships. The payment still processes. The customer still receives the product. The economic transaction is identical — it just arrives through a different channel.

What is actually happening is a channel shift, not a revenue collapse. Revenue that previously came through organic search clicks is migrating to AI agent transactions. The total addressable market is not shrinking. The distribution mechanism is changing.

The merchants who will struggle are those who are only set up to receive traffic through browsers and only measure success through page views. The merchants who will thrive are those who are discoverable by AI agents and can complete transactions through protocol-level APIs.

Traditional Analytics Are Blind

This is the urgent problem. If 10% of your revenue is coming through AI agent transactions today and your GA4 dashboard shows zero AI agent activity, you are making business decisions on incomplete data. You might cut a product line that AI agents are selling well. You might change a checkout flow that breaks agent compatibility. You might think your marketing is underperforming when the missing revenue is simply arriving through a channel you cannot see.

The analytics gap is not a nice-to-have issue. It is a decision-quality issue. You need tools that can track the agentic commerce funnel — discovery, browse, checkout, payment, and order — and attribute it correctly.

Product Data Quality Is Now Mission-Critical

When a human shopper visits your product page, they can look at photos, read descriptions, interpret context, and make judgment calls. An AI agent cannot. It reads your structured data — product schemas, pricing fields, availability status, shipping options — and makes decisions based on that data alone.

If your product titles are vague, the agent may skip your products. If your schema markup is incomplete, the agent may not understand your catalog. If your pricing data is inconsistent between your feed and your site, the agent may encounter errors at checkout.

Product data quality has always mattered for SEO. In the age of AI shopping, it is the difference between being discoverable and being invisible.

5 Things You Should Do Right Now

Here is the actionable checklist. These are ordered by impact and effort — the first two take minutes, the last three take days.

1. Validate Your UCP Profile

If you have a UCP profile (or think you might — Shopify is rolling these out automatically), validate it. A profile with structural errors, missing required fields, or broken endpoint references means AI agents cannot transact on your store even if they discover it.

How to do it:

Go to ucptools.dev and run the validator. It checks four levels:

Structural: JSON format, required fields, version format
Rules: Namespace/origin binding, HTTPS requirements, signing keys
Network: Remote schema verification, endpoint accessibility
SDK: Official UCP specification compliance

The validator is free, requires no signup, and gives you a detailed report with specific error codes and fix suggestions. If your profile passes all four levels, agents can discover and transact on your store. If it fails, the report tells you exactly what to fix.

Time: 2 minutes
Cost: Free

2. Check Your ACP Readiness

If you use Stripe, you may already be partially ACP-ready. The ACP protocol builds on Stripe's existing payment infrastructure, but there are specific requirements around product catalog exposure, checkout session handling, and agent authentication.

UCPtools includes an ACP readiness checker at ucptools.dev that evaluates your store's compatibility with the Agent Commerce Protocol. It identifies what you already have in place and what gaps remain.

Even if ACP is not your immediate priority, knowing your readiness baseline is useful for planning.

Time: 5 minutes
Cost: Free

3. Audit Your Product Data and Schema Markup

AI agents rely on structured data to understand your products. This means your product feed, your schema.org markup, and your UCP product catalog need to be accurate, complete, and consistent.

Run an audit focused on:

Product titles: Clear, specific, not stuffed with keywords. "Sony WH-1000XM5 Wireless Noise-Cancelling Headphones" is better than "Best Headphones SALE 2026!!!" for AI agents.
Pricing data: Ensure prices in your product feed match your live site. AI agents cross-reference these.
Availability: If a product is out of stock, your structured data should say so. Agents that create checkout sessions for unavailable products generate errors and drop off.
Schema markup: Ensure Product, Offer, AggregateRating, and Review schemas are present and valid. Use Google's Rich Results Test to check.
Product identifiers: GTINs, MPNs, and brand fields help agents match your products to user queries. Missing identifiers reduce discoverability.

UCPtools includes a Feed Analyzer that can parse your product feed and identify issues that would cause problems for AI agents — missing fields, inconsistent pricing, broken image URLs, and more.

Industry data suggests that product data improvements show measurable results in 2-4 weeks as AI agents re-crawl and re-index your catalog. This is one of the highest-ROI investments you can make right now.

Time: 1-3 days depending on catalog size
Cost: Free tools available; may need developer time for fixes

4. Set Up AI Agent Analytics

You cannot optimize what you cannot measure. Traditional analytics tools do not track AI agent transactions because AI agents do not execute JavaScript, accept cookies, or generate page views. You need purpose-built analytics that track the agentic commerce funnel.

The agentic commerce funnel has five stages:

Discovery — Agent hits /.well-known/ucp to find your store
Browse — Agent queries your product catalog
Checkout — Agent creates a checkout session
Payment — Agent submits payment credentials
Order — Transaction completes, revenue is recorded

Each stage maps to specific API calls. Tracking middleware intercepts these calls, classifies the agent (Gemini, ChatGPT, Perplexity, Claude, Copilot), and records the funnel event.

UCPtools Analytics V2 tracks the full funnel for both UCP and ACP protocols. You can explore the interactive demo at ucptools.dev/dashboard/analytics?demo=true — it loads realistic sample data showing 2,847 events, $12,450 in agentic revenue, and per-agent conversion rates. No signup required to explore the demo.

For production tracking, the Starter plan at $9/mo includes full funnel analytics, agent comparison, error analysis, and capability gap reporting.

Time: 30 minutes for middleware setup
Cost: Free demo; $9/mo for production tracking

5. Monitor Your AI Traffic Starting Today

Even before you set up full funnel analytics, you can start monitoring AI agent traffic in your existing server logs. Look for these User-Agent patterns:

Googlebot              — Google's crawler (may include UCP discovery)
Google-Extended         — Gemini/AI Mode specific
GPTBot                 — OpenAI/ChatGPT
ChatGPT-User           — ChatGPT browsing mode
PerplexityBot          — Perplexity AI
ClaudeBot / anthropic  — Anthropic's Claude
CopilotBot             — Microsoft Copilot

Check your access logs for requests to /.well-known/ucp. If you see hits there, AI agents are already discovering your store. Check the response codes — 200 means they found a valid profile, 404 means they looked and found nothing.

Also monitor requests to your product API endpoints and checkout endpoints from these user agents. Any activity there means agents are not just discovering you — they are attempting to browse and buy.

You can do this with a simple log grep:

# Check for AI agent discovery attempts
grep "well-known/ucp" /var/log/nginx/access.log

# Check for specific AI agents
grep -E "GPTBot|Google-Extended|PerplexityBot|ClaudeBot|CopilotBot" \
  /var/log/nginx/access.log | tail -50

If you see activity, you have AI agent traffic today. If you see 404s on /.well-known/ucp, agents are looking for you and not finding you — which means setting up a UCP profile is an immediate revenue opportunity.

Time: 15 minutes
Cost: Free

The Bottom Line

Zero-click retail is not the death of e-commerce. It is the transformation of e-commerce.

The economic transaction has not disappeared. People still want products. They still pay money. Merchants still fulfill orders. What has changed is the intermediary. Instead of a browser rendering your product page and a human clicking "Add to Cart," an AI agent parses your product data and completes the purchase through an API call.

The merchants who will win this transition are the ones who treat AI agents as a first-class sales channel — not a threat to be blocked, not a curiosity to be ignored, but a channel to be optimized with the same rigor applied to organic search, paid ads, and email.

That means:

Being discoverable through UCP, ACP, and structured data
Being transactable with working checkout flows that agents can complete
Being measurable with analytics that actually track the agentic funnel
Being optimized by fixing errors, adding capabilities, and improving product data

The 93% zero-click stat is not a death sentence. It is a signal that the channel is shifting. One million Shopify merchants are about to get UCP profiles. Google AI Mode is adding new merchant categories every month. ChatGPT Instant Checkout is rolling out with a growing merchant base.

The wave is coming. The question is whether you are set up to catch it or whether AI agents will discover your store, find nothing, and move on to your competitor.

Start with the five steps above. Validate your profile, check your readiness, audit your data, set up analytics, and monitor your traffic. The tools are free. The data improvements show results in weeks, not months. And the merchants who move first will have the analytics history, the optimization insights, and the agent compatibility that latecomers will spend months catching up on.

Resources

UCP Validator — validate your UCP profile for free
AI Agent Simulator — test how AI agents interact with your store
Analytics V2 Demo — explore the full agentic analytics dashboard
Feed Analyzer — audit your product data for AI readiness
UCP Specification — the official protocol spec from Google and Shopify
ACP Specification — the official Agent Commerce Protocol spec
Google AI Mode Shopping Announcement — Google's rollout details

What is your experience with AI agent traffic on your store? Are you seeing hits on /.well-known/ucp in your logs? Have you noticed revenue appearing in your payment processor that GA4 cannot explain? Share your observations in the comments.

Disclaimer: UCP is an open standard by Google and Shopify. ACP is an open standard by OpenAI and Stripe. UCPtools is an independent community tool — not affiliated with Google, Shopify, OpenAI, or Stripe.

Agorio v0.3: Triple-Protocol AI Agents - UCP, ACP, and MCP in One SDK

Peter — Fri, 20 Feb 2026 14:18:47 +0000

TL;DR

Agorio v0.3 is the first commerce agent SDK that supports all three open protocols - UCP (Google/Shopify), ACP (OpenAI/Stripe), and MCP (JSON-RPC) - from a single codebase. Also shipping: 4 LLM adapters (including Ollama for offline agents), a plugin system, observability, and a CLI.

npm install @agorio/sdk

191 tests. MIT license. Star the repo if this is useful.

What Changed Since v0.1

A few weeks ago, we launched Agorio with UCP support and a single Gemini adapter. Here's where we are now:

Feature	v0.1	v0.3
Protocols	UCP only	UCP + ACP + MCP (auto-detect)
LLM adapters	Gemini	Gemini, Claude, OpenAI, Ollama
Streaming	No	`runStream()` async generator
Plugins	No	Custom tools via `AgentPlugin`
Observability	No	Logging, tracing, metrics
CLI	No	`npx agorio`
Mock servers	1 (UCP)	3 (UCP, ACP, MCP)
Tests	37	191

Let me walk through the highlights.

Triple-Protocol Auto-Detection

The agentic commerce space has three protocols now:

UCP - Google AI Mode (75M+ daily users), Shopify merchants
ACP - ChatGPT Instant Checkout (800M+ weekly users), Stripe merchants
MCP - JSON-RPC 2.0 transport for tool-based interactions

Most SDKs force you to pick one. Agorio auto-detects:

import { ShoppingAgent, ClaudeAdapter } from '@agorio/sdk';

const agent = new ShoppingAgent({
  llm: new ClaudeAdapter({ apiKey: process.env.ANTHROPIC_API_KEY }),
  acpOptions: {
    endpoint: 'https://merchant.example.com',
    apiKey: process.env.MERCHANT_API_KEY,
  },
});

// Agent auto-detects UCP, ACP, or MCP - your code doesn't change
const result = await agent.run('Buy wireless headphones from shop.example.com');
console.log(result.checkout?.orderId);

When discover_merchant runs, Agorio tries UCP first (/.well-known/ucp), checks for MCP transport support, then falls back to ACP. All 12 built-in tools route through whichever protocol the merchant speaks.

Star on GitHub - it helps other developers find this.

Run Agents Offline with Ollama

No API keys? No problem. The new OllamaAdapter connects to a local Ollama instance:

import { ShoppingAgent, OllamaAdapter, MockMerchant } from '@agorio/sdk';

const merchant = new MockMerchant();
await merchant.start();

const agent = new ShoppingAgent({
  llm: new OllamaAdapter({ model: 'llama3.1' }),
});

const result = await agent.run(
  `Browse products at ${merchant.domain}`
);

await merchant.stop();

Fully offline. No API costs. Same LlmAdapter interface as the cloud adapters - swap one line to switch between local and cloud.

All four adapters support function calling and streaming:

new GeminiAdapter({ apiKey: process.env.GEMINI_API_KEY })   // Google
new ClaudeAdapter({ apiKey: process.env.ANTHROPIC_API_KEY }) // Anthropic
new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY })    // OpenAI
new OllamaAdapter({ model: 'llama3.1' })                    // Local

Plugin System: Add Custom Tools

The 12 built-in shopping tools cover discovery, search, cart, checkout, and order tracking. But what if you need something custom? Register a plugin:

const priceAlertPlugin: AgentPlugin = {
  name: 'check_price_alert',
  description: 'Check if a product price is below the user threshold',
  parameters: {
    type: 'object',
    properties: {
      product_name: { type: 'string' },
      max_price: { type: 'number' },
    },
    required: ['product_name', 'max_price'],
  },
  handler: async ({ product_name, max_price }) => {
    // Your custom logic here
    return { alert: true, current_price: 29.99 };
  },
};

const agent = new ShoppingAgent({
  llm: new ClaudeAdapter({ apiKey: process.env.ANTHROPIC_API_KEY }),
  plugins: [priceAlertPlugin],
});

The LLM sees your custom tool alongside the built-in ones and can call it during the agent loop. Name conflicts with built-in tools throw at construction time.

Streaming: Watch the Agent Think

Use runStream() to get real-time events as the agent reasons and acts:

for await (const event of agent.runStream('Buy me headphones')) {
  switch (event.type) {
    case 'text_delta':
      process.stdout.write(event.text);
      break;
    case 'tool_call':
      console.log(`\nCalling ${event.toolName}...`);
      break;
    case 'tool_result':
      console.log(`Got result from ${event.toolName}`);
      break;
    case 'done':
      console.log('\nDone:', event.result.checkout?.orderId);
      break;
  }
}

Each adapter implements chatStream() using its provider's native streaming API. The agent yields events as the LLM thinks and acts.

Observability: Logging, Tracing, Metrics

Production agents need visibility. Agorio v0.3 ships three observability hooks:

const agent = new ShoppingAgent({
  llm: new ClaudeAdapter({ apiKey: process.env.ANTHROPIC_API_KEY }),

  // Structured logging
  onLog: (event: AgentLogEvent) => {
    console.log(`[${event.level}] ${event.message}`, event.data);
  },

  // Distributed tracing
  tracer: {
    startSpan: (name, attributes) => {
      const span = tracer.startSpan(name, { attributes });
      return { end: () => span.end() };
    },
  },
});

// After a run, get usage metrics
const result = await agent.run('Buy headphones');
// result includes: promptTokens, completionTokens, llmCalls, toolCalls, latency

Plug in your existing OpenTelemetry setup, Datadog, or any logging backend. The interface is minimal - you bring your own implementation.

CLI: `npx agorio`

Explore UCP merchants and scaffold projects from the terminal:

# Discover a merchant's capabilities
npx agorio discover shop.example.com

# Start mock merchants for local development
npx agorio mock --port 3456

# Scaffold a new agent project
npx agorio init my-shopping-agent

No global install needed. The CLI ships with the SDK.

Get Started

npm install @agorio/sdk

GitHub: github.com/Nolpak14/agorio
npm: @agorio/sdk
Website: agorio.dev

191 tests. 4 adapters. 3 protocols. Plugin system. CLI. MIT license.

The protocols are live, merchants are onboarding. Star the repo and come build with us.

Agorio is open source and not affiliated with Google, Shopify, OpenAI, or Stripe. UCP, ACP, and MCP are open standards maintained by their respective organizations.

DEV Community: Peter

Valid JSON, broken discovery: the UCP checks that should fail your build

Discovery comes before checkout

The checks that should fail your build

1. /.well-known/ucp is missing or not fetchable

2. Endpoint URLs are not HTTPS

3. Endpoint URLs have a trailing slash mismatch

4. ucp.version is missing or malformed

5. The root ucp object is missing

6. Namespace authority and schema origins do not match

7. Signing keys are missing

What should warn instead of fail

A practical CI workflow

Where ACP fits

Final takeaway

Valid JSON Valid UCP: 10 Checks That Should Fail Your Build

The Discovery Hierarchy

The 10 Discovery-Critical Checks

Level 1: Fetchable

1. UCP_PROFILE_FETCH_FAILED — Manifest unreachable

2. UCP_ENDPOINT_NOT_HTTPS — HTTP endpoint in profile

Level 2: Parseable

3. UCP_MISSING_ROOT — No ucp object

4. UCP_MISSING_VERSION / UCP_INVALID_VERSION_FORMAT — Bad version

5. UCP_MISSING_SERVICES — No services object

6. UCP_MISSING_CAPABILITIES — No capabilities array

Level 3: Verifiable

7. UCP_NS_ORIGIN_MISMATCH — Schema URL spoofing

8. UCP_ORPHANED_EXTENSION — Extension without parent

9. UCP_MISSING_SIGNING_KEYS — No webhook verification keys

10. UCP_ENDPOINT_TRAILING_SLASH — Trailing slash in URL

What About Cart, Catalog, and Identity Linking?

Running These Checks in CI

TL;DR

How to Check Polish Company Insolvency Programmatically (KRZ Scraper)

TL;DR

The Problem

The Solution

What You Can Search

Step-by-Step: Check 100 Companies in 10 Minutes

1. Create a free Apify account

2. Navigate to the actor

3. Configure your input

4. Read the results

5. Deep-dive into a specific proceeding

Pricing

Part of the Polish Business Data Suite

Technical Details

ClickUp + MCP: the practical setup + 5 automation patterns (Claude Desktop / ChatGPT / n8n)

What you need before you start

1) A ClickUp personal token

2) IDs you'll use a lot

Option A: Use a hosted MCP server (no local Node process)

Option B: n8n pattern (agent-in-the-middle)

5 ClickUp workflows that are actually worth automating

1) Triage new tasks into the right list + fill missing fields

2) Daily standup summary from "In Progress"

3) Convert meeting notes into tasks + link to the notes doc

4) "Release checklist" generator per project

5) Weekly cleanup: stale tasks + duplicate detection

Common MCP failure modes (and how to debug fast)

1) Tool collisions (multiple MCP servers enabled)

2) Timeouts on "big list" queries

3) Rate limits

When MCP is overkill

Try it / poke holes in it

UCP Cart, Catalog, and Identity Linking: What to Validate (and What Can Wait)

What Changed on March 19

Draft vs Stable: Why Your Validator Needs to Know

The Cart Capability: What to Validate

Required Fields in Cart Response

Validation Checklist for Cart

Cart-to-Checkout Conversion

The Catalog Capabilities: What to Validate

Validation Checklist for Catalog

Identity Linking: What to Validate

Validation Checklist for Identity Linking

The 7 Rules That Actually Break Discovery

1. Missing or malformed /.well-known/ucp

2. Missing or invalid version

1. `/.well-known/ucp` is missing or not fetchable

4. `ucp.version` is missing or malformed

5. The root `ucp` object is missing

1. `UCP_PROFILE_FETCH_FAILED` — Manifest unreachable

2. `UCP_ENDPOINT_NOT_HTTPS` — HTTP endpoint in profile

3. `UCP_MISSING_ROOT` — No `ucp` object

4. `UCP_MISSING_VERSION` / `UCP_INVALID_VERSION_FORMAT` — Bad version

5. `UCP_MISSING_SERVICES` — No services object

6. `UCP_MISSING_CAPABILITIES` — No capabilities array

7. `UCP_NS_ORIGIN_MISMATCH` — Schema URL spoofing

8. `UCP_ORPHANED_EXTENSION` — Extension without parent

9. `UCP_MISSING_SIGNING_KEYS` — No webhook verification keys

10. `UCP_ENDPOINT_TRAILING_SLASH` — Trailing slash in URL

1. Missing or malformed `/.well-known/ucp`