The autonomous cycle

The runtime runs one cycle every tickMs (default 10s). A cycle is a pure function over the persisted board: it absorbs directives, plans, executes, reviews, and accounts. Because all coordination state is files, a mid-cycle crash simply resumes on the next tick.

The five steps

Each cycle runs the same five steps, then loops.

1. Absorb directives → goals

Operator messages queued from the dashboard become goals on the shared tracker, oldest first (FIFO), so a burst of directives is never silently reordered.

2. Select the goal to plan

The runtime picks one goal to plan this cycle: the oldest new directive, else the least-recently-advanced open goal. This is fair rotation (below), and it bounds meeting cost to one goal per cycle.

3. Plan (if never planned)

For a goal that’s never been planned, the team meets — a real multi-round debate where each speaker argues and the chair polls for consensus (a line-anchored RESOLVED: yes/no) — and the synthesized decision is threaded into decomposition, which breaks the goal into a task DAG. So the debate shapes the plan rather than being discarded.

4. Execute

The runtime builds a batch from every non-done task across all goals and runs it in dependency order with bounded concurrency, using an intra-cycle drain loop so that delegation and hiring resolve within the same cycle. Budget or a stop halts new dispatch mid-cycle. Full detail in Task DAG.

5. Account

Each open goal’s progress is recomputed. A goal is done only when it has ≥1 task and every task is done. A synthesis (decision doc) is written once, on the transition to done. Then the loop turns again.

Fair scheduling — no starvation

A naive runtime works the first unfinished goal every cycle, so a goal that never converges head-of-line-blocks the whole backlog. Quorum avoids that two ways:

• Selection rotates. Each open goal carries a lastAdvancedCycle cursor; the runtime picks the smallest (never-advanced sorts first), tie-broken by creation time, and stamps the chosen goal. Every open goal is therefore planned within N cycles.
• Execution is decoupled from selection. The task batch is the global set of ready tasks across all goals — not just the selected one. So reworked, delegated, and follow-up tasks on any goal run as soon as their dependencies are met. A stuck goal can’t starve the rest.

Only planning is one goal per cycle; execution spans everything ready.

Communication is load-bearing

The message bus isn’t write-only. Each task turn folds a bounded “messages for you” block into the agent’s prompt — prioritizing directives, meeting decisions, and operator responses — via a ring buffer so a long run can’t leak memory. Meeting decisions drive planning; operator answers to an agent’s request are delivered to its memory and inbox, and re-open the originating task so the next cycle retries it with the granted thing in hand.

Cost safety & cancellation

Budget is a live control input, re-checked before each task and between drain passes:

• A hard daily/monthly cap, an exceeded perCycleUsd, or an abort stops new dispatch; in-flight work drains.
• Each task run passes the remaining per-cycle budget as the binary’s --max-budget-usd, so one agentic run can’t blow the cycle cap.
• Every cycle can be aborted instantly, killing in-flight claude children — an operator stop or runaway spend halts real work immediately, not at the next tick.

See Cost & budget for the caps themselves.

Failure isolation

One flaky agent must never discard the batch. A thrown task is caught, audited, requeued (bounded by maxAttempts), and its siblings still finish; accounting still runs. A departed assignee (fired, or a roster shrink) never throws the batch either — the task is reassigned to the delegating manager, then the lead, then any live agent, or parked blocked.

Design principles

The runtime is built on six ideas:

1. Board as source of truth. All state is persisted files; the runtime is a pure function over them, so a crash resumes cleanly.
2. Decouple selection from execution. One goal is planned per cycle, but every ready task across all goals executes — so no goal starves.
3. Isolate failure. One flaky agent can’t abort the batch.
4. Ground review in independence. No agent grades its own work; an unparseable verdict fails closed rather than rubber-stamping.
5. Make cost a live control input. Budget is re-checked mid-cycle and a stop actually kills in-flight children.
6. Grow the org from the work. When a task needs a skill the team lacks, the coordinator hires a specialist.

All the knobs mentioned here are collected in Configuration.