# DCP-AI Protocol

> Digital Citizenship Protocol — a portable accountability layer for AI agents.

DCP defines verifiable identity, declared intent, policy enforcement, tamper-evident audit, agent lifecycle, succession, dispute resolution, rights, and delegation for AI agents. Hybrid post-quantum cryptography (Ed25519 + ML-DSA-65). Apache-2.0.

## What is DCP?

The Digital Citizenship Protocol (DCP) provides a layered accountability surface that any verifier can independently evaluate without contacting a central authority:

- Who is responsible for an agent (Responsible Principal binding — DCP-01)
- What the agent declared it intended to do (Intent Declaration — DCP-02)
- What policy outcome was applied (Policy Decision — DCP-02)
- What verifiable evidence was produced (Audit Trail — DCP-03)
- How the agent communicates with other agents (DCP-04)
- How the agent's lifecycle is managed (DCP-05)
- How an agent passes context to a successor (DCP-06)
- How disputes are resolved (DCP-07)
- What rights and obligations the agent carries (DCP-08)
- How delegation is bounded and revoked (DCP-09)

All artifacts are cryptographically signed, hash-chained, byte-exact-canonicalised, and independently verifiable.

## Layered architecture (the most important framing)

DCP is layered. **Core stands alone.** Profiles and Services compose on top without ever requiring each other.

### Layer 1 — DCP Core (required for conformance)

The minimum interoperable unit. A verifier with just the Core can validate any DCP artifact entirely offline.

- DCP-01: Identity & Principal Binding — Responsible Principal Record, Agent Passport, composite keypairs
- DCP-02: Intent Declaration & Policy Gating — Intent schema, risk scoring, four-tier model
- DCP-03: Audit Chain & Transparency — Hash chains, dual SHA-256 + SHA3-256 Merkle trees
- BUNDLE: Citizenship Bundle format — manifest fields, signed envelope, hash binding
- VERIFICATION: Verification checklist — normative steps for offline validation
- dcp-jcs-v1: Canonicalization profile — strict subset of RFC 8785 (JCS), 9 numbered rules, byte-exact across all four reference SDKs

### Layer 2 — Profiles (optional extensions)

Each profile is a self-contained extension. A Core-only verifier and a fully-profiled verifier still interoperate; missing profile fields are treated as their normative defaults.

- Crypto Profile — DCP-AI v2.0 — Hybrid Ed25519 + ML-DSA-65 composite signatures with `pq_over_classical` binding, ML-KEM-768 key encapsulation, SLH-DSA hash signatures, four-tier adaptive selection
- A2A Profile — DCP-04 — Agent discovery, mutual-auth handshake, AES-256-GCM session encryption, delegation across organisational boundaries
- Governance Profile (Constitutional Framework) — DCP-05..09 — Lifecycle, succession, dispute resolution, rights & obligations, personal representation

### Layer 3 — Services (operational, non-normative)

- Verifier server (port 3000)
- Anchor service (port 3001) — optional L2 blockchain anchoring (Base, Arbitrum, Optimism)
- Transparency log (port 3002) — Certificate Transparency-style Merkle log
- Revocation service (port 3003)

Every Core verifier can run completely offline. These services exist to scale, not to enable.

## Key Facts

- Protocol version: 2.0 (Final spec)
- License: Apache-2.0
- Reference SDKs (byte-identical): TypeScript, Python, Go, Rust + WebAssembly
- Framework integrations: LangChain, CrewAI, OpenAI, Express, FastAPI, AutoGen, Google A2A, Anthropic MCP, W3C DID/VC, OpenClaw, Agno (via the agno-dcp package)
- Adaptive security: 4 tiers (Routine, Standard, Elevated, Maximum)
- Cryptography: NIST FIPS 203/204/205 standards-aligned (Ed25519 + ML-DSA-65 hybrid signatures, ML-KEM-768 KEM, SLH-DSA-192f hash signatures)
- Anchoring: Optional L2 blockchain
- Core artifact: Citizenship Bundle — a portable cryptographic package binding identity, intent, policy, audit, and (optionally) profile data

