The Agent Commerce Tech Stack.

The complete stack at a glance.

Eight layers, every one of which has to exist before an AI agent can find your store, query your catalog, transact, and report the result back to its user. Most solo founders show up thinking "I just need a Stripe button." The actual stack is closer to this:

┌─────────────────────────────────────────────────────────────────────────┐
│                    AGENT COMMERCE TECH STACK (2026)                     │
├──────────────┬──────────────────────────────────────────────────────────┤
│ Layer        │ Tool (primary → alternative)                             │
├──────────────┼──────────────────────────────────────────────────────────┤
│ L1 Hosting   │ Vercel Fluid Compute → Railway → Cloud Run               │
│ L2 Database  │ Supabase (Postgres + pgvector) → Neon                    │
│ L3 Caching   │ Upstash Redis → Cloudflare KV                            │
│ L4 API GW    │ Zuplo → Cloudflare Workers → Kong                        │
│ L5 Auth/Keys │ Unkey → JWT + Supabase Auth                              │
│ L6 Billing   │ Stripe → Lemon Squeezy (tax-inclusive)                   │
│ L7 Agent I/F │ OpenAPI spec + FastMCP server + UCP checkout             │
│ L8 Observ.   │ Grafana Cloud (metrics/logs) + Sentry (errors)           │
│ CI/CD        │ GitHub Actions + Vercel preview deployments              │
│ Vector Search│ pgvector (free/bundled) → Pinecone → Qdrant Cloud       │
└──────────────┴──────────────────────────────────────────────────────────┘

The second diagram shows where this maps to the broader protocol and payment stack:

┌─────────────────────────────────────────────────────────────┐
│ 1. AI Surface             Google AI Mode · ChatGPT · Claude │
├─────────────────────────────────────────────────────────────┤
│ 2. Protocol               UCP · ACP · MCP · A2A             │
├─────────────────────────────────────────────────────────────┤
│ 3. Discovery              /.well-known/ucp · Schema.org ·   │
│                           Merchant Center feed              │
├─────────────────────────────────────────────────────────────┤
│ 4. API + OpenAPI          FastAPI on Vercel Fluid Compute   │
├─────────────────────────────────────────────────────────────┤
│ 5. Data                   Postgres (Supabase/Neon) +        │
│                           pgvector + Upstash Redis          │
├─────────────────────────────────────────────────────────────┤
│ 6. Payment Authorization  AP2 mandates · Stripe SPTs ·      │
│                           Visa Trusted Agent Protocol       │
├─────────────────────────────────────────────────────────────┤
│ 7. Billing + API Keys     Stripe Billing · Unkey / Zuplo    │
├─────────────────────────────────────────────────────────────┤
│ 8. Observability          Sentry · Logfire · Cloudflare     │
│                           Bot Analytics · structured logs   │
└─────────────────────────────────────────────────────────────┘

Per the UCP specification at ucp.dev, this stack collapses N×N integration complexity into a 1-to-Many model: implement once, every UCP-compliant agent can reach you. The eight layers below are what "implement once" actually means.

Full stack cost by MRR stage.

All prices fetched from official pricing pages. "$1K MRR" assumes ~1,000 active customers and ~3M API calls/month. "$10K MRR" assumes ~10K customers and ~30M API calls/month.

Vector search add-on (if needed)

pgvector handles product catalog semantic search up to ~1M vectors with an HNSW index at zero additional cost on Supabase Pro. Switch to a dedicated vector database at three signals: (a) catalog exceeds 1M vectors, (b) p99 semantic search latency exceeds 500ms under concurrent agent load, or (c) you need multi-tenant vector isolation.

Reading the table: At zero revenue you can run a production-grade agent commerce stack for about a dollar a month, but only because Vercel Hobby is non-commercial. The moment you take a paying customer, you owe Vercel $20/mo for Pro and Supabase $25/mo for a Postgres that doesn't pause itself. From there, the next $80/mo gets you everything else — error tracking, billing, API keys, transactional email, domain. The first $130/mo carries you to roughly $1K MRR. From $1K to $10K MRR, the largest cost growth is Stripe processing fees, not infrastructure.

Build order & dependencies.

One row per stack layer. "Hard Dependency On" lists the layers that must exist first. "Can Be Deferred" means the stack can ship and transact without it.

The minimum viable day-one stack

Per the dev.to UCP vs ACP comparison: "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."

1. FastAPI app with the six UCP REST endpoints listed in Layer 4
2. Postgres database (Supabase Pro or Neon Launch)
3. HTTPS-served /.well-known/ucp JSON manifest pointing at the API
4. Stripe account configured for ACP or SPTs
5. Sentry + Cloudflare spend alerts

When each free tier breaks.

The free tier is a marketing-acquisition channel for every vendor in this stack. They are calibrated to break at slightly different points. Knowing the order of breakage is how you avoid the $1,141 Vercel bill.

Agent-specific considerations.

What changes when your API is built for agents rather than humans.

Traffic patterns

• AI crawler traffic grew 15× in 2025 globally; AI bot share of HTML requests reached 4.2% average (Cloudflare Radar Year in Review).
• Anthropic's ClaudeBot crawl-to-refer ratio peaks at 500,000:1; OpenAI's GPTBot reaches 3,700:1.
• Visa cited a 4,700% surge in AI-driven traffic to U.S. retail sites as justification for launching Trusted Agent Protocol.
• Bursty traffic patterns can look like abuse to a naive rate limiter. Configure horizontal scale, not vertical.

