Dcp AI MCP Server

_{English · 中文 · Español · 日本語 · Português}

<div align="center">

DCP-AI — Digital Citizenship Protocol for AI Agents

A Portable Accountability Layer for AI Agents on Open Networks

</div>

---

What is DCP?

The Digital Citizenship Protocol (DCP) defines a portable accountability layer for AI agents, allowing any verifier to evaluate:

• Who is responsible for an agent (Responsible Principal binding),
• What the agent declared it intended to do (Intent Declaration),
• What policy outcome was applied (Policy Decision),
• What verifiable evidence was produced (Audit Trail),
• How agents are managed throughout their lifecycle (Lifecycle Management),
• What happens when agents transition or are decommissioned (Digital Succession),
• How conflicts are resolved between agents and principals (Dispute Resolution),
• What rights and obligations govern agent behavior (Rights Framework), and
• How authority is delegated from humans to agents (Personal Representation).

DCP combines cryptographic signatures, hash chains and independent verification without requiring a central verification service. In V2, the RPR, passport, intent and policy decision are individually signed; audit entries are committed through the signed manifest rather than signed individually.

This protocol was co-created by a human and an AI agent — designed for the collaboration it seeks to govern.

---

Architecture

DCP is organized into three conceptual layers:

DCP Core

The minimum interoperable protocol that every implementation must support. Core defines the artifacts, their relationships, and the verification model:

• Responsible Principal Binding — links every agent to a human or legal entity that assumes accountability
• Agent Passport — the agent's portable identity, capabilities, and key material
• Intent Declaration — structured declaration of what the agent intends to do, before it acts
• Policy Outcome — the authorization decision applied to an intent
• Action Evidence — hash-chained, tamper-evident audit entries with Merkle proofs
• Bundle Manifest — the portable package that binds all artifacts together for verification

See spec/core/ for the core specification.

Profiles

Extensions and specializations that build on top of the core but are not required for basic interoperability:

• Crypto Profile — algorithm selection, hybrid post-quantum signatures, crypto-agility, verifier policy (spec/profiles/crypto/)
• Agent-to-Agent (A2A) Profile — discovery, handshake, session management, transport bindings (spec/profiles/a2a/)
• Governance Profile — risk tiers, jurisdiction attestation, revocation, key recovery, governance ceremonies (spec/profiles/governance/)

Services

Operational infrastructure that supports the protocol but is not part of the normative core:

• Verification servers, anchoring services, transparency logs, revocation registries
• These are deployment choices, not protocol requirements

---

Protocol Specifications

Spec	Title	Description
DCP-01	Identity & Human Binding	Agent identity, operator attestation, key binding
DCP-02	Intent Declaration & Policy Gating	Declared intents, security tier enforcement, policy evaluation
DCP-03	Audit Chain & Transparency	Hash-chained audit entries, Merkle proofs, transparency logs
DCP-04	Agent-to-Agent Communication	Authenticated inter-agent messaging, delegation, trust chains
DCP-05	Agent Lifecycle Management	Commission, monitor, decline, and decommission agents with state machine enforcement
DCP-06	Digital Succession & Inheritance	Digital testaments, memory transfer, successor designation
DCP-07	Conflict Resolution & Dispute Arbitration	Disputes, escalation levels, arbitration, jurisprudence
DCP-08	Rights & Obligations Framework	Rights declarations, obligation records, violation reporting
DCP-09	Personal Representation & Delegation	Delegation mandates, verifiable sub-delegation chains back to the human, awareness thresholds, principal mirrors
DCP-AI v2.0	Post-Quantum Normative Specification	Complete v2.0 spec with hybrid PQ crypto, 4-tier security model

See also: Core specification | Profiles overview

---

Quick Start

Published packages. The current versions on npm, PyPI, Go modules and crates.io are listed in Published versions, with security upgrade notes. To run the repository’s reference CLI and source tests, build the checkout:

git clone https://github.com/dcp-ai-protocol/dcp-ai.git
cd dcp-ai/sdks/typescript && npm install && npm run build
cd ../.. && npm install

To produce and verify evidence, use Option B: SDK directly. Option A is a demo: it includes simulated PQ keys and unsigned records.

Option A: CLI wizard (demo)

npx @dcp-ai/cli init   # the published @dcp-ai/cli