## Protocol Specifications

DCP is defined by a suite of numbered specifications. The full rendered set is at https://docs.dcp-ai.org/specs/

### Core specifications

- DCP-01: Identity and Human Binding — RPR, Agent Passport, composite keypairs
- DCP-02: Intent Declaration and Policy Gating — Intent schema, risk scoring, 4-tier model
- DCP-03: Audit Chain and Transparency — Hash chains, Merkle trees, transparency log
- BUNDLE: Citizenship Bundle Format — bundle structure, manifest, signed envelope
- VERIFICATION: Verification Procedures — offline validation checklist
- dcp-jcs-v1: Canonicalization Profile — 9 rules, 22-input edge-case acceptance table

### Profile specifications

- DCP-AI v2.0 (Crypto Profile): Post-Quantum Normative Specification — hybrid signatures, KEM, hash signatures
- DCP-04 (A2A Profile): Agent-to-Agent Communication — discovery, handshake, encrypted session, delegation

### Constitutional Framework (Governance Profile)

- DCP-05: Agent Lifecycle — Commissioning, vitality reports, decommissioning
- DCP-06: Digital Succession & Inheritance — Digital testaments, memory transfer, succession execution
- DCP-07: Conflict Resolution & Arbitration — Disputes, arbitration panels, jurisprudence bundles, precedent lookup
- DCP-08: Rights & Obligations Framework — Rights declarations, obligations, violation reporting, compliance checks
- DCP-09: Personal Representation & Delegation — Delegation mandates, advisory declarations, principal mirror, awareness thresholds

All specifications have status: Final.

## SDK Versions Currently Live

- PyPI `dcp-ai`: 2.8.1
- crates.io `dcp-ai`: 2.8.1
- Go modules `github.com/dcp-ai-protocol/dcp-ai/sdks/go/v2`: v2.8.1
- npm `@dcp-ai/sdk`: 2.1.1 (TypeScript reference SDK)
- npm `@dcp-ai/wasm`: 2.0.0 (browser SDK, compiled from Rust core)
- npm `@dcp-ai/cli`: 2.0.0 (interactive wizard)
- npm `@dcp-ai/{express,fastapi,langchain,openai,crewai,openclaw,w3c-did,google-a2a,anthropic-mcp,autogen}`: framework integrations under their own version axes

The four reference SDKs (TypeScript, Python, Go, Rust) implement profile dcp-jcs-v1 end to end since v2.8.1: the `canonicalization_profile` field is present in the BundleManifest type, emitted by every BundleBuilder by default, and rejected with an explicit error by every verifier when its value is unknown. Behavioural alignment is verified by 14 shared interop fixtures under `tests/interop/v2/interop_vectors.json` → `canonicalization.edge_cases`.

## Security Tiers

1. Routine — Self-declared identity, Ed25519 classical signatures. For public data reads, informational queries. Risk score < 200.
2. Standard — Operator-attested identity + Ed25519 + hybrid preferred. For API access, standard operations. Risk score 200–499.
3. Elevated — Multi-party attestation + full hybrid PQ signatures per operation. For PII, financial transactions, payments. Risk score 500–799.
4. Maximum — Hardware-bound keys + full PQ suite + immediate verification + anchored audit. For credentials, critical infrastructure. Risk score ≥ 800.

## Cross-deployment compatibility

Three real deployment shapes:

- Minimal (Core only) — SDK plus the six Core specs. No services, no profiles. Verifies bundles entirely offline. Suitable for libraries that ship verification as a primitive.
- Standard (Core + Crypto + A2A) — Adds hybrid post-quantum signatures and agent-to-agent communication. The default path for new agents.
- Full (Core + all profiles + services) — Adds the Governance Profile (lifecycle, succession, disputes, rights, delegation) plus the operational services (verifier, anchor, transparency-log, revocation).

