Concurrency Modes¶
How many dispatches run at once. The primary speed-vs-risk dial.
[TUNABLE — concurrency mode]
This page is about one choice: do you let the AI work on one thing at a time, or several things at once? Doing more at once is faster, but it's also riskier — so this is the main dial you'll reach for when you want to trade safety for speed.
TL;DR¶
In plain terms: pick how many jobs run at the same time. One-at-a-time is the safe, slow default; running several together is faster but easier to get wrong.
Concurrency mode chooses how many units of work proceed simultaneously. The four modes — sequential (LAYGO), pipelined, parallel-independent, parallel-doer — trade wall-clock speed against pollution and dependency risk. The conservative default is sequential (LAYGO): one dispatch at a time, maximum context cleanliness, lowest risk, slowest. Most projects graduate to pipelined after the first cycle proves the rhythm. The git-layer mechanics (commit discipline + worktrees) make every mode race-safe at the storage layer, but the coordination risk still rises with concurrency.
A related but separate dial: the delegation mode (who coordinates with whom) is its own cycle-boundary toggle that composes with the concurrency mode (how many run at once).
How dispatches overlap — from one-at-a-time to parallel Doers under one orchestrator — and the speed-versus-risk each buys.
The dial¶
The cross-axis alternation (LOCKED build vs UNLOCKED doctrine) is [INVARIANT] — those don't run together. This dial controls concurrency within an active axis: how many of its dispatches run at the same time.
The four modes¶
Sequential — Learn As You Go (LAYGO) · default¶
One dispatch at a time. The next dispatch starts only after the current one fully closes. Maximum context cleanliness per dispatch; lessons fully absorbed before the next begins.
- Slowest wall-clock.
- Lowest pollution risk — no two dispatches in flight to bleed into each other.
- Highest intelligence floor — each dispatch has the full attention of a clean orchestrator.
- Highest predictability — one thing happening at a time is easy to estimate.
Recommended for the first cycle and for risk-averse projects. It is the only mode that needs no dependency tracking, because there is never more than one dispatch to depend on anything.
Pipelined¶
The next dispatch starts while the current one is in close-out (its gate-check / tag-apply tail). The orchestrator is composing the next stamp while the previous dispatch finishes its ceremony.
- Modest throughput gain — roughly a 30–50% wall-clock reduction in workflows of this shape, since the close-out tail overlaps useful work.
- Some cross-dispatch bleed if the top mentor has to triage two dispatches at once.
- Intelligence and predictability stay high; risk rises to low-medium.
Recommended after the first cycle proves the rhythm. This is the natural graduation from LAYGO.
Parallel-independent¶
Multiple dispatches run concurrently when they have no substrate dependencies — for example two modules (or two doctrine entities) that don't cross-reference each other.
- Maximum throughput at the dispatch level.
- Requires explicit dependency tracking — the orchestrator must know which dispatches are independent.
- Risk if dependencies are wrong — one dispatch reads a base that another is concurrently amending, and the read goes stale silently.
The cost of getting dependency tracking wrong is the gating consideration. If your work naturally factors into independent units, this mode pays off; if dependencies are subtle, the provenance law is your only defense against a stale-base read.
Parallel-doer¶
A single orchestrator (Mentor-2) spawns multiple Doer slices in parallel within one dispatch.
- Throughput within one dispatch — useful when a dispatch decomposes into many independent slices.
- Fresh-per-slice still applies; each parallel Doer is its own fresh session in its own worktree.
- Risk of doer-level divergence at integration — multiple fresh slices must be integrated in order, and divergent assumptions surface only at merge.
The git-layer mechanics make the storage safe (each Doer gets its own worktree and isolated index; object writes never conflict — see Git foundations). The remaining risk is semantic: two slices making incompatible assumptions that only collide at integration.
Trade-off matrix¶
| Mode | Speed | Intelligence | Cost | Risk | Predictability |
|---|---|---|---|---|---|
| Sequential (LAYGO) | low | high | low | low | high |
| Pipelined | medium | high | medium | low–medium | high |
| Parallel-independent | high | high | medium–high | medium | medium |
| Parallel-doer | high (within dispatch) | medium–high | medium–high | medium | medium |
What stays invariant across all modes¶
The storage-layer correctness is non-negotiable regardless of concurrency:
- Per-session isolated index (
GIT_INDEX_FILE+commit-tree) so parallel sessions never stomp each other's stages. - Per-slice worktrees so parallel Doers never share a working directory.
- Refspec push so a ref race is resolved by fast-forward rejection, never a silent overwrite.
These are detailed in Git foundations. Concurrency tuning rides on top of them; it never relaxes them.
Defaults¶
| Setting | Default | Range |
|---|---|---|
| Concurrency mode | Sequential (LAYGO) | LAYGO / Pipelined / Parallel-independent / Parallel-doer |
| Dependency tracking | not required (LAYGO) | required for both parallel modes |
How to choose¶
- First cycle → LAYGO, always. Prove the rhythm before adding concurrency. Bootstrap and Conservative presets pin this.
- After first close → Pipelined. Low-cost throughput win with minimal added risk. This is the Balanced default.
- Time-pressured, mature project, naturally independent work → Parallel-independent. Only with disciplined dependency tracking. This is the Throughput preset.
- A single dispatch decomposes into many independent slices → Parallel-doer. Budget for ordered integration.
Weigh each step by the cost of getting dependency tracking wrong. If a stale-base read would be expensive to roll back (regulated/compliance work), stay at LAYGO or Pipelined.
Remember this¶
- One dial, one trade-off: more work at once buys speed and costs safety. That's the whole idea behind the four modes.
- Start slow on purpose. Run one job at a time (LAYGO) for your first cycle, then graduate to pipelined once you trust the rhythm.
- The storage layer is always safe — git keeps parallel work from corrupting files. The risk that grows with concurrency is coordination: two jobs making assumptions that only clash later.
- New here? The four modes sit inside the mental model as one of the dials you tune after the basics click.
How this connects¶
- Git foundations — the storage-layer mechanics that make concurrency race-safe.
- Context patterns — concurrency interacts with mentor lifecycle (a parallel mode pressures the top mentor's context more).
- Operating presets — each preset pins a concurrency mode.
- Tunables overview — concurrency is the canonical speed-vs-risk dial.