Explicit ownership
Tasks, dependencies, claims, messages, and completion evidence live as shared state, so every piece of work has an owner and a visible path forward.
Independent build · Validated agent infrastructure
C2 Lattice
Fast agents only create leverage when ownership, authority, dependencies, and recovery stay visible.
22coordination tools
465named local tests
28 / 28clean-checkout acceptance
The constraint
Multiple agents can create coordination debt faster than useful output: duplicate work, invisible dependencies, file collisions, ambiguous ownership, and abandoned tasks after a worker disappears.
Non-obvious diagnosis
The answer was not a larger framework. It was a small control plane that made the minimum critical state explicit and inspectable.
The build starts here. The feature set follows from this diagnosis.What the system makes possible
The useful unit is not an agent. It is accountable work moving through a system.
C2 Lattice is the full local control plane: 22 tools, run management, versioned memory, worker spawning, a live dashboard, task DAGs, file locks, signed identity, role boundaries, and failure recovery. Control Tower Lite is the deliberately minimal 11-tool reference core.
Safe parallelism
File locks and shared memory reduce collisions while letting specialized workers operate concurrently against the same objective.
Bounded authority
Signed identity and architect/worker roles make consequential actions attributable instead of treating every connected agent as equally trusted.
Recovery as a primitive
Heartbeats surface dead peers; abandoned tasks and locks return safely to the system rather than becoming invisible blockers.
Operator visibility
A live dashboard exposes ownership, blockers, queues, and run health so a human can intervene where judgment matters.
See it working
Inspect the mechanism, then inspect the evidence.
The public source is supported by 465 named local tests across six counted suites, a separate end-to-end pipeline, and a 28-of-28 two-client acceptance run from a clean checkout, with green hosted CI on Ubuntu and Python 3.12 / 3.13. The paired editions make the product judgment visible: what the full operating envelope needs, and what can be removed without making the core guarantees implicit.
C2 Lattice
22 tools · 465 named local testsRun management, worker spawning, versioned memory, task DAGs, file locks, signed identity, role boundaries, a live operator dashboard, and recovery—plus a separate end-to-end pipeline and a 28-of-28 clean-checkout two-client acceptance run. The public source has green hosted CI on Ubuntu and Python 3.12 / 3.13.
Inspect the public source ↗︎Control Tower Lite
11 essential tools · 50 testsThe smaller public lineage preserves the minimum useful coordination contract: tasks, dependencies, messaging, locks, memory, signed identity, and dead-peer recovery.
Inspect the reference core ↗︎def sweep_dead_peers() -> None:
cutoff = time.time() - HEARTBEAT_TIMEOUT
with db_lock:
dead = db.execute(
"SELECT id FROM peers WHERE status = 'active' "
"AND last_heartbeat < ?", (cutoff,)
).fetchall()
for row in dead:
db.execute(
"UPDATE tasks SET status = 'pending', "
"assigned_to = NULL WHERE assigned_to = ? "
"AND status = 'in_progress'", (row["id"],)
)
db.execute(
"DELETE FROM file_locks WHERE peer_id = ?", (row["id"],)
)Actual command-center desktop
A representative run makes C2's operating model visible: active ownership, dependency-aware work, completed evidence, broker health, and intervention state in one command center.
Actual agent-state drawer
The operator can inspect one worker's role, liveness, branch, budget, owned work, messages, and permitted interventions without reconstructing state from chat history.
Inspectable public source
The C2 Lattice repository exposes the implementation, architecture assets, security policy, tests, and green commit status.
Companion implementation CI
Control Tower Lite preserves the smaller predecessor; C2 Lattice is now the current public coordination system, with its own green hosted CI.
How the parts compound
A feature matters when it improves the next decision.
- 01Define
Decompose the outcome into tasks, dependencies, authority, and acceptance evidence.
- 02Coordinate
Workers claim bounded tasks, exchange messages, lock files, and share durable context.
- 03Observe
The control plane keeps ownership, progress, blockers, and run health visible.
- 04Recover
Dead peers, abandoned ownership, and blocked work become explicit state transitions.
- 05Verify
Completion is tied to evidence and validated through local, end-to-end, and clean-checkout tests.
The decisions that mattered
Architecture follows the failure mode.
The implementation is the visible surface. These choices determined whether it could solve the underlying problem.
- 01
State before intelligence
Represent tasks, dependencies, ownership, messages, locks, and memory directly instead of trusting conversational context.
- 02
Narrow authority
HMAC identity and architect/worker roles make the actor and permitted action attributable.
- 03
Recovery by design
Heartbeats surface dead peers so abandoned tasks and locks can be released instead of silently blocking the system.
Evidence classOperating interface + public source
Source
Actual command-center captures from an isolated representative run, plus public C2 Lattice source, green hosted CI on Ubuntu and Python 3.12 / 3.13, 465 named local tests across six counted suites, a separate end-to-end pipeline, and a 28-of-28 clean-checkout acceptance record.
What it establishes
The implementations, their different feature envelopes, task graphs, locks, signed identity, role boundaries, recovery behavior, tests, dashboard, and standard-library runtime are inspectable.
Boundary
A deliberately small local coordinator—not a claim of enterprise-scale throughput or a general-purpose agent platform.