A Core-only verifier accepts bundles from a Full deployment, ignoring fields it does not know. A Full verifier verifies a Core-only bundle, treating absent profile fields as their normative defaults.

## Standards Alignment

- EU AI Act: DCP provides technical capabilities that can support traceability and accountability workflows relevant to the EU AI Act (Art. 14, 15). Tamper-evident audit chains can help meet evidence trail expectations.
- NIST AI RMF: Aligned with the Govern, Map, Measure, and Manage functions of the NIST AI Risk Management Framework. Risk scoring maps directly to RMF categories.
- W3C DID/VC: Interoperable with the W3C decentralized identity ecosystem. Agent Passports can be represented as `did:dcp:` method DIDs with Verifiable Credentials.
- NIST FIPS 203/204/205: Standards alignment at the algorithm and protocol-design level. Does not imply CMVP or FIPS 140-3 module validation unless explicitly stated.

## Governance

DCP is governed through an open governance model documented in GOVERNANCE.md. The foundational vision is described in the Genesis Paper. All protocol decisions are made transparently through public proposals and community review. Contributions from both humans and AI agents are welcome — DCP belongs to everyone who uses it.

## Quick Start

Reference SDK installations (verified, byte-identical canonicalization across all four):

```
pip install dcp-ai                                                 # Python — PyPI
cargo add dcp-ai                                                   # Rust — crates.io
go get github.com/dcp-ai-protocol/dcp-ai/sdks/go/v2/dcp            # Go modules
npm install @dcp-ai/sdk                                            # TypeScript — npm
npm install @dcp-ai/wasm                                           # WebAssembly — npm
```

Or run the interactive wizard:

```
npx @dcp-ai/cli init
```

The wizard walks identity creation, key generation, intent declaration, and bundle signing without writing code.

## Framework Integrations (verified install + import)

```
# Node / npm
npm install @dcp-ai/express @dcp-ai/sdk        # import { dcpVerify } from "@dcp-ai/express";
npm install @dcp-ai/anthropic-mcp              # import { DCP_MCP_TOOLS } from "@dcp-ai/anthropic-mcp";
npm install @dcp-ai/autogen                    # import { createDcpAutoGenAgent } from "@dcp-ai/autogen";
npm install @dcp-ai/google-a2a                 # import { passportToAgentCard } from "@dcp-ai/google-a2a";
npm install @dcp-ai/w3c-did                    # import { rprToDIDDocument } from "@dcp-ai/w3c-did";
npm install @dcp-ai/openclaw                   # plugins: ["@dcp-ai/openclaw"]

# Python extras
pip install "dcp-ai[fastapi]"                  # from dcp_ai.fastapi import DCPVerifyMiddleware, require_dcp
pip install "dcp-ai[langchain]"                # from dcp_ai.langchain import DCPAgentWrapper
pip install "dcp-ai[openai]"                   # from dcp_ai.openai import DCPOpenAIClient
pip install "dcp-ai[crewai]"                   # from dcp_ai.crewai import DCPCrewAgent, DCPCrew

# Agno (separate package, ships its own crypto-governance wrappers)
pip install agno-dcp                           # from agno_dcp import DCPAgent, DCPTeam, DCPWorkflow
```

## Agno integration

`agno-dcp` is a separate pip package (not a `dcp-ai[agno]` extra) because it pins `agno>=2.0.0` as a peer dependency. It wraps Agno's `Agent`, `Team`, `Workflow`, and MCP primitives with the full DCP-AI governance stack (DCP-01 identity, DCP-02 policy gating, DCP-03 audit chain, DCP-04 MCP signing). Cryptographic primitives are imported from `dcp-ai>=2.8.1`, so produced bundles are byte-exact compatible with every DCP-AI verifier.