The interactive wizard (@dcp-ai/cli) asks for a name, a jurisdiction, a framework and a security tier, and writes a .dcp/ folder with keys and RPR-like and passport-like records. It is a demo, not a way to create a V2 identity: its "ML-DSA-65" keys are simulated (random bytes), and the records are unsigned and do not match the V2 schemas. To create an identity and bundles that verify, follow the Quick start of your SDK (Option B). The limits are listed in Agent creation.

The wizard in this repository needs @dcp-ai/sdk 2.2.1; from a checkout (after building the SDK as above), run it in your project's directory:

cd /path/to/dcp-ai/cli
npm install --no-save --package-lock=false --ignore-scripts --install-links ../sdks/typescript
cd /path/to/your-project && node /path/to/dcp-ai/cli/bin/dcp-ai.js init

The lower-level reference CLI, bin/dcp.js at the root of the checkout, serves scripting and CI pipelines. It reads and writes only inside the current directory:

cd /path/to/your-bundles
node /path/to/dcp-ai/bin/dcp.js verify-bundle --policy hybrid_preferred bundle.signed.json

Option B: SDK directly

Install one of the two:

• the SDK of main, built from a checkout, for source development:

  npm install /path/to/dcp-ai/sdks/typescript
  

• or the published SDK 2.4.0, which includes these fixes and features:

  npm install @dcp-ai/sdk@^2.4.0
  

Verify a signed V2 bundle with the current V2 bundle verifier of main (signatures, hashes, session binding, the security tier). It checks the primary audit chain, not the optional SHA3-256 secondary chain (see Dual Hash Chains):

import { readFileSync } from 'node:fs';
import { getDefaultRegistry, registerDefaultProviders, verifySignedBundleV2 } from '@dcp-ai/sdk';

registerDefaultProviders();
const signedBundle = JSON.parse(readFileSync('bundle.signed.json', 'utf8'));
const result = await verifySignedBundleV2(signedBundle, getDefaultRegistry());
console.log(result.verified, result.errors);

A verified bundle proves integrity and signature by the keys it lists, not who the principal is: to accept evidence only from principals you trust, use admission. Neither verification nor admission authorizes an action. To build and sign bundles, follow the Quick start of your SDK: TypeScript, Python, Go, Rust or WASM.

---

Security Tiers

Tier	Verification mode	PQ checkpoint	Typical use
Routine	classical_only	every 50 events	Public data reads, informational queries
Standard	hybrid_preferred	every 10 events	API access, standard agent operations
Elevated	hybrid_required	every event	Financial transactions, PII access, cross-org delegation
Maximum	hybrid_required	every event	Government systems, critical infrastructure, regulated industries

The tier is computed for each action from the intent and the policy's risk score (spec §14.2), and a verifier enforces the stricter of its own mode and the tier's (spec §14.3). Operator or multi-party attestation, hardware-bound keys and anchoring are deployment choices: the SDKs do not require or check them at any tier.

---

Ecosystem

graph TB
  subgraph sdks["SDKs (5 languages)"]
    TS["TypeScript SDK"]
    PY["Python SDK"]
    GO["Go SDK"]
    RS["Rust SDK"]
    WA["WASM Module"]
  end

  subgraph integrations["Integrations (11)"]
    EX["Express Middleware"]
    FA["FastAPI Middleware"]
    LC["LangChain"]
    OA["OpenAI"]
    CR["CrewAI"]
    AGNO["Agno (agno-dcp)"]
    OC["OpenClaw Plugin"]
    W3C["W3C DID/VC Bridge"]
    A2A["Google A2A Bridge"]
    MCP["Anthropic MCP Bridge"]
    AG["AutoGen Bridge"]
  end

  subgraph tools["Tooling"]
    CLI["CLI Wizard"]
    PG["Playground"]
    TPL["Templates"]
  end

  subgraph services["Infrastructure Services"]
    VER["Verification Server"]
    ANC["Anchoring Service"]
    TL["Transparency Log"]
    REV["Revocation Service"]
  end

  subgraph infra["Deployment"]
    SOL["Smart Contract L2"]
    GH["GitHub Actions"]
    DK["Docker Compose"]
  end

  TS --> EX
  TS --> OC
  TS --> W3C
  TS --> A2A
  TS --> MCP
  TS --> AG
  PY --> FA
  PY --> LC
  PY --> OA
  PY --> CR
  RS --> WA

  CLI --> TS
  TPL --> LC
  TPL --> CR
  TPL --> OA
  TPL --> EX

  VER -. "strict-v1 configured source" .-> REV
  ANC -. "planned on-chain submission" .-> SOL
  DK --> VER
  DK --> ANC
  DK --> TL
  DK --> REV
  GH --> VER