Headers well-behaved agents send

• OpenAI GPTBot / OAI-SearchBot — declared User-Agent + dedicated IP ranges.
• Anthropic-ai / ClaudeBot — declared User-Agent, dedicated IPs.
• ChatGPT Agent, Goose, Browserbase, Anchor Browser — RFC 9421 HTTP Message Signatures with Signature-Agent, Signature-Input, Signature headers.

Per Simon Willison's writeup, actual ChatGPT agent headers look like:

Signature-Agent: "https://chatgpt.com"
Signature-Input: sig1=("@authority" "@method" "@path" "signature-agent");
                 created=1754340838;keyid="...";alg="ed25519";tag="web-bot-auth"
Signature: sig1=...

Verification per Arcjet: check Signature-Agent equals "https://chatgpt.com", fetch public keys from that domain's .well-known directory, verify the signature per RFC 9421.

Testing an agent-facing API

• MCP Inspector (npx @modelcontextprotocol/inspector) — interactive dev-time tool for testing MCP servers. Not CI-grade.
• UCP Conformance Suite at github.com/Universal-Commerce-Protocol/conformance — tests manifest correctness, capability schemas, checkout state machine.
• Prism (Stoplight) — open-source OpenAPI mock server + contract testing proxy; runs in CI.
• EvalView — "Playwright, but for tool-calling agents." Snapshots agent behavior as a baseline, then diffs new behavior against it. Catches silent regressions when a model update changes tool-call patterns.

Logging that distinguishes agent vs. human

No tool does it natively. The practical pattern is structured JSON logging where every request includes a parsed client_type:

{
  "timestamp": "2026-05-19T13:54:00Z",
  "request_id": "uuid",
  "api_key_id": "hashed_id",
  "endpoint": "POST /checkout-sessions",
  "http_status": 200,
  "latency_ms": 312,
  "user_agent": "OpenAI/Agents-SDK/0.4.2",
  "client_type": "agent",
  "signature_agent": "https://chatgpt.com"
}

This is what makes a client_type:agent filter on your dashboard possible. None of the analytics vendors give it to you by default.

Security: what's different

• Replay attacks matter more. Agents retry aggressively. AP2's TTL on Intent Mandates (24h recommended), ECDSA signatures, and idempotency keys exist for this reason.
• Credentials don't belong on the agent. Per Stripe: "Tokens can be scoped to a specific business, limited by time or amount, revoked at any time, and monitored via webhook events." Use Stripe SPTs or AP2 Closed Payment Mandates; never give the agent the raw card.
• Rate limiting needs per-key + per-IP + per-tool granularity. Per Panther on securing MCP: "Cap concurrent sessions per client, and throttle expensive tool categories (outbound HTTP, database writes, file operations) more aggressively than read-only tools."
• Production MCP reality. Per Lenses.io's analysis of ~7,000 MCP server implementations: 86% run locally on developer machines, only 5% in production, 43% contained command injection flaws, 25% had zero authentication. STDIO transport "failed catastrophically under concurrent load (20 out of 22 requests failed with just 20 simultaneous connections)" — if you ship MCP, you must ship Streamable HTTP, not STDIO.

The stack in production.

What a real deployed instance of this looks like end-to-end.

GitHub repo
    │
    ├─ push to main → GitHub Actions CI/CD
    │                      │
    │                      ├─ ruff (lint)
    │                      ├─ mypy (type-check)
    │                      ├─ pytest (unit + integration)
    │                      ├─ OpenAPI schema validation
    │                      ├─ pip-audit (dependency security)
    │                      └─ vercel deploy --prod
    │
    └─ PR branch → preview deployment URL on Vercel

Custom domain (Cloudflare DNS, $0.87/mo .com)
    └─ CNAME → vercel.app (auto Let's Encrypt SSL)

Secrets (Vercel env vars → pydantic-settings on boot)
    ├─ DATABASE_URL (Supabase or Neon)
    ├─ UPSTASH_REDIS_REST_URL
    ├─ STRIPE_SECRET_KEY
    ├─ UNKEY_ROOT_KEY
    └─ SENTRY_DSN

Discovery
    ├─ /.well-known/ucp  (static JSON manifest)
    ├─ /openapi.json     (auto from FastAPI)
    └─ /sitemap.xml + Schema.org Product on every PDP

Runtime
    ├─ FastAPI on Vercel Fluid Compute (Active CPU billing)
    ├─ Postgres + pgvector (Supabase Pro $25/mo)
    ├─ Upstash Redis for rate-limit counters + idempotency keys
    └─ Unkey for API-key verification (middleware)

Observability
    ├─ Sentry (ASGI middleware) — error tracking, 5K free
    ├─ Logfire (logfire.instrument_fastapi(app)) — distributed tracing
    ├─ Cloudflare Bot Analytics (Free plan) — bot vs. human signal
    └─ Vercel spend alerts ON (this is non-negotiable)

Minimum pre-deploy CI checks

• ruff check . — lint
• mypy app/ — type-check Pydantic models
• pytest tests/ -v — unit and route tests
• python -c "from app.main import app; import json; json.dumps(app.openapi())" — OpenAPI schema validity
• pip-audit — known CVEs in dependencies

Common shortcuts that backfire.

Four places solo founders cut corners on agent infrastructure that cause real problems later.

Frequently asked questions.