Agentic Commerce
ACK Agentic Journey
How autonomous agents pay — identity, negotiation, settlement. ACK handles the agent identity problem, then extends x402 for payment execution.
Stage 2 deep dive
The agent identity problem.
Agent identity is the hardest compliance problem in agentic commerce. When an autonomous AI agent initiates a payment, the fundamental question is: who is this agent acting for, and are they authorized to transact?
Traditional KYC answers this for humans — passport, address, date of birth. But agents don't have passports. ACK-ID solves this with a verifiable credential system that binds an agent to its operator's identity. The credential chain works like this: a human or organization (the principal) undergoes standard KYC, then issues a delegation credential to their agent. The agent carries this credential — an ACK-ID — which proves it's authorized to act on behalf of a verified entity.
This is the KYA (Know Your Agent) pattern. It extends KYC to the agentic layer without requiring agents themselves to have legal personhood. The ACK-ID is a W3C Verifiable Credential, meaning it's interoperable with existing identity infrastructure and can be verified without contacting the issuer.
At Stage 2 (Identity), ACK performs the credential check before any transaction can proceed. This is a gate — it blocks if the credential is invalid, expired, or revoked. The gate fires at the middleware layer (L4), which means it's infrastructure-level, not application-level. Any application built on ACK inherits this identity gate automatically.
Architecture
How ACK extends x402.
ACK and x402 are complementary protocols with minimal overlap. ACK handles the first two stages — Intent (Stage 1, implicit through agent delegation) and Identity (Stage 2, ACK-ID credential verification). x402 picks up at Stage 3 (Discovery) and carries through to Stage 8 (Finality).
The handoff happens at Stage 3: once ACK has verified the agent's identity and authorization, the agent proceeds to discover x402-gated resources through standard HTTP. From that point forward, x402's HTTP header exchange handles negotiation, transport, authorization, facilitation, and finality.
This separation of concerns is deliberate. ACK doesn't need to know how payments work — it only needs to verify that the agent is who it claims to be. x402 doesn't need to know how identity works — it only needs to receive a valid payment signature. The two protocols compose cleanly because they operate on different stages of the lifecycle.
The combined pattern gives full lifecycle coverage: agent identity verification (ACK at S2) → service discovery (x402 at S3) → payment negotiation (x402 at S4) → header transport (x402 at S5) → cryptographic authorization (x402 at S6) → on-chain facilitation (AgentKit/CDP at S7) → Base L2 finality (S8).
Stack view
Base compliance stack with ACK.
ACK-specific mechanisms live at L4 (Middleware) alongside x402 Worker and CCTP. The AgentKit OFAC/KYT monitor is the ACK identity gate — policy-enforced at the middleware layer.