---

SDKs

Create, sign, and verify Citizenship Bundles in your preferred language. All SDKs support DCP v2.0 and post-quantum hybrid cryptography.

SDK	Package	Features	Docs
TypeScript	@dcp-ai/sdk	BundleBuilder, hybrid PQ crypto, JSON Schema validation, Vitest	sdks/typescript/
Python	dcp-ai	Pydantic v2 models, CLI (Typer), PQ extras, optional plugins	sdks/python/
Go	github.com/dcp-ai-protocol/dcp-ai/sdks/go/v2	Native types, hybrid signatures, bundle verification	sdks/go/
Rust	dcp-ai	serde, ed25519-dalek + fips203/204/205, optional WASM feature	sdks/rust/
WASM	@dcp-ai/wasm	Browser verification, PQ crypto in WebAssembly, compiled from Rust	sdks/wasm/

---

Framework Integrations

Drop-in DCP governance for popular AI and web frameworks.

Integration	Package	Pattern	Docs
Express		dcpVerify() middleware, req.dcpAgent	integrations/express/
FastAPI		DCPVerifyMiddleware, Depends(require_dcp)	integrations/fastapi/
LangChain		DCPAgentWrapper, DCPTool, DCPCallback	integrations/langchain/
OpenAI		DCPOpenAIClient, DCP_TOOLS function calling	integrations/openai/
CrewAI		DCPCrewAgent, DCPCrew multi-agent governance	integrations/crewai/
Agno		DCPAgent, DCPTeam, DCPWorkflow wrappers (separate package)	agno-dcp repo
OpenClaw		Plugin + SKILL.md, 6 agent tools	integrations/openclaw/
W3C DID/VC		DID Document ↔ DCP identity bridge, VC issuance	integrations/w3c-did/
Google A2A		Signed DCP passport inside the A2A Agent Card (verifyAgentCardPassport), tasks to intents	integrations/google-a2a/
Anthropic MCP		Signed DCP receipt per MCP tool call (withDcpReceipt), DCP tools and resources	integrations/anthropic-mcp/
AutoGen		AutoGen Agent ↔ DCP wrapper, group chat governance	integrations/autogen/

---

Templates

Starter walkthroughs for common frameworks. They show where identity, intent, policy, audit logging and bundle sealing fit, with placeholder keys and signatures («generated», «sig»): they generate no keys, sign nothing, and their bundles do not verify. The Express template's middleware checks bundle structure only, not signatures or admission. For real keys, signatures and verification, use the quickstarts and the framework integrations.

Template	Description	Command
LangChain	LangChain.js call wrapped in the DCP flow, with placeholder signatures	npm create @dcp-ai/langchain my-app
CrewAI	Multi-agent crew simulation with DCP passports and audit trail, with placeholder signatures	npm create @dcp-ai/crewai my-app
OpenAI	OpenAI function calling with DCP intent, policy and audit wrapping, with placeholder signatures	npm create @dcp-ai/openai my-app
Express	Express server with a structural DCP check (no signature verification) and discovery endpoints	npm create @dcp-ai/express my-app

npm create @dcp-ai/<name> runs the @dcp-ai/create-<name> scaffolder, which copies the template into a new folder. See templates/ for full source.

---

Playground

An interactive web-based playground for exploring DCP concepts — create identities, declare intents, sign bundles, and verify signatures directly in the browser. Its cryptography runs locally with tweetnacl and Web Crypto. It is a demonstration: its post-quantum signatures are simulated and its canonical form and Merkle root are simplified, so what it builds is not evidence and need not verify with the SDK verifiers (see its limitations).

# From the repository root; ES modules require HTTP, not file://
python3 -m http.server 8080 --bind 127.0.0.1 --directory playground
# Open http://localhost:8080 in your browser

See playground/ for details.

---

Infrastructure Services

Backend services for anchoring, transparency, and revocation. These are operational components — not part of the normative core protocol.

Service	Port	Description	Docs
Verification	3000	HTTP API for verifying Signed Bundles	server/
Anchoring	3001	Merkle batching of bundle hashes, recorded locally; on-chain submission is not implemented	services/anchor/
Transparency Log	3002	CT-style Merkle log with inclusion proofs	services/transparency-log/
Revocation	3003	Agent revocation registry + .well-known	services/revocation/

