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

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).

All artifacts are cryptographically signed, hash-chained, and independently verifiable — without requiring a central authority.

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

See also: Core specification | Profiles overview

Quick Start

Option A: CLI Wizard (recommended)

npx @dcp-ai/cli init

The interactive wizard (@dcp-ai/cli) walks you through identity creation, key generation, intent declaration, and bundle signing.

A lower-level reference CLI is also available as dcp (from the root dcp-ai package) for scripting and CI/CD pipelines:

npx dcp-ai verify my-bundle.signed.json

Option B: SDK directly

npm install @dcp-ai/sdk

import { BundleBuilder, KeyManager } from '@dcp-ai/sdk';

const keys = await KeyManager.generate({ algorithm: 'hybrid' });
const bundle = await new BundleBuilder()
  .setIdentity({ name: 'my-agent', operator: 'org:example' })
  .addIntent({ action: 'query', resource: 'public-api', tier: 'routine' })
  .sign(keys)
  .build();

Security Tiers

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
  PG --> WA
  TPL --> LC
  TPL --> CR
  TPL --> OA
  TPL --> EX

  EX --> VER
  FA --> VER
  VER --> ANC
  VER --> TL
  VER --> REV
  ANC --> 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.

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		A2A Agent Card ↔ DCP identity, task governance	integrations/google-a2a/
Anthropic MCP		MCP Tool ↔ DCP intent mapping, server middleware	integrations/anthropic-mcp/
AutoGen		AutoGen Agent ↔ DCP wrapper, group chat governance	integrations/autogen/

Templates

Ready-to-use project templates for common frameworks. Each template includes DCP identity, intent policies, and audit logging pre-configured.

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 using the WASM SDK.

# Open in browser
open playground/index.html

See playground/ for details.

Infrastructure Services

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

Deploy all services with one command:

cd docker && docker compose up -d

Documentation

Normative Specifications

Getting Started

API Reference

Architecture & Security

Guides

Standards Alignment

Community

Vision

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.

Repository Layout

dcp-ai-genesis/
├── spec/                    # Normative specifications (DCP-01 through DCP-09, v2.0)
│   ├── core/                # DCP Core editorial specification
│   └── profiles/            # Profile specifications (crypto, a2a, governance)
├── schemas/                 # JSON Schemas (draft 2020-12, v2 includes DCP-05–09)
├── tools/                   # Validation, conformance, crypto + Merkle helpers
├── tests/                   # Conformance tests and fixtures
├── 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)
├── 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/                    # All documentation
└── .github/                 # CI/CD workflows + reusable GitHub Actions

Development

# Install dependencies
npm install

# Run tests
npm test

# Run protocol conformance suite
npm run conformance

# 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 (v2.0.2)

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