DCP is one app that controls how AI agents use wallets, credentials, identity, and private data. Agents get access inside rules you set. You stay in control.

Is DCP only a wallet?

No. DCP can work as a wallet control surface for agents, but it also controls credentials, identity, private data, remote-agent access, limits, approvals, and logs.

Do agents ask me for everything?

No. You set rules once. Actions inside those rules run automatically. Only exceptions ask for approval.

Where are my keys stored?

On your machine. DCP is local-first. Wallet keys stay in your local vault, not inside the agent and not on our servers.

Can I use DCP with multiple agents?

Yes. Each agent gets its own rules, limits, approvals, and logs, all from one dashboard.

Can DCP work with remote agents?

Yes. Your agent can run on a VPS or cloud machine while your vault stays local. Approvals come through Desktop, Telegram, or the DCP mobile app.

What happens if an agent is compromised?

The agent can only act inside the access you gave it. You can revoke access anytime, and every action is logged.

The core is free and open source (Apache-2.0). Desktop app, agent runtime, CLI, and source code are all free.

Which blockchains does DCP support?

DCP supports Solana. You can generate a Solana wallet or import one. Keys are encrypted locally with XChaCha20. DCP is non-custodial . You control everything.

How do AI agent spending limits work?

DCP lets you set daily caps and per-action limits for each agent. If an agent tries to spend more than the limit, the action is blocked or sent to you for approval. You can adjust limits anytime.

Is DCP better than .env files for AI agents?

Yes. With .env files, agents read your keys directly. One prompt injection leaks everything. DCP keeps credentials local and runs access inside rules. Agents get results, not raw keys.

Can I store credentials like OpenAI and Anthropic keys in DCP?

Yes. Store any credential: OpenAI, Anthropic, Stripe, AWS, custom keys. Your AI agents request access, rules decide, and the agent gets results, never the raw key.

Does DCP work with Claude, Cursor, and OpenClaw?

Yes. Claude Desktop, Cursor, VS Code, and other stdio MCP clients can run the DCP agent locally. OpenClaw and VPS agents use the remote installer and HTTP MCP. Custom runtimes can integrate through MCP or HTTP MCP.

How do I secure my OpenClaw agent with DCP?

Use the remote invite command from DCP Desktop. It installs the DCP agent service on your VPS, pairs it with your Desktop vault, and configures OpenClaw MCP when the install shape can be detected.

Is MCP server security a problem in 2026?

Yes. MCP servers have known vulnerabilities. Over 42,000 exposed endpoints leaked credentials in early 2026, including CVE-2025-6514 (remote code execution). DCP adds a control layer: even if your MCP server is compromised, agents can't use raw keys outside your rules.

How is DCP different from Infisical or VaultAgent?

DCP is local-first (keys never leave your device) and controls how agents use them. Infisical and VaultAgent are cloud-based secret stores. DCP also handles crypto wallets, which they don't. And DCP is free & open source.

How is DCP different from Turnkey or Cobo agentic wallet?

DCP is free and handles both crypto AND credentials. Turnkey and Cobo are enterprise-only, crypto-only, and Cobo holds a key share (MPC). DCP is fully non-custodial and local-first . You control everything.

What if my laptop is off?

Requests queue until you're back online. For 24/7 bots, just leave your laptop sleeping. No need to be unlocked.

Yes. The entire stack is open source under Apache-2.0. Self-host the relay if you want full control over your infrastructure.

Export your data, uninstall. Your wallets, keys, everything stays yours. No lock-in, no data hostage.

Can an AI agent pay for APIs without my private key?

Yes. The agent requests an x402 / USDC payment, DCP checks your daily cap, auto-approves small ones and asks your phone for the rest, then signs locally. The agent gets a paid result, and never sees the private key.

How is DCP different from Coinbase Agentic Wallet, Cobo, or Turnkey?

Those give the agent its own wallet or account. DCP is non-custodial: it keeps your existing wallet's key encrypted on your machine and lets the agent request to use it inside your rules. The agent receives a signed result, never the raw key.

Is DCP an MCP permission server?

Yes. Give your agent a DCP tool over MCP instead of raw secrets. It runs sensitive actions (sign, pay, use a scoped credential, read approved data) with task-scoped access, approval for exceptions, and logs. Works with the OpenAI Agents SDK, LangGraph, CrewAI, Claude, Cursor, and OpenClaw.

MCP Tools Reference

Integrations should call DCP through MCP. The HTTP endpoint is streamable HTTP MCP; it is not a general REST API.

Endpoint

dcp-agent run --mode http-mcp --host 127.0.0.1 --port 8420
http://127.0.0.1:8420/mcp

Initialize With curl

curl -i -sS \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -X POST http://127.0.0.1:8420/mcp \
  --data '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"dcp-client","version":"1.0.0"}}}'

Copy the returned mcp-session-id.

List Tools

curl -i -sS \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -H 'mcp-session-id: PASTE_SESSION_ID_HERE' \
  -X POST http://127.0.0.1:8420/mcp \
  --data '{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}'

Tools

Tool	Required input	Optional input
`vault_get_address`	`chain: "solana"`
`vault_budget_check`	`amount`, `currency`	`chain: "solana"`
`vault_scope_guide`
`vault_read`	`scope`	`fields`
`vault_write`	`scope`, `data`
`vault_sign_tx`	`chain: "solana"`, `unsigned_tx`	`description`, `amount`, `currency`, `destination`, `idempotency_key`
`vault_sign_message`	`chain: "solana"`, `message`	`encoding`, `description`
`vault_sign_x402`	`network: "solana"`, `payload`	`amount`, `currency`, `recipient`, `purpose`
`vault_transfer`	`chain: "solana"`, `to`, `amount`	`currency`, `mint`, `decimals`, `confirm`, `description`, `idempotency_key`
`vault_swap`	`chain: "solana"`, `from_token`, `to_token`, `amount`	`slippage_bps`, `from_decimals`, `to_decimals`, `confirm`, `description`, `idempotency_key`
`vault_get_balances`		`chain: "solana"`
`vault_get_tx_history`		`limit`, `before`, `chain`
`vault_get_tx_status`	`signature`	`chain: "solana"`
`vault_search_tokens`	`query`	`limit`

Input Rules

chain and network are currently solana.
unsigned_tx is an unsigned Solana transaction encoded as base64.
payload for vault_sign_x402 is the exact x402 payment payload encoded as base64.
encoding for vault_sign_message is utf8 or base64. Use utf8 unless the challenge is already base64.
currency can be SOL, USDC, USDT, or 1LY.
1LY SPL mint: Aih3sbAbu39Yn7jB2Qf4btZ5eWtDGQJH2gMfC4qdBAGS.
For vault_transfer, to is the destination Solana address; use currency for known tokens or mint + decimals for an arbitrary SPL token.
For vault_swap, from_token/to_token accept SOL, a symbol like USDC, or a mint address; slippage_bps defaults to 50.
confirm (transfer/swap) is confirmed (default, waits for on-chain confirmation) or submitted (returns on broadcast).
Pass a stable idempotency_key on vault_transfer/vault_swap to make retries safe (no accidental double-spend).
Use exact scopes such as identity.name, identity.email, and credentials.api.openai.

Approval Behavior

Wallet reads (address, balances, history, status, token search) return without a prompt. Writes, transaction signing, message signing, x402 signing, transfers, and swaps go through budget checks and can require approval in DCP Desktop or Telegram. Each approval is bound to the exact amount and destination you see; an approval for one transaction cannot be reused for a different one. Requests within trusted policy and budget limits may complete without another prompt.