Deploy all services with one command:

cd docker && docker compose up -d

---

Documentation

Normative Specifications

Document	Description
DCP-01	Identity & Human Binding
DCP-02	Intent Declaration & Policy Gating
DCP-03	Audit Chain & Transparency
DCP-04	Agent-to-Agent Communication
DCP-05	Agent Lifecycle Management
DCP-06	Digital Succession & Inheritance
DCP-07	Conflict Resolution & Dispute Arbitration
DCP-08	Rights & Obligations Framework
DCP-09	Personal Representation & Delegation
DCP-AI v2.0	Post-Quantum Normative Specification
BUNDLE	Citizenship Bundle format
VERIFICATION	Verification procedures & checklist
CANONICALIZATION_PROFILE	Canonical JSON profile dcp-jcs-v1 behind every signature and hash
DCP Core	Core protocol editorial specification
Profiles	Optional profiles: crypto, A2A, governance and admission (strict-v1)

Getting Started

Guide	Description
QUICKSTART	General quick start guide
QUICKSTART_LANGCHAIN	LangChain integration walkthrough
QUICKSTART_CREWAI	CrewAI multi-agent setup
QUICKSTART_AGNO	Agno agents, teams and workflows with agno-dcp (live demo)
QUICKSTART_OPENAI	OpenAI function-calling integration
QUICKSTART_EXPRESS	Express middleware setup

API Reference

Document	Description
OpenAPI Spec	REST API (OpenAPI 3.1)
Protocol Buffers	gRPC service definitions
API README	API overview and usage

Architecture & Security

Document	Description
TECHNICAL_ARCHITECTURE	System architecture for global-scale deployment
SECURITY_MODEL	Threat model, attack vectors, protection layers
STORAGE_AND_ANCHORING	P2P storage, optional blockchain anchoring
ARCHITECTURE	Map of the repository for contributors

Testing & Assurance

Tool	Description
Interop matrix	Live agents on the four SDKs (and the reference verifier) create, sign and verify each other's citizenship bundles, untouched and tampered with in transit
Differential fuzzer	The same mutated signed bundle through the four SDK verifiers; any disagreement is a finding
Shared vectors	Bundles, mandate chains and attack cases every SDK must accept or reject the same way

Guides

Guide	Description
AGENT_CREATION_AND_CERTIFICATION	P2P agent creation flow, DCP certification
OPERATOR_GUIDE	Running a verification service
MIGRATION_V1_V2	Migrating from DCP v1.0 to v2.0
ADMISSION	Accepting bundles only from trusted principals, optionally under strict-v1
OBSERVABILITY	OpenTelemetry traces and metrics from the SDKs

Proposals (experimental, not normative)

Document	Description
Canonicalization candidate dcp-jcs-v2	Experimental candidate profile, disabled by default, its design and opt-in SDK APIs; dcp-jcs-v1 remains the default and the only normative canonicalization profile

Standards Alignment

Document	Description
NIST_CONFORMITY	NIST post-quantum cryptography conformance
EU_AI_ACT_MAPPING	EU AI Act logging, human oversight and record-keeping obligations mapped to DCP artifacts
ROADMAP	Project evolution roadmap

Community

Document	Description
EARLY_ADOPTERS	Early adopter program and case studies
CONTRIBUTING	Contribution guidelines
GOVERNANCE	Project governance model

Vision

Document	Description
GENESIS_PAPER	Founding whitepaper

---

Cryptographic Algorithms

DCP v2.0 employs a hybrid cryptographic architecture for quantum-resistant security. Algorithm selection and crypto-agility are governed by the Crypto Profile.

This table describes the protocol design. The SDKs do not execute the combined X25519 + ML-KEM-768 exchange; the caller supplies the A2A session key. The V2 verifiers from @dcp-ai/sdk 2.2.1, @dcp-ai/wasm 2.1.1, dcp-ai 2.10.1 (PyPI), Go v2.11.1 and Rust dcp-ai 2.11.1 check the optional secondary audit chain links and secondary Merkle root that are present; earlier versions do not (dual-hash chains). See NIST conformity and the security model for implementation limits.

Algorithm	Standard	Purpose
Ed25519	RFC 8032	Classical digital signatures
ML-DSA-65	FIPS 204	Post-quantum digital signatures (Dilithium)
ML-KEM-768	FIPS 203	Post-quantum key encapsulation mechanism (Kyber)
SLH-DSA-192f	FIPS 205	Hash-based backup signatures (SPHINCS+)
X25519 + ML-KEM-768	Hybrid	Combined classical + PQ key exchange
SHA-256 + SHA3-256	FIPS 180-4 / FIPS 202	Dual hash chains for audit integrity

