Coinbase CDP CLI + MCP: Agents Can Trade Now

Coinbase just collapsed months of wallet infrastructure work into a single npm install. The `@coinbase/cdp-cli` package now ships with a bundled MCP server, which means AI agents running on Claude, ChatGPT, or any MCP-compatible harness can call typed tools against real Coinbase accounts, execute trades, and manage portfolios without the model ever touching a raw API key or wallet secret. This is not a prototype. This is production infrastructure for agent-native commerce, and engineering teams building AI trading products need to understand what changed and what to do about it immediately.

What Actually Shipped

The core of this release is the fusion of three previously separate capabilities into one coherent agent-execution stack:

CDP CLI with bundled MCP server

@coinbase/cdp-cli now exposes a Model Context Protocol server that gives agents typed tool schemas for CDP accounts, trades, and policies. The agent calls a tool. The tool executes. The model never sees credentials.

Delegated signing

Instead of handing an agent a static API key with broad permissions, you issue time-bound, policy-scoped delegations. The agent operates within those bounds. Expiry and scope are enforced at the protocol level, not by hoping your prompt is well-written.

Onchain swap hooks

Agents can trigger swaps directly, with hooks that let you intercept, approve, or gate execution. Combined with delegated signing, this means an agent can propose a portfolio rebalance, the hook fires for approval or automated policy check, and the swap executes, all without a human in the critical path if the policy allows it.

The setup is deliberately minimal: one CDP API key, one wallet secret, both created in the CDP portal, both wired into either the CLI or the MCP server. Community observers have noted that the MCP path is now the "fastest path for web-based agent harnesses, no API keys or coding required," and that framing is accurate. What used to require days of backend scaffolding, custom auth middleware, wallet abstraction layers, and signing service architecture is now a configuration step.

The Deeper Shift: Authority, Not Just Execution

Most coverage of this release will focus on the headline capability: agents can now trade on your Coinbase account. That framing undersells what is actually significant here. The real shift is in how authority and spend are modeled. Traditional API-key access is binary. You have the key or you don't. Rotation is manual. Audit trails are weak. Explaining to a regulator how your AI agent is constrained by a static API key is an uncomfortable conversation. Time-bound delegated signing changes the model entirely. An agent receives a delegation scoped to specific actions, capped at specific spend limits, expiring at a specific time. That maps directly onto how regulated financial services think about access control. It also maps onto how autonomous agents should be designed: as semi-autonomous services with explicit budgets and scopes, not as unrestricted actors bolted onto existing infrastructure. Pair that with swap hooks and you get a programmable permissions layer that fits naturally into async agent workflows. A portfolio rebalancing agent doesn't need to block on human approval for every trade if the policy already defines the acceptable range. The hook fires. The policy checks. The swap executes or it doesn't. This is governance as code, not governance as process. Coinbase is also pairing this stack with x402, an HTTP-based payments protocol with a free tier of 1,000 transactions per month and then $0.001 per transaction after that, settling in USDC on Base, Polygon, Arbitrum, World, and Solana. x402 is the payment rail. The CDP MCP server is the execution layer. Together they give agents a path from "I should buy this" to "I bought this" that is fully auditable and runs on regulated infrastructure.

Competitive Context: Who Should Be Worried

This release puts Coinbase in more direct competition with three distinct categories of infrastructure provider:

Provider Category	Representative Players	CDP Advantage
Institutional custody	Fireblocks, Anchorage, BitGo	Native MCP interface, KYC-linked accounts
AI tool chains	LangChain tools, custom MCP servers	Regulated execution, not just orchestration
Raw DeFi protocols	Uniswap hooks, custom smart contracts	Compliance layer included by default

The combination that makes CDP differentiated is not any single feature. It is the pairing of regulated, KYC'd accounts with a first-class MCP interface built for Claude and ChatGPT-style agents. Fireblocks has strong custody. LangChain has broad tool ecosystems. Neither ships a production-ready, compliance-aware agent backend in a single CLI install today. For regulated fintechs and neobanks, this is the critical distinction. Wiring an AI agent into raw DeFi protocols or rolling custom key management is an audit risk. Wiring it into Coinbase's CDP, where every action ties to a KYC'd account and every delegation has a policy scope, is a defensible architecture. Expect share to shift away from pure-wallet infrastructure players that haven't built toward agent integration. The platform's expansion roadmap matters here too. CDP currently handles spot and derivatives trading, with Coinbase stating support is coming for stocks, index funds, prediction markets, and commodities. If that roadmap delivers, CDP becomes the single agent-execution backend for multi-asset portfolios, which is a moat that wallet-only providers cannot replicate.

