Specification

Current Version

CKP v0.3.0 — Released March 2026, Apache 2.0 License.

The Claw Kernel Protocol is an open specification for describing, composing, and interoperating autonomous AI agents. It defines eleven primitive units that together form a complete declarative manifest for an agent’s identity, capabilities, communication surfaces, security boundaries, memory systems, predictive planning surfaces, and multi-agent coordination.

CKP is complementary to MCP (Model Context Protocol). MCP standardizes how LLM hosts discover and invoke tools. CKP standardizes how autonomous agents are assembled, secured, and orchestrated as first-class runtime entities.

Reading Order

For a complete understanding of the protocol, read the documents in this order:

Specification — This page. Architecture overview and design principles.
Primitives — The eleven building blocks (Identity through WorldModel, Swarm, and Telemetry).
URI Scheme — The claw:// addressing format.
Lifecycle — Agent state machine (INIT through STOPPED).
Transport & Wire Format — JSON-RPC 2.0 methods and error codes.
Security Model — Defense-in-depth layers and threat model.
Runtime Profile — Recommended defaults, retry semantics, transport extensions.

Design Principles

CKP is guided by seven principles:

ID	Principle	Statement
P1	Declarative Over Imperative	Agent behavior is described, not coded. A YAML/JSON manifest declares what an agent is and can do. The runtime decides how.
P2	Secure by Default	Security is not an add-on. Every primitive has built-in security surfaces. A Claw with no explicit policy runs in the most restrictive mode.
P3	MCP-Compatible	CKP’s Tool primitive is a strict superset of MCP’s tool definition. Any MCP server can be referenced as a CKP tool source.
P4	Transport-Agnostic	CKP does not mandate a specific transport. Manifests can be exchanged over stdio, HTTP, WebSocket, message queues, or filesystem.
P5	Progressive Complexity	A valid Claw manifest can be as simple as an Identity + one Provider. Every other primitive is optional and additive.
P6	Hardware-Agnostic	The same manifest targets any runtime — from a Rust binary on embedded hardware to a TypeScript process on Kubernetes.
P7	Auditable	Every primitive produces structured telemetry. Agent behavior can be traced, replayed, and audited.

The Eleven Primitives

Every CKP agent is assembled from these building blocks:

Primitive	Purpose
Identity	Who the agent is — personality, context files, autonomy level
Provider	LLM inference endpoint — protocol, auth, fallback chains
Channel	Communication surface — Telegram, Slack, CLI, webhook, voice
Tool	Executable function — MCP-compatible, sandboxed, policy-governed
Skill	Composed workflow — tools + natural-language instructions
Memory	Persistent state — conversation, semantic, key-value, workspace, checkpoint
WorldModel	Optional predictive planning — simulate futures, estimate risk and cost
Sandbox	Execution isolation — process, WASM, container, VM
Policy	Behavioral rules — allow, deny, require-approval, audit
Swarm	Multi-agent coordination — topologies, delegation, aggregation
Telemetry	Observability — exporters, sampling, redaction

Only Identity and Provider are required. Everything else is optional and additive.

Conformance Levels

CKP defines three conformance levels to accommodate the full range of implementations:

Level	Required Primitives	Target
Level 1: Core	Identity, Provider	Minimal deployments, embedded devices, simple chatbots
Level 2: Standard	Identity, Provider, Channel, Tool, Sandbox, Policy	Personal assistants, team bots, automated workflows
Level 3: Full	All 9 core primitives (`WorldModel` and Telemetry optional at all levels)	Enterprise deployments, research teams, multi-agent swarms

Architecture

                    +-------------+
                    |   Human     |
                    +------+------+
                           | interacts via
                    +------v------+
                    |  Channel(s) |
                    +------+------+
                           | routes to
                    +------v------+
                    |  Identity   |
                    +------+------+
                           | reasons with
                    +------v------+
                    |  Provider   |
                    +------+------+
                           | acts through
              +------------+------------+
              |            |            |
       +------v--+  +-----v-----+  +--v------+
       |  Tool   |  |   Skill   |  |  Swarm  |
       +----+----+  +-----+-----+  +----+----+
            |             |              |
       +----v----+  +-----v-----+  +----v----+
       | Sandbox |  |  Memory   |  | Policy  |
       +---------+  +-----------+  +---------+

Full Specification

The complete normative specification is available on GitHub:

clawkernel-spec.md — Normative specification (Sections 5-11)
clawkernel-runtime-profile.md — Informative companion document

Sections 1-4 of the specification are informative context. Appendices are informative unless explicitly marked otherwise.