decapod 0.25.0

Decapod is a Rust-built governance runtime for AI agents: repo-native state, enforced workflow, proof gates, safe coordination.
Documentation

What Is Decapod

Like Docker gives containers a standard runtime, Decapod gives agents a standard operating environment. Install it once, and any agent enters through the same repo contract: governed state, enforced workflow, proof gates, and coordination for parallel work.

It replaces “trust me” with enforcement. Validation gates prevent agents from skipping checks, drifting from the repo’s rules, or declaring completion without executable evidence—so outcomes are verifiable, not narrated.

Decapod isn’t an agent framework or a SaaS layer. It’s repo-side infrastructure: humans can read the artifacts, but the operators are agents, and the repo’s rules are what hold.

How It Works

Decapod is a tool for agents, not for humans. After decapod init is present in a repo, agents operate inside the governed environment. Two things set it apart from orchestration frameworks: an embedded constitution and coordination primitives.

Embedded Constitution

Every Decapod binary ships with a compiled-in methodology: binding contracts, authority chains, proof doctrine, and architectural guidance — 40+ documents covering specs, interfaces, architecture, and plugins. Agents don't receive tips; they receive contracts.

decapod init generates thin entrypoints (AGENTS.md, CLAUDE.md, GEMINI.md, CODEX.md) that point agents into the constitution. Every agent, regardless of provider, enters through the same contract and follows the same authority ladder:

Intent > Architecture > Implementation > Proof

Projects customize behavior through .decapod/OVERRIDE.md — extend or adjust any contract without forking the constitution.

Coordination Primitives

Agents operating in the same repo share durable infrastructure:

  • Architecture decision prompting — When starting a new project, decapod decide walks agents through curated engineering questions (runtime, framework, orchestration, database, etc.) with only the best options. Decisions are stored in SQLite and cross-linked into the knowledge graph as a durable Architecture Decision Record.
  • Proof ledger + knowledge graph — Decisions, conventions, and proof events survive sessions and model switches. Stored in .decapod/data/ as SQLite + append-only event logs, forming a repo-native knowledge graph of intent → change → proof.
  • Proof gates — decapod validate is authoritative. If it fails, the change is not complete, regardless of summary confidence.
  • Shared backlog — A brokered task system with audit trails. Agents claim work, record transitions, and archive completions. No duplicate effort, no lost context.
  • Policy boundaries — Trust tiers, risk zones, and approval gates. Governance that scales with autonomy.
  • Event sourcing — Every state mutation goes through a broker that records who did what, when, and why. State can be deterministically rebuilt from events.

Architecture

your-project/
├── AGENTS.md              Agent universal contract (generated)
├── CLAUDE.md              Claude entrypoint (generated)
├── GEMINI.md              Gemini entrypoint (generated)
├── CODEX.md               Codex entrypoint (generated)
└── .decapod/
    ├── data/              State: SQLite DBs + event logs
    ├── generated/         Derived artifacts (auto-managed)
    ├── OVERRIDE.md        Project-specific constitution overrides
    └── README.md          Control plane documentation

Agents interact through the CLI control surface. Direct mutation of .decapod/data/ violates the control-plane contract.

Security

See SECURITY.md. Agents must handle credentials securely — never log, never commit, always rotate. Violations are constitutional breaches.

Contributing

Decapod is built with Decapod. To develop:

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

Support

License

MIT. See LICENSE for details.