Manifest Format

The Claw Manifest (claw.yaml) is the root document that composes all primitives into a complete agent definition. It declares what an agent is and what it can do. The runtime decides how.

Top-level structure

Every manifest has four required top-level fields:

claw: "0.3.0"        # Protocol version (semver)
kind: Claw            # Must be "Claw" for root manifests
metadata:
  name: "my-agent"    # Agent name (required)
  version: "1.0.0"    # Agent version (optional, semver)
  description: "..."  # Human-readable description (optional)
spec:
  # Primitives go here

Field	Required	Description
claw	Yes	CKP protocol version this manifest targets
kind	Yes	Must be Claw for root manifests
metadata.name	Yes	Unique agent name
metadata.version	No	Agent version (semver)
metadata.description	No	Human-readable description
spec	Yes	Contains all primitive declarations

The spec object

The spec object holds references or inline definitions for each of the 11 primitives (9 core primitives plus optional WorldModel and Telemetry). Two fields are required; the rest are optional and additive:

spec:
  # REQUIRED
  identity: "./identity.yaml"           # or inline
  providers:                             # at least one entry
    - "./providers/primary.yaml"
    - "./providers/fallback.yaml"

  # OPTIONAL
  channels:
    - "./channels/telegram.yaml"
    - "./channels/cli.yaml"
  tools:
    - "./tools/*.yaml"                   # glob patterns supported
    - "claw://registry/tools/[email protected]"  # registry references
    - inline:                            # inline definitions
        name: "echo"
        description: "Returns input text"
        input_schema:
          type: object
          properties:
            text: { type: string }
  skills:
    - "./skills/*.yaml"
  memory: "./memory.yaml"
  world_models:
    - "./world-models/environment-model.yaml"
  sandbox: "./sandbox.yaml"
  policies:
    - "./policies/security.yaml"
  swarm: "./swarm.yaml"
  telemetry: "./telemetry.yaml"

Inline vs. referenced primitives

Primitives can be declared in two ways:

Referenced — point to a separate YAML file or a claw:// registry URI:

identity: "./identity.yaml"

Inline — declare the primitive directly using the inline: key:

identity:
  inline:
    personality: "You are a helpful assistant."
    autonomy: supervised

Both approaches follow the same schema. Inline is convenient for small agents; referenced files are better for complex configurations where primitives are shared across manifests.

Required fields per kind (inline)

When a primitive is declared inline, these fields are required:

Kind	Required Fields
Identity	personality
Provider	protocol, endpoint, model, auth
Channel	type, transport, auth
Tool	(description + input_schema) or mcp_source
Skill	description, tools_required, instruction
Memory	stores (at least one entry)
WorldModel	backend
Sandbox	level
Policy	rules (at least one entry)
Swarm	topology, agents, coordination, aggregation
Telemetry	exporters (at least one entry)

Minimal valid manifest

The smallest possible valid agent — an L1 Claw with identity and one provider:

claw: "0.3.0"
kind: Claw
metadata:
  name: "minimal-bot"
spec:
  identity:
    inline:
      personality: "You are a helpful assistant."
      autonomy: observer
  providers:
    - inline:
        protocol: openai-compatible
        endpoint: http://localhost:11434/v1
        model: llama3
        auth:
          type: none

This creates a read-only assistant using a local Ollama instance. No tools, no channels, and maximum security restrictions by default.

Full manifest example

A complete L3 manifest with all 9 core primitives (WorldModel and Telemetry optional at all levels):

claw: "0.3.0"
kind: Claw
metadata:
  name: "research-coordinator"
  version: "1.0.0"

spec:
  identity:
    inline:
      personality: "You are an autonomous research coordinator."
      autonomy: autonomous

  providers:
    - inline:
        protocol: anthropic-native
        endpoint: https://api.anthropic.com/v1
        model: claude-sonnet-4-6
        auth:
          type: bearer
          secret_ref: ANTHROPIC_KEY

  channels:
    - inline:
        type: cli
        transport: stdio
        auth:
          secret_ref: LOCAL_CLI_TOKEN

  tools:
    - inline:
        name: search
        description: "Search the web"
        input_schema:
          type: object
          properties:
            query: { type: string }
          required: [query]

  skills:
    - inline:
        name: deep-research
        description: "Multi-step research workflow"
        tools_required: [search]
        instruction: "Search for the topic, then synthesize findings."

  memory:
    inline:
      stores:
        - name: context
          type: conversation
          role: episodic
          backend: sqlite
          lifecycle:
            acquisition: event-driven
            consolidation: adaptive
            retrieval: contextual

  world_models:
    - inline:
        name: environment-model
        paradigm: hybrid
        backend:
          type: tool
          ref: search
        predicts:
          state: true
          observation: true
          risk: true
        planning:
          horizon: adaptive
          uncertainty_mode: bounded
          fallback: conservative

  sandbox:
    inline:
      level: process

  policies:
    - inline:
        rules:
          - id: allow-all
            action: allow
            scope: all

  swarm:
    inline:
      topology: peer-to-peer
      agents:
        - identity_ref: research-coordinator
          role: peer
      coordination:
        message_passing: direct
        backend: in-process
        concurrency:
          max_parallel: 3
      aggregation:
        strategy: merge

Validation rules

The runtime enforces these rules when loading a manifest:

1. The kind field must be Claw for root manifests.
2. spec.identity is required.
3. spec.providers is required and must contain at least one entry. An empty array is rejected.
4. File path references (e.g., "./identity.yaml") are resolved relative to the manifest file’s directory.
5. Glob patterns (e.g., "./tools/*.yaml") are expanded by the runtime at load time.
6. If a referenced file does not exist, the runtime rejects the manifest with a descriptive error.
7. metadata.name should be provided in inline primitives. If omitted, the runtime may generate a name.
8. metadata.version defaults to the parent manifest’s metadata.version when omitted from inline primitives.
9. If skills[].world_model_ref is present, it must resolve to a declared world_models entry.

Conformance level by primitives

The primitives you include determine the agent’s conformance level:

Level	Required Primitives	Target Use Case
L1 Core	Identity, Provider	Embedded devices, simple chatbots
L2 Standard	+ Channel, Tool, Sandbox, Policy	Personal assistants, team bots
L3 Full	All 9 core primitives (WorldModel and Telemetry optional at all levels)	Enterprise swarms, multi-agent systems

WorldModel and Telemetry are optional at all levels. Telemetry is recommended for production deployments; WorldModel is recommended only when the runtime performs predictive planning.

URI references

Manifests can reference primitives using the claw:// URI scheme:

claw://local/tool/my-tool           # Local primitive
claw://local/tool/[email protected]     # Local with version
claw://registry/namespace/[email protected] # Registry reference

Alias URIs (e.g., claw://tool/my-tool) are allowed in manifests for convenience. The runtime resolves them to claw://local/tool/my-tool before processing.

---

See the CKP Specification for the full normative definition, including ABNF grammar and detailed primitive schemas.