Architecture

CKP organizes agent capabilities into 11 primitives. This page explains how those primitives relate to each other, how data flows through an agent, and how the dependency graph determines what is required at each conformance level.

Conceptual model

The flow from human interaction to agent execution follows a clear path through the primitives:

                    ┌─────────────┐
                    │   Human     │
                    └──────┬──────┘
                           │ interacts via
                    ┌──────▼──────┐
                    │  Channel(s) │  Telegram, Slack, CLI, Webhook, Voice...
                    └──────┬──────┘
                           │ routes to
                    ┌──────▼──────┐
                    │  Identity   │  Who am I? What do I know? What is my purpose?
                    └──────┬──────┘
                           │ reasons with
                    ┌──────▼──────┐
                    │  Provider   │  Claude, GPT, Gemini, Ollama, local model...
                    └──────┬──────┘
                           │ acts through
              ┌────────────┼────────────┐
              │            │            │
       ┌──────▼──┐  ┌─────▼─────┐  ┌──▼──────┐
       │  Tool   │  │   Skill   │  │  Swarm  │
       └────┬────┘  └─────┬─────┘  └────┬────┘
            │             │              │
       ┌────▼────┐  ┌─────▼─────┐  ┌────▼────┐
       │ Sandbox │  │  Memory   │  │ Policy  │
       └─────────┘  └─────┬─────┘  └─────────┘
                          │
                    ┌─────▼─────┐
                    │WorldModel │
                    └───────────┘

A human reaches the agent through a Channel (Telegram, Slack, CLI, voice, or any of 16 supported types). The message is routed to the agent’s Identity, which defines its personality, context, and autonomy level. The agent reasons about the input using a Provider (any LLM endpoint — Claude, GPT, Ollama, or a local model).

When the agent needs to act, it has three pathways:

• Tool — execute an atomic function (file I/O, web fetch, API call)
• Skill — run a composed workflow built from multiple tools, guided by natural-language instructions
• Swarm — delegate work to other agents in a coordinated topology

These execution paths are governed by supporting primitives:

• Sandbox constrains where and how tools execute (process isolation, container, WASM, network restrictions)
• Memory persists information across sessions (conversations, semantic search, key-value stores, workspaces, checkpoints)
• WorldModel predicts bounded futures before action (simulation, risk, cost, or observation rollouts)
• Policy enforces behavioral rules (allow, deny, require-approval, audit-only)

The eleventh primitive, Telemetry, sits alongside all others — it observes and exports structured events from any primitive without affecting behavior.

Dependency graph

The manifest dependency graph makes the relationships between primitives explicit:

Claw Manifest (claw.yaml)
├── Identity (required)
├── Provider (required, at least one)
├── Channel (optional, at least one for interactive use)
├── Tool[] (optional)
│   ├── references → Sandbox
│   └── references → Policy
├── Skill[] (optional)
│   └── composes → Tool[]
├── Memory (optional)
├── WorldModel[] (optional)
│   └── referenced by → Skill[]
├── Sandbox (optional, defaults to most restrictive)
├── Policy[] (optional, defaults to deny-all for unconfigured categories)
├── Swarm (optional)
│   └── references → Identity[] (other agents)
└── Telemetry (optional, valid at all levels)

Key relationships:

• Identity and Provider are always required. Every agent must declare who it is and which LLM it reasons with.
• Tools reference Sandbox and Policy. Each tool can bind to a specific sandbox for execution isolation and a specific policy for behavioral governance.
• Skills compose Tools. A Skill declares which tools it depends on and provides natural-language instructions for orchestrating them.
• WorldModels are reusable planning surfaces. They can be shared across multiple Skills without becoming Skills themselves.
• Swarm references other Identities. Multi-agent coordination involves referencing other agents by their Identity.
• Sandbox defaults to most restrictive. If no sandbox is declared, tools run under maximum restrictions.
• Policy defaults to deny-all. If no policy is declared, unconfigured actions are denied.

Conformance levels and the dependency graph

The dependency graph maps directly to the three conformance levels:

Level 1 (Core) requires only the root of the graph — Identity and Provider. This is enough for a simple chatbot that receives input, reasons with an LLM, and responds.

Level 2 (Standard) adds the execution layer — Channel, Tool, Sandbox, and Policy. This enables agents that connect to messaging platforms, execute tools within security boundaries, and enforce behavioral rules.

Level 3 (Full) includes everything — Memory, Skill, and Swarm join the graph. This enables agents that persist knowledge across sessions, compose multi-step workflows, and collaborate with other agents.

WorldModel and Telemetry are optional at all levels. Telemetry enhances observability without gating deployment.

For the full method support matrix and test vector counts per level, see Conformance Levels.