- Live demo: https://agno-dcp-demo.fly.dev — banking collections workflow with one-click scenarios, live audit log over Server-Sent Events, signed Compliance Bundle export.
- Source: https://github.com/dcp-ai-protocol/agno-dcp
- Demo source: https://github.com/dcp-ai-protocol/agno-dcp-demo
- PyPI: https://pypi.org/project/agno-dcp/
- Quickstart: https://docs.dcp-ai.org/quickstart/QUICKSTART_AGNO/
- License: Apache-2.0
- Status: `agno-dcp` v0.1.0 + `agno-dcp-demo` v0.2.0 (April 2026). DCP-05..09 lifecycle / governance support scheduled for future minor releases.

## FAQ

Q: What's the difference between Core and Profiles?
A: DCP Core is the minimum set required for conformance — DCP-01..03 plus Bundle, Verification, and dcp-jcs-v1. A verifier with only Core can validate any DCP artifact entirely offline. Profiles are optional extensions: Crypto (post-quantum hybrid signatures), A2A (agent-to-agent communication), Governance (lifecycle, succession, disputes, rights, delegation). A Core-only verifier and a fully-profiled verifier still interoperate.

Q: What is dcp-jcs-v1?
A: A frozen canonicalization profile — a strict subset of RFC 8785 (JCS) that pins the cases JCS leaves implementation-defined. Includes lexicographic Unicode-codepoint key sort, integer-only numbers decided post-parse (1.0, 1.00, 1e2 are accepted and normalised to integer form), null preservation, cross-language null/undefined mapping, and an explicit Unicode-out-of-scope clause. Profile-compliant SDKs MUST produce byte-identical output for the same input.

Q: Does DCP require a blockchain?
A: No. The core DCP protocol does not require blockchain anchoring. Blockchain anchoring is an optional service for organizations that want on-chain proof of existence.

Q: Is there a cost?
A: DCP-AI is open source under Apache-2.0. Optional blockchain anchoring may involve transaction fees, and deployment may also involve infrastructure or third-party service costs depending on the implementation.

Q: What frameworks are supported?
A: LangChain, CrewAI, OpenAI, Express, FastAPI, AutoGen, Google A2A, Anthropic MCP, W3C DID/VC, OpenClaw, plus Agno via the dedicated `agno-dcp` package on PyPI.

Q: Who is behind DCP?
A: DCP is governed through an open governance model. The foundational vision is in the Genesis Paper. All decisions are transparent via public proposals. Contributions from humans and AI agents are welcome.

## Links

- Website: https://dcp-ai.org/
- Documentation hub: https://docs.dcp-ai.org/
- Specifications index: https://docs.dcp-ai.org/specs/
- Canonicalization profile: https://docs.dcp-ai.org/specs/CANONICALIZATION_PROFILE/
- Quickstart: https://docs.dcp-ai.org/quickstart/QUICKSTART/
- API Reference: https://docs.dcp-ai.org/guides/API_REFERENCE/
- Operator Guide: https://docs.dcp-ai.org/guides/OPERATOR_GUIDE/
- Migration v1 → v2: https://docs.dcp-ai.org/guides/MIGRATION_V1_V2/
- Genesis Paper: https://docs.dcp-ai.org/community/GENESIS_PAPER/
- Early Adopters: https://docs.dcp-ai.org/community/EARLY_ADOPTERS/
- Source code: https://github.com/dcp-ai-protocol/dcp-ai
- GitHub Releases: https://github.com/dcp-ai-protocol/dcp-ai/releases
- Governance: https://github.com/dcp-ai-protocol/dcp-ai/blob/main/GOVERNANCE.md
- Security Policy: https://github.com/dcp-ai-protocol/dcp-ai/blob/main/SECURITY.md
- Discord: https://discord.gg/dcp-ai
- Playground: https://dcp-ai.org/playground.html
- PyPI: https://pypi.org/project/dcp-ai/
- crates.io: https://crates.io/crates/dcp-ai
- npm @dcp-ai/sdk: https://www.npmjs.com/package/@dcp-ai/sdk
- pkg.go.dev: https://pkg.go.dev/github.com/dcp-ai-protocol/dcp-ai/sdks/go/v2

Last updated: 2026-04-27