decapod 0.46.1

Decapod is the daemonless, local-first control plane that agents call on demand to align intent, enforce boundaries, and produce proof-backed completion across concurrent multi-agent work. 🦀

What Decapod does (plain language)

Decapod does not replace your agent. You keep using Claude Code, Codex, Gemini CLI, Cursor, etc.

Decapod adds one missing layer: when an agent needs to make a control-plane decision (what the user meant, what's in/out of scope, what "done" means, what must be proven), it calls Decapod as a local CLI/RPC. Decapod writes the resulting intent/spec/proof artifacts into .decapod/, so the run becomes auditable and repeatable instead of "trust me bro."

Decapod ships with an embedded constitution: a set of governance docs that agents receive as just-in-time context. The constitution defines boundaries, interfaces, and methodology so agents don't have to guess the rules — they query them on demand.

Decapod is daemonless: it starts when called and exits immediately after the call.

Scenarios where Decapod helps immediately

"This request is underspecified." The agent stops guessing. Decapod forces intent to become explicit (constraints, boundaries, acceptance criteria), then the agent continues with tighter context.
"Multiple agents are editing the same repo." Decapod coordinates shared state and prevents collisions so parallel runs don't silently overwrite or drift.
"It compiled, but is it actually done?" Decapod enforces completion gates: tests, validations, and proof artifacts must pass before a run can claim VERIFIED.

Related research: Evaluating AGENTS.md (ETH SRI, 2026) on context-file quality and agent cost/performance.

Getting started

cargo install decapod
decapod init

What changes after init?

Decapod creates a .decapod/ directory (local-first state) and a small set of agent entrypoint files so agents know the contract. Your existing code and workflow are untouched.

What files get created?

.decapod/
  config.toml                 # project configuration
  data/                       # durable state (governance, memory, traces)
  generated/
    specs/                    # intent, architecture, validation specs
    artifacts/                # proof artifacts, internalizations, provenance
    sessions/                 # per-session provenance logs
AGENTS.md                     # agent-facing contract overview
CLAUDE.md / CODEX.md / GEMINI.md  # tool-specific entrypoints

How to tell it's working

Run your agent normally and ask for a real change (not just "explain X").
Check .decapod/generated/ for new artifacts (specs, proofs, session logs).
Run decapod validate and see typed pass/fail gates instead of narrative claims.
Ask the agent "what did Decapod change about your plan?" — it should reference explicit intent/spec/proof steps.

Agent integration: see AGENTS.md and tool-specific entrypoints (CLAUDE.md, CODEX.md, GEMINI.md) for the operational contract.

Learn more about the embedded constitution. Override defaults with plain English in .decapod/OVERRIDE.md.

Why Decapod

AI coding agents are strong at generating code. Most failures happen before and after generation: unclear intent, fuzzy boundaries, and weak completion checks.

Decapod is the missing layer in that loop. Agents call it mid-run to lock intent, enforce boundaries, and prove completion with explicit gates. It shapes inference without doing inference.

State is local and durable in .decapod/: shared context, decisions, and traces persist across sessions and remain retrievable over time.

Assurance model

Decapod centers execution around three outcomes:

Advisory: clear next actions that tighten intent and reduce wasted loops.
Interlock: hard policy boundaries that block unsafe or out-of-contract flow.
Attestation: durable, structured proof that completion criteria actually passed.

Operating model

Human Intent
    |
    v
AI Agent(s)  <---->  Decapod Runtime  <---->  Repository + Policy
                         |    |    |
                         |    |    +-- Interlock (enforced boundaries)
                         |    +------- Advisory (guided execution)
                         +------------ Attestation (verifiable outcomes)

Features

Core properties:

Daemonless execution: no background agent manager, no hidden runtime.
Two-command adoption: cargo install decapod and decapod init.
Agent-agnostic contract: one CLI/RPC surface across Claude, Codex, Gemini, Cursor, and others.
Parallel-safe collaboration: multiple agents can operate in one repo without state collisions.
VERIFIED is enforced: completion requires passing proof-plan results, not narrative claims.
Local-first auditability: .decapod/ keeps durable traces, decisions, and proof artifacts.
Internalized context artifacts: turn long documents into mountable, verifiable context adapters so agents stop paying the long-context tax repeatedly (decapod internalize create).

Deep surface area (interfaces, capsules, eval kernel, promotions, etc.):

decapod docs show core/INTERFACES.md
.decapod/OVERRIDE.md template after init

Contributing

git clone https://github.com/DecapodLabs/decapod
cd decapod
cargo build
cargo test
decapod validate