TypeScript-first
Framework-agnostic
Production-tested
Built-in telemetry

Two tool calls.
Commerce done.

AGC exposes a standard MCP endpoint. Connect any agent and it gets live inventory, confirmed pricing, payment execution, and fulfilment routing — through the full Discovery → UCP → Fulfillment stack.

No redirect to build. No webhook to handle. No payment infrastructure to manage. Your agent passes a quote ID. AGC handles the rest.

Every tool call is logged. Successful checkout flows become training data. Export your interactions as JSONL to fine-tune a smaller, cheaper model on your exact commerce workflows — and stop paying frontier model prices at scale.

Quickstart Live buyer endpoint
The problem

Discovery is solved.
Execution is not.

Most agent stacks stop at search and recommendation — the fuzzy, stateless layer. Completing a real purchase means solving an entirely different class of infrastructure problem before you write a line of product logic.

What you'd build from scratch

  • OAuth token lifecycle — per merchant, with refresh
  • Secure token storage — Secret Manager, KV, or DB
  • Authenticated API client with rate-limit handling
  • Webhook router — signature verification + dispatch
  • Async state: 3DS challenges, tracking updates
  • Order lifecycle: create, advance, void, refund
  • Blind AI execution — no visibility into failed tool calls or schema errors
  • An evaluation pipeline to grade good vs. bad agent interactions
  • Training data curation to improve your model over time

Weeks of infrastructure before you've written agent logic.

What you write with AGC

buyer MCP
const quote = await get_checkout_quote({
cartItems: [{ variantId, quantity }],
shopDomain: "roaster.myshopify.com",
})
const order = await execute_purchase({
quoteId: quote.quoteId,
shopDomain: "roaster.myshopify.com",
})

Everything else is handled. Including the telemetry.

The full lifecycle — where your agent fits

Discover

Your agent

Search, intent, match

Quote + Pay

AGC

State, pricing, Stripe

Fulfil

AGC + Shippo

Label, pack, track

Optimize

You + AGC

Telemetry → fine-tune

What's available

Three developer products.
Pick what you need.

Buyer and Merchant MCP endpoints are live now. The Shippo SDK is in early access.

Buyer MCPLive now

Commerce execution for buyer agents.

Connect any MCP-compatible agent to the AGC managed catalog — a unified, normalized index of every connected merchant's live inventory. Confirmed pricing with 15-minute quote TTLs, payment execution via Stripe, fulfilment routing via Shippo, and tracking fed back to your agent. Two tool calls. Discovery happens inside AGC. Not across the open web.

buyer MCP · two tools
// 1. Quote — confirmed price, live stock, 15-min TTL
const quote = await get_checkout_quote({
cartItems: [{ variantId: "gid://shopify/...", quantity: 1 }],
shopDomain: "roaster.myshopify.com",
})
// → { quoteId, total, currency, expiresAt }
// 2. Execute — one word from the buyer, one call from your agent
const order = await execute_purchase({
quoteId: quote.quoteId,
shopDomain: "roaster.myshopify.com",
})
// → { success, orderId, orderName }
API reference Live endpoint
Merchant MCPLive now

Catalog intelligence for merchant agents.

Give a merchant's AI assistant the ability to audit, enrich, and publish products. The same tools that power AGC's AI Readiness scoring — audit the catalog, enrich drafts with Gemini, push structured attributes back to Shopify. 32 tools across catalog, orders, fulfilment, team, and execution mode.

merchant MCP · catalog tools
// Audit the catalog
const summary = await get_audit_summary()
// → { overallScore, avgProductScore, totalProducts }
// Enrich a single product
const enriched = await enrich_product({ productId: "gid://shopify/..." })
// → { structuredTitle, roastLevel, originCountry, flavorNotes[] }
// Batch enrich all drafts
const results = await audit_draft_products()
// → { scored: Product[], avgScore: number }
API reference Live endpoint
Shippo SDKEarly access

Gray Label shipping for any MCP server.

Every MCP platform that wants to integrate Shippo solves the same problem from scratch — OAuth per merchant, token management, webhook routing, order lifecycle. The SDK packages our production implementation. Three lines to register, one route to mount.

