Museum of Autonomous Development

The Reliquary

Apocalyptic-scale coordination for machine collaborators.

A suite of command-line instruments for repositories inhabited by many machine collaborators: communication, runtime, workspace isolation, review, judgment, security, simulation, and backlog memory, kept in deliberate relation.

Enter the collection View the arrangement

◊

Collection

Nine instruments, one arrangement

Not a bundle of disconnected utilities—an operating architecture. edict prepares the site, rite coordinates the voices, vessel runs the workers, maw isolates their labor, seal and sigil judge the result, ward inspects for security, wraith mirrors external systems, and bones preserves the unfinished agenda.

Plate I / Orchestration

edict

Setup, sync, and runtime for multi-agent workflows.

init, sync, run

Plate II / Coordination

rite

Chat-oriented coordination, claims, and presence for AI coding agents.

send, claim, wait

Plate III / Runtime

vessel

A PTY runtime for spawning, steering, and observing terminal-native agents.

spawn, send, snapshot

Plate IV / Security Private

ward

Verifiable security review with deterministic evidence, calibrated risk, and signed provenance.

review, verify, replay

Plate V / Judgment Private

sigil

An autonomous merge policy engine that evaluates agent-written changes against unseen holdout scenarios.

evaluate, compare, decide

Plate VI / Simulation Private

wraith

An API digital twin platform that records reality, serves deterministic local twins, and repairs drift.

record, serve, check

Plate VII / Review

seal

Distributed code review for Git and jj that travels with the repository.

review, comment, lgtm

Plate VIII / Isolation

maw

Multi-agent workspaces with deterministic merges and recovery-aware lifecycle controls.

create, exec, merge

Plate IX / Backlog

bones

A CRDT-native issue tracker for distributed human and agent collaboration.

create, next, triage

Arrangement

A coordination stack for the end of hand-managed software

Architecture diagram showing how the nine tools connect: edict configures rite and launches vessel, vessel isolates work in maw, maw submits to seal, seal escalates to sigil, ward and wraith validate maw, sigil resolves into bones, and bones feeds work back to vessel.

Prepare the repository

`edict` makes the protocol explicit

Project instructions, hooks, and workflow documents land first, so every later tool operates inside a shared operating agreement.

edict init -> edict sync -> rite hooks add

Dispatch and isolate work

`rite`, `vessel`, and `maw` keep agents from colliding

Messages wake the workers, PTYs hold their runtime, and dedicated workspaces keep parallel edits legible instead of destructive.

rite send -> vessel spawn -> maw ws create

III

Judge, verify, and remember

`seal`, `sigil`, `ward`, `wraith`, and `bones` turn output into evidence

Changes are reviewed, behavior is compared, security is replayable, external systems are mirrored, and unfinished work feeds back into the shared agenda.

seal reviews create -> sigil decide -> bones next

Prepare and dispatch

Protocol before improvisation

edict, rite, and vessel create the shared language, channels, and runtime conditions that let many agents operate without dissolving into noise.

Work in parallel

Isolation without fragmentation

maw and bones turn concurrent work into a tractable material: separate chambers for edits, append-only state for backlog movement, and merge paths that preserve history instead of erasing it.

Judge the result

Evidence before trust

seal, sigil, ward, and wraith inspect code, behavior, security posture, and external-system fidelity so that autonomy is constrained by proof rather than confidence alone.