Models propose.
Only the kernel commits.

Colony Kernel is deterministic mission control for AI-agent colonies. Every state change, budget, and human approval goes through an auditable, fail-closed core. An agent saying "this passed" is not a verification result, and nothing in the kernel treats it as one.

The problem it solves. Hand work to an AI agent and "I finished and it works" is a claim you cannot verify. A model that is wrong about its own success is worse than no agent at all. Colony makes the agent propose and a deterministic core decide. Trust comes from replayable evidence, not from the model's word.

147 offline tests 1 runtime dependency (pinned) replay: byte-identical Node ≥22 · MIT

The problem is measured, not asserted

From a 2026 study of 9,876 agent trajectories across 8 model families (arXiv 2606.09863). False success means an agent confidently reporting completion while the environment state says otherwise.

44–52%
of all failures are false success in single-control domains
3%
when an independent verifier can check state, which is the mechanism Colony is built on
0.65
best LLM-judge AUROC. Judges read confidence, not state
20–24%
of rewritten failures fool even the best detectors. Prose is attackable, state is not

The thesis is not ours alone. Arbiter-K (arXiv 2604.18652, cure-lab/ArbiterOS) shipped a deterministic governance-first kernel first, and Rel(AI)Build (arXiv 2606.26924) converges on the same mechanisms. Colony's axis is mission control: budgets, approvals bound to transitions, durable rejections. Not security interception. Full write-up →

Get the source → Try to break it

Try to break it

The stage pairs below are projected from the kernel's own transition table, so you can press the illegal ones. Each button submits a forbidden move a compromised or overconfident agent might attempt, and the table answers with a reason instead of an exception. Every one of these is illegal by structure, not by likelihood.

Pick an attack above and the kernel will answer.

The proof, not the promise

One seeded demo mission, run twice during publication. Both runs are byte-identical, which is the whole point. Below is the complete, unedited output of the run that shipped this page (also served raw as demo.json):

loading demo.json …

Reproduce it yourself, offline, in seconds:

git clone https://github.com/faresrafat3/colony-kernel && cd colony-kernel
npm install
npm run verify   # typecheck + lint + 147 tests + claims + demo twice, byte-identical
npm run demo > a.json; npm run demo > b.json
diff a.json b.json   # empty — byte-identical replay

What's inside

22-stage state machine

Default-deny edge table. Unlisted transitions are illegal, not "unlikely". Legality precedes storage.

Apply-once event reducer

Accepted events carry canonical hash + CAS version + monotonic sequence. Replay reconstructs identical state.

Content-addressed approvals

SHA-256 over RFC 8785 JCS bytes, bound to the exact transition, consumed ≤1, expired at commit.

Budget ledger

Immutable limits with CAS rows. Agents can't mint resources or vote themselves a raise.

Deny-by-default roles

No self-mutation, no self-publication. Reserved public states are structurally unreachable.

Durable rejections

Refused commands leave evidence and never mutate state. Audit trails don't have gaps.

The inversion

Multi-agent frameworks let the LLM drive workflow state, so workflow is only as reliable as the model. Colony flips the trust boundary: models suggest, a deterministic kernel decides. Verification is proven by replayable evidence, not claimed by the model that wrote the code.

Work with the author

AI Agent Reliability Audit. A fixed-scope engagement for teams shipping AI agents whose outputs they can't fully trust. I audit your agent loop with the same doctrine Colony Kernel is built on: evidence over claims, replay over narratives, fail-closed over fail-open. You get a written findings report and a re-test tier.

Colony Kernel is the proof of work for this offer.

Book an audit (faresrafat3@gmail.com)