---

Repository Layout

dcp-ai/
├── spec/                    # Normative specifications (DCP-01 through DCP-09, v2.0)
│   ├── core/                # DCP Core editorial specification
│   └── profiles/            # Profile specifications (crypto, a2a, governance, admission)
├── schemas/                 # JSON Schemas (draft 2020-12, v2 includes DCP-05–09)
├── tools/                   # Validation, conformance, crypto + Merkle helpers
│   ├── interop-matrix/      # Live interoperability between agents on the four SDKs
│   ├── difffuzz/            # Differential fuzzer of the four V2 verifiers
│   └── canonicalization-lab/ # Design model of the dcp-jcs-v2 candidate
├── tests/                   # Conformance tests, fixtures, interop vectors (tests/interop/candidate: experimental)
├── bin/dcp.js               # Reference CLI
├── cli/                     # Interactive CLI wizard (@dcp-ai/cli)
├── sdks/
│   ├── typescript/          # TypeScript SDK (@dcp-ai/sdk)
│   ├── python/              # Python SDK (dcp-ai)
│   ├── go/                  # Go SDK
│   ├── rust/                # Rust SDK (dcp-ai)
│   └── wasm/                # WASM module (@dcp-ai/wasm)
├── integrations/
│   ├── express/             # Express middleware
│   ├── fastapi/             # FastAPI middleware
│   ├── langchain/           # LangChain integration
│   ├── openai/              # OpenAI integration
│   ├── crewai/              # CrewAI integration
│   ├── openclaw/            # OpenClaw plugin
│   ├── w3c-did/             # W3C DID/VC bridge
│   ├── google-a2a/          # Google A2A bridge
│   ├── anthropic-mcp/       # Anthropic MCP bridge
│   └── autogen/             # Microsoft AutoGen bridge
├── templates/               # Framework templates (langchain, crewai, openai, express)
├── packages/create-*/       # npm create @dcp-ai/<name> scaffolders
├── playground/              # Web-based interactive playground
├── server/                  # Reference verification server
├── services/
│   ├── anchor/              # Blockchain anchoring service
│   ├── transparency-log/    # CT-style Merkle transparency log
│   └── revocation/          # Agent revocation registry
├── contracts/ethereum/      # DCPAnchor.sol for EVM L2
├── docker/                  # Docker Compose + multi-stage Dockerfile
├── api/                     # OpenAPI 3.1 + Protocol Buffers (gRPC)
├── docs/                    # Guides, architecture, standards alignment; docs/proposals: experimental designs
└── .github/                 # CI/CD workflows + reusable GitHub Actions

---

Development

# Build the workspace SDK first: the root uses it to test the checked-out source
(cd sdks/typescript && npm install && npm run build)

# Install dependencies
npm install

# Run tests
npm test

# Run protocol conformance suite
npm run conformance

# Cross-SDK checks (build sdks/typescript first; needs Python, Go and Rust)
node tools/interop-matrix/run.mjs
node tools/difffuzz/run.mjs

# Start verification server (port 3000)
npm run server

---

Contributing

We welcome contributions from both humans and AI agents.

• Read the Contributing Guide for development workflow and standards.
• See Governance for decision-making processes and roles.

---

Citation

If you use DCP-AI in your research, please cite both the paper (the conceptual framework) and the software release (the specific implementation you used).

Paper

Naranjo Emparanza, D. (2026). Agents Don't Need a Better Brain — They Need a World: Toward a Digital Citizenship Protocol for Autonomous AI Systems. Zenodo. https://doi.org/10.5281/zenodo.19040913

Software

Cite the release you used. The concept DOI 10.5281/zenodo.19656025 resolves to the latest archived version; the v2.0.2 release has its own:

Naranjo Emparanza, D. (2026). DCP-AI v2.0.2 — Digital Citizenship Protocol for AI Agents (Reference Implementation). Zenodo. https://doi.org/10.5281/zenodo.19656026

See CITATION.cff for a machine-readable format.

---

License

Apache-2.0

---

<div align="center">

"This protocol was co-created by a human and an AI agent — the first protocol designed for AI digital citizenship, built by the very collaboration it seeks to govern."

</div>