Agent Commerce Protocol. The open standard for AI agent-to-brand commerce.
ACP defines how AI shopping agents discover, query, negotiate, and purchase products from brands. One spec. Every brand. Every agent.
Four phases. Each phase is a layer brands and agents can adopt independently.
ACP defines how AI shopping agents discover, query, negotiate, and purchase products from brands.
Discovery
Agents find your products through a standardized API. Publish a .well-known/acp.json and any AI agent can discover your storefront.
The discovery layer uses a well-known URI pattern inspired by OAuth and WebFinger. Brands publish a machine-readable manifest at /.well-known/acp.json that declares supported protocol versions, available endpoints, rate limit tiers, and capability flags. Agents crawl these manifests to build a real-time registry of ACP-compatible storefronts without any centralized directory.
Query
Structured request/response protocol for product search. Agents send typed queries with intent, filters, and context. Your storefront returns rich product cards.
Queries support five intent types: search, recommend, compare, detail, and availability. Each intent has its own schema for filters, sort order, and pagination. Responses return AgentProductCards: a structured format with pricing, attributes, review summaries, and trust scores.
Negotiate
Agent-to-agent price negotiation with typed offers and counter-offers. Supports volume discounts, bundles, subscriptions, and time-limited deals.
The negotiation protocol is a finite state machine with well-defined transitions: offer, counter-offer, accept, reject, expire. Each transition is authenticated and logged. Price holds let agents lock a negotiated price for a configurable TTL.
Transact
Secure transaction coordination with escrow and fulfillment tracking. Full lifecycle from cart to delivery with dispute resolution.
Transactions follow a strict lifecycle: cart, checkout, payment authorization, fulfillment, completion. Escrow holds funds until delivery confirmation. Built-in dispute resolution provides structured claim and evidence submission. Webhooks fire at every stage.
Existing approaches don’t fit. They were built for browsers, not autonomous agents.
Web scraping, affiliate APIs, embedded widgets, and custom brand APIs each solve part of the problem. None solves all four phases.
| Approach | Limitations | ACP advantage |
|---|---|---|
| Web scraping | Fragile selectors break on redesign. Blocked by anti-bot measures. No structured data. Legal gray area. Cannot negotiate or transact. | Structured JSON with typed schemas. Explicit permission via API keys. Stable versioned endpoints. |
| Affiliate APIs | Read-only product data. No negotiation or transaction support. Limited to participating affiliate networks. Inconsistent formats. | Full commerce lifecycle from discovery to delivery. Standardized format across brands. Direct brand relationship without intermediaries. |
| Embedded commerce widgets | Requires a browser context. Cannot be consumed by headless agents. No programmatic negotiation. Poor accessibility for AI systems. | API-first by design. No browser or rendering engine required. Every interaction is a typed API call. |
| Custom brand APIs | Every brand has a different schema, auth mechanism, and endpoint structure. Agents must maintain per-brand integrations. No interoperability. | Single protocol, single SDK. An agent that supports ACP can interact with any ACP-connected brand without brand-specific code. |
Four independent layers. Adopt only what you need.
Each layer has its own versioning, capabilities, and audit trail. Brands can ship discovery and query without touching negotiation or transactions.
Layer 0: Discovery
The agent resolves the brand’s domain and fetches /.well-known/acp.json. The manifest declares supported protocol versions, endpoint base URLs, authentication requirements, rate limit tiers, and capability flags. Discovery is cacheable with standard HTTP cache headers.
Agent → DNS → GET /.well-known/acp.json → Parse manifest → Cache
Layer 1: Query
The agent POSTs to the query endpoint with a typed intent (search, recommend, compare, detail, or availability). The request includes structured filters, natural language context, and pagination cursors. The storefront returns AgentProductCards with pricing, attributes, reviews, and trust scores.
Agent → POST /api/storefront/{brandId}/query → Storefront → AgentProductCard[]
Layer 2: Negotiation
The agent submits an offer on one or more products. The storefront can accept, reject, or counter-offer. Each state transition is tracked by a session ID with timestamps, expiry TTLs, and audit metadata. The state machine prevents invalid transitions.
Agent → POST /negotiate → counter-offer → accept → Price hold issued
Layer 3: Transaction
The agent creates a cart, initiates checkout with a payment method token, and the storefront coordinates authorization, capture, fulfillment, and delivery. Webhooks fire at each stage. Escrow holds funds until receipt is confirmed. Disputes follow a structured claim-evidence-resolution flow.
Agent → POST /transactions → Webhooks: authorized, fulfilled, delivered → Complete
Four principles. They guide every decision in the spec.
Open
ACP is an open specification published under Apache 2.0. Anyone can implement a client or server without permission, royalties, or registration. The spec is developed in the open on GitHub with public RFCs.
Federated
There is no central server or mandatory registry. Each brand hosts its own ACP endpoints and publishes its own discovery manifest. Agents discover storefronts through DNS-based well-known URIs, the same decentralized pattern email and WebFinger use.
Agent-Native
Every design decision optimizes for machine-to-machine communication. Responses are structured data, not HTML. Errors include machine-readable codes and field-level details. Pagination uses cursors. The consumer is an autonomous agent, not a human with a browser.
Composable
ACP layers are independent. A brand can implement discovery and query without negotiation. An agent can use query without transactions. Each layer has its own versioning and capability flags, allowing incremental adoption and graceful degradation.
“The best protocol is one where the happy path needs zero configuration. Publish your manifest, implement the query endpoint, and every AI agent in the world can find your products.”
Protocol at a glance. The technical contract.
| Current Version | 2.0 |
| Transport | HTTPS (TLS 1.2+) |
| Encoding | JSON (UTF-8) |
| Authentication | API Key (Bearer token) |
| Discovery | /.well-known/acp.json |
| Rate Limiting | Tiered (Free / Growth / Enterprise) |
| Versioning | Semantic (major.minor) |
| Error Format | RFC 7807 Problem Details |
| Webhooks | HMAC-SHA256 signed payloads |
| License | Apache 2.0 |
Where ACP is right now. Spec live. SDKs and pilot brands ramping up.
Honest status on what’s shipped and what’s next.
Spec v2.0
liveCandidate Recommendation published. Apache 2.0. Open for comment on GitHub.
JavaScript / Python SDKs
in development@cresva/acp-client (TypeScript) and cresva-acp (Python) shipping first. Go and Ruby planned.
Storefront framework
betaExpress and FastAPI adapters for ACP endpoints. Discovery, auth, rate limiting handled.
From shopping to procurement. Same protocol. Same SDK.
AI Shopping Assistant
A conversational agent helps a user find and purchase products across multiple brands. The agent uses ACP discovery to locate storefronts, the query layer to search catalogs, and the transaction layer to complete purchases. All in a single chat conversation.
Example
“Find me running shoes under $150 with good arch support.” The agent queries 12 ACP-connected shoe brands simultaneously, compares results using structured product cards, and presents a ranked shortlist.
Price Comparison Agent
An autonomous agent monitors prices across ACP-connected storefronts for a set of tracked products. When a price drops below a threshold, the agent notifies the user or automatically triggers a purchase using pre-authorized transaction rules.
Example
A user tracks the Sony WH-1000XM5. The agent polls 8 storefronts every hour via ACP queries, detects a 20% drop at one retailer, and uses the negotiation layer to request a loyalty discount before purchasing.
Automated Procurement
Procurement systems use ACP to automate routine purchasing. The agent maintains approved vendor lists via ACP discovery, issues RFQs using the negotiation protocol, compares bids on structured attributes, and places orders through the transaction layer with escrow for quality verification.
Example
A facilities manager sets a rule: “Reorder printer paper when stock falls below 500 sheets.” The agent queries three approved vendors, negotiates volume pricing, and places the order with the best price-to-delivery-time ratio.
Inventory Intelligence
Retail analytics teams use ACP availability intents to track stock levels and pricing across competitor storefronts. The structured response format makes it straightforward to build dashboards, trigger alerts, and feed data into demand forecasting models.
Example
A brand monitors competitor pricing and stock for 500 SKUs across 20 ACP-connected storefronts, feeding the data into pricing models that adjust their own storefront prices nightly.
Built alongside the spec. Honest status on each.
Official SDKs
@cresva/acp-client (TypeScript) and cresva-acp (Python) shipping first. Go and Ruby planned.
Storefront framework
Express and FastAPI adapters for ACP endpoints. Discovery, auth, rate limiting out of the box.
ACP validator
CLI to validate your ACP implementation against the spec. Compliance tests across all four layers.
Trust dashboard
Monitor trust score, agent feedback, query volume, and conversion funnels.
A search query. Request and response.
Request
import { CresvaClient } from "@cresva/sdk";
const client = new CresvaClient({
apiKey: "pk_live_your_key_here",
brandId: "brand_abc123",
});
const results = await client.query({
intent: "search",
query: "wireless noise-cancelling headphones under $200",
filters: {
category: "electronics/audio/headphones",
price: { max: 200, currency: "USD" },
attributes: { wireless: true, noiseCancelling: true },
},
context: {
budget: "moderate",
preferences: ["comfort", "battery-life"],
},
limit: 5,
});
console.log(results.products);Response
{
"products": [
{
"id": "prod_h7k2m",
"title": "ProSound ANC-300 Wireless Headphones",
"price": 179.99,
"currency": "USD",
"url": "https://acme.com/products/prosound-anc-300",
"description": "Premium noise-cancelling wireless headphones with 40hr battery",
"availability": "in_stock",
"attributes": {
"wireless": true,
"noiseCancelling": true,
"batteryLife": "40 hours",
"weight": "250g"
},
"reviews_summary": {
"average": 4.6,
"count": 2847,
"highlights": ["Excellent ANC", "All-day comfort", "Great battery"]
},
"trust_score": {
"overall": 92,
"tier": "Gold"
}
}
],
"total": 12,
"query_id": "qry_9f8e7d6c"
}Read the spec. Or skip ahead to the API reference.
Commerce infrastructure should be as interoperable as email. Any agent should be able to shop at any brand using a single protocol.