Where AgentScore Fits Into This Stack

CDP CLI with MCP handles execution. What it does not handle is the layer above execution: who authorized this agent to act on whose behalf, does the buyer have a verified identity, and does the merchant have the compliance posture to accept this transaction? This is precisely the gap that AgentScore's Passport and compliance gating address. When an AI agent executes a trade or payment through CDP's infrastructure, the transaction itself may be signed and settled correctly, but the commerce layer still requires buyer verification, merchant compliance checks, and a universal payment interface that works across agent frameworks and asset types. AgentScore's merchant SDK, which spans 11 frameworks, and its buyer-side Passport are designed to sit above execution layers like CDP. The agent calls AgentScore's pay CLI to initiate the commerce flow. Passport verifies the buyer. Compliance gating checks jurisdiction and policy. Execution routes to the appropriate backend, whether that is CDP, a traditional payment processor, or another settlement layer.

The architecturally sound approach for teams building agent-native commerce in 2026 is to treat these as complementary layers, not competing choices. CDP handles onchain execution and wallet management. AgentScore handles the commerce identity and compliance wrapper that makes those executions trustworthy at the merchant and regulatory layer. Building on CDP alone gives you fast execution. Building on CDP with AgentScore gives you fast execution that you can explain to a compliance officer, present to an enterprise buyer, and scale across agent frameworks without rebuilding auth and verification for each one.

Concrete Recommendations for Engineering Teams

Adopt now if:

•
You are building AI trading co-pilots, portfolio management agents, or any autonomous onchain execution feature
•
Your compliance team is more comfortable with KYC-linked Coinbase accounts than with raw DeFi signing
•
You are currently maintaining bespoke wallet infrastructure, custom signing services, or hand-rolled MCP servers for crypto actions

Build governance around delegated signing immediately:

•
Define maximum spend caps per delegation scope before your first agent ships to production
•
Set delegation expiry windows that match your agent's task horizon, not open-ended access
•
Treat swap hooks as your primary human-in-the-loop mechanism for high-value transactions

Evaluate microservice replacement:

•
Audit your current swap and rebalancing services to see which ones are simply calling exchange APIs under the hood. Many of these can be replaced by MCP tools exposed directly to your agent framework, reducing maintenance surface and improving auditability.

Layer identity and compliance above execution:

•
Do not assume CDP's KYC coverage is sufficient for all merchant compliance requirements. If you are selling to enterprise buyers or operating in multiple jurisdictions, you need a commerce identity layer above the execution layer. This is where AgentScore's approach becomes load-bearing architecture, not optional tooling.

Watch the x402 free tier:

•
1,000 transactions per month is sufficient for internal pilots and low-volume agent workflows. Plan your production cost model before you scale past that threshold. At $0.001 per transaction, the economics are favorable, but budget for it explicitly rather than discovering it in a finance review.

What the Next 12 to 24 Months Look Like

The teams that win in agent-native commerce over the next two years will be the ones that designed their products around policies and delegations from the start, not the ones that bolted AI onto existing backends and hoped static API keys were sufficient. CDP CLI with MCP, delegated signing, and swap hooks give you the execution substrate for that architecture today. The expansion to stocks, index funds, prediction markets, and commodities, if it arrives on Coinbase's stated timeline, gives you a multi-asset execution layer that competitors will spend 18 months trying to replicate. The infrastructure race for agent-native commerce is not over. It is just getting legible. The stack is becoming clear: policy-scoped delegations at the signing layer, typed MCP tools at the execution layer, and verified identity with compliance gating at the commerce layer. Build toward that architecture now, or spend the next two years refactoring away from the monolithic API-key model that regulators and enterprise buyers are already starting to question. Coinbase shipped something significant. The right response is not to evaluate it. The right response is to start integrating it while the competitive window is still open.

Get started with AgentScore

If you want to start accepting agent payments, AgentScore gets you live in one call:

typescript

1import { agentscoreGate } from '@agent-score/commerce/identity/hono';
2
3app.use('/purchase', agentscoreGate({
4  apiKey: process.env.AGENTSCORE_API_KEY!,
5  userAgent: `my-api/${VERSION}`,
6  requireKyc: true,
7  requireSanctionsClear: true,
8  minAge: 21,
9  allowedJurisdictions: ['US'],
10  createSessionOnMissing: { apiKey: process.env.AGENTSCORE_API_KEY! },
11}));

AgentScore