servo-flow

servo runs a piece of work as a feedback loop, not a straight line. Each phase boundary re-grounds against the project's oracles and gates the artifact against ground truth before moving on. The premise: the agent is a high-gain actuator with no damping — left alone it converges fast and confidently, even on the wrong answer. The phases supply the damping.

The phases

scan-project → gather-context → expert-panel → shape-spec ⟂gate→ seal-plan ⟂gate→ execute ⟂scope-watch ⟂gate→ close-the-books

Two things that hold across all phases

• The human is a seat at the table, not ceremony. Always the client (nothing ships without their OK). Often the CEO (they carry the intent). Sometimes also an expert (they contribute, and get challenged like any expert). Capture their input richly, in batches — then pressure-test it.
• Verification only counts if it injects ground truth the producer did not have. Every gate names an oracle. A check that re-reads the artifact with the same context that wrote it is theater. Skip it.

Show the work — keep a live checklist

The phases are only damping if the human can see them happen. At the start of a servo run, open a TodoWrite checklist with one item per phase you intend to run (skip the ones that don't apply), and walk it: mark a phase in_progress when you enter it, completed when its gate passes. When a phase fans out, expand it into sub-items — one todo per expert in expert-panel, one todo per task when executing a sealed plan, one per verifier in a multi-gate. The checklist is the visible spine of the run; never do a multi-phase servo run as a silent block of work.

Depth — choose how much rigor to spend

The fan-out (panels, gates, multiple verifiers) is where the cost is. Pick a depth up front and tell the phases:

• quick (default for most work): the minimal relevant experts (2-3) on a cheap model, fed the context brief; gates run a single oracle-grounded verifier; reason inline rather than spawning when a fork is low-stakes. This is the everyday setting.
• thorough (high-stakes only): widen the panel, run a multi-verifier gate, use the strong model for synthesis and final verification. Reserve for the irreversible, the security-sensitive, the expensive-to-reverse.

A project can set its default depth in the manifest; a task can override it ("this one's high-stakes, go thorough"). When unsure, start quick — a single oracle-grounded gate already catches most stale-premise and scope problems. Escalate only when being wrong is expensive.

Skip what does not apply

Small, well-scoped work does not need the whole loop. A one-line fix needs servo-gate against scope at most. Reach for expert-panel only when there is a genuine fork. The loop scales down; do not run ceremony for its own sake.