npm install @agenticcommerce/shippo-mcp
register · mount · done
import { createShippoMcpPlugin } from '@agenticcommerce/shippo-mcp';
const shippo = createShippoMcpPlugin({
clientId: process.env.SHIPPO_CLIENT_ID,
clientSecret: process.env.SHIPPO_CLIENT_SECRET,
redirectUri: 'https://yourplatform.com/oauth/callback',
storage: new SecretManagerStorageAdapter({ projectId: 'your-project' }),
webhookBaseUrl: 'https://yourplatform.com/webhooks/shippo',
onTrackingUpdated: async ({ merchantId, event }) => {
await db.orders.update(event.trackingNumber, { status: event.statusDescription });
},
});
server.registerTools(shippo.tools);
app.post('/webhooks/shippo/:merchantId', shippo.webhookHandler);
Full SDK docs Request access
Security model

Your agent handles intent.
AGC handles execution.

The AI agent (your Spoke) is architecturally isolated from the payment backend (the Hub). The Hub executes payments, manages tokens, and routes webhooks. The Spoke handles conversation. They share only opaque tokens.

This isn't a policy promise — it's an architectural guarantee. Raw card numbers never enter the LLM context window. The Hub holds PCI SAQ-A compliance because it has no access to card data at all.

  • Agent receives quoteId — not price, not card, not address
  • Stripe vault is SAQ-A — independently audited, no card data in AGC
  • Merchant tokens are scoped — one token cannot act for another merchant
  • 3DS challenges surface a secure link — the agent never handles authentication

Hub-Spoke isolation

Spoke — your agent

Receives: quoteId · orderName · trackingNumber

Never sees: card · token · address · secret

opaque tokens only
Hub — AGC backend

Holds: Stripe tokens · merchant OAuth · webhook secrets

Executes: payment · order · label · fulfilment routing

PCI SAQ-A · Stripe Connect · HMAC webhook verification

Observability · Optimization

Stop prompt engineering.
Start telemetry engineering.

When you hand commerce execution to an LLM, you can't fly blind. AGC captures every JSON-RPC request, latency metric, and schema validation error your agent generates — automatically, on every tool call.

Successful checkout flows are logged as Golden Paths. Failed tool calls are flagged with error type. Export as JSONL to fine-tune a smaller, faster model on your exact commerce data — the same autonomous vehicle playbook used to replace expensive human drivers with learned autopilots.

Your frontier model is the human driver collecting the data. Your fine-tuned Apprentice model is the autopilot it trains.

  • Real-time JSON-RPC logging for every MCP tool call
  • Automated Zod error capture for hallucinated payloads
  • Golden Path tagging — sequences ending in successful execute_purchase
  • JSONL export for Vertex AI, OpenAI, or Anthropic fine-tuning
  • Your data is scoped to your token — never shared across accounts

Telemetry API

export-golden-paths.ts
// Fetch successful checkout interactions (Golden Paths)
const dataset = await agc.telemetry.getGoldenPaths({
tool: 'execute_purchase',
status: '200_OK',
limit: 100,
})
// → { interactions: JsonRpcLog[], totalTokens, avgLatencyMs }
// Export to your fine-tuning pipeline
await VertexAI.createTuningJob({
baseModel: 'gemini-1.5-flash',
trainingData: dataset.toJSONL(),
})
// Failed tool calls are flagged automatically
const failures = await agc.telemetry.getFailures({
errorType: 'validation', // Zod schema errors
limit: 50,
})
// → ready for auto-correction and reinjection

Your agent's failures become tomorrow's training data.

The flywheel

1
Log — Every tool call captured automatically.
2
Grade — Successes tagged Golden. Failures flagged by type.
3
Correct — Failed payloads auto-rewritten against your Zod schema.
4
Train — Export JSONL. Fine-tune your Apprentice model.
5
Swap — Point your MCP client at the fine-tuned model. Costs drop.
Get started

Three paths. Pick one.

Buyer and Merchant MCP endpoints are live now. SDK is early access. Telemetry is active on all live endpoints.

Buyer MCP

Commerce execution.

Live inventory, confirmed quotes, payment, fulfilment, tracking. Standard MCP protocol. Five minutes to a test order.

Quickstart API reference

Merchant MCP

Catalog intelligence.

Audit, enrich, and publish products. Give a merchant's AI assistant full catalog operator access across 27 tools.

API reference Live endpoint

Shippo SDK

Gray Label shipping.

Multi-tenant Shippo integration for MCP platforms. OAuth, webhooks, order lifecycle — packaged and production-tested.

SDK docs Request access
Questions

Common developer questions