# williams-adlc-5-three-dials-parallel-agents-2026-06-12

## Veille

Fifth installment of the ADLC series: orchestrating parallel agents without "merge hell". Williams sets out three coupled dials — cost (model selection), wall-clock time (parallelization width), and accuracy (contract quality) — and an architectural principle: "control flow is code; judgment is models" (deterministic scripts orchestrate, models supply only judgment). Four lanes (frontier Contract Desk, single-writer Builder Pool, shared Prosecution Pool, sequential Integrator), a merge-conflict forecast built from four signals (certified width typically 3-5 agents), and consensus-based disambiguation across N cheap agents rather than clarification questions.

## Titre Article

Three Dials: Parallel Agents Without Merge Hell

## Date

2026-06-12

## URL

https://www.voodootikigod.com/adlc-5-three-dials-parallel-agents

## Keywords

ADLC, multi-agent orchestration, three dials, cost-time-accuracy, control flow is code, parallelization, merge hell, lanes, Contract Desk, Builder Pool, single-writer, Prosecution Pool, Integrator, model routing, rail density, escalation ladder, DAG float, merge-forecast, work-stealing queue, consensus disambiguation

## Authors

Chris Williams (@voodootikigod)

## Ton

Profile: systems-engineering exposition (practitioner perspective in English, architectural and precise register), very high technical level, aimed at platform engineers building agent orchestrators. The tone is one of optimization under coupled constraints: Williams treats parallelism as a scheduling problem where three interdependent variables (cost, wall-clock time, accuracy) cannot be optimized separately. Authority rests on an anti-magic discipline — refusing to let frontier models make scheduling decisions — summed up by the axiom "control flow is code; judgment is models". A style dense with engineering detail: a taxonomy of lanes, named and quantified predictive signals (certified width 3-5 agents), enumerated field practices (batching permissions, work-stealing queues, foundation → packages → apps merge order).

## Pense-betes

- **Three coupled dials**: cost (model selection), wall-clock time (parallelization width), accuracy (contract quality). They are linked: parallelism only improves cost efficiency at constant accuracy if the work partition is clean.
- **Architectural principle**: "control flow is code; judgment is models". Don't let frontier models make scheduling decisions — deterministic scripts orchestrate, models supply judgment only where it's needed.
- **Four specialized lanes**: Contract Desk (frontier model, drafts contracts), Builder Pool (single-writer per partition), Prosecution Pool (shared, fresh contexts), Integrator Lane (sequential).
- **Three tier-routing principles**: (1) rail density (test coverage, deterministic checks); (2) escalation ladder (regenerate on failure, move up a tier); (3) DAG float (critical-path analysis decides whether to ladder up or go straight to the higher tier).
- **Wall-clock time optimization**: four signals predict merge conflicts **before** work starts — file scope overlap, radius in the import graph, historical co-change coupling, namespace collisions. The width certified by the forecast typically runs between **3 and 5 agents**.
- **Accuracy without introspection**: instead of asking the model clarification questions, cheap agents are fanned out to generate multiple interpretations — "where all N agree, the request is demonstrably unambiguous". Disagreement becomes measured, actionable ambiguity.
- **Field practices**: batch permission prompts pre-flight; distinguish in-flight validators from prosecution gates; use work-stealing queues rather than static assignments; observe a strict merge order: foundation → shared packages → apps.

## RésuméDe400mots

This fifth installment tackles scaling: getting agents to work in parallel without falling into "merge hell". Williams starts from the premise that multi-agent orchestration comes down to balancing three interdependent dials — cost (determined by model selection), wall-clock time (determined by parallelization width), and accuracy (determined by contract quality). These factors are coupled: parallelism only improves cost efficiency at constant accuracy if the work partition is clean. Increasing width without clean contracts degrades accuracy and causes conflicts to spike.

The architectural principle is sharp: "control flow is code; judgment is models". Williams refuses to hand scheduling decisions to frontier models; deterministic scripts do the orchestrating, with models stepping in only where judgment is genuinely required. The system is organized into four specialized lanes: a Contract Desk (frontier model) that drafts contracts, a single-writer-per-partition Builder Pool (only one agent writes to a given partition), a shared Prosecution Pool with fresh contexts, and a sequential Integrator Lane.

Model-tier routing follows three principles: rail density (the denser the test coverage and deterministic checks, the lower the tier can go), the escalation ladder (on failure, regenerate by moving up a tier), and DAG float (critical-path analysis decides whether to climb the ladder or jump straight to a higher tier so as not to delay the critical path).

For wall-clock time, Williams identifies four signals that predict merge conflicts before work even starts: file scope overlap, radius in the import graph, historical co-change coupling, and namespace collisions. The width certified by this forecast typically falls between three and five agents — beyond that, collision risk cancels out the gain.

Finally, accuracy without introspection: rather than asking a model clarification questions (unreliable), cheap agents are fanned out to generate multiple interpretations of the request. Where the N agents converge, the request is demonstrably unambiguous; where they diverge, the ambiguity becomes measured and actionable. Williams closes with field practices: batching permissions pre-flight, distinguishing in-flight validators from prosecution gates, preferring work-stealing queues over static assignments, and observing a strict merge order — foundation, then shared packages, then apps.

## GrapheDeConnaissance

- Chris Williams —publie→ Three Dials: Parallel Agents Without Merge Hell (DOCUMENT, 0.97)
- orchestration multi-agents —affirme_que→ coût, temps mural et précision sont trois cadrans couplés (AFFIRMATION, 0.93)
- Chris Williams —affirme_que→ le control flow est du code, le jugement vient des modèles (CITATION, 0.94)
- scripts déterministes —surpasse→ modèles frontier pour les décisions d'ordonnancement (TECHNOLOGIE, 0.88)
- orchestration multi-agents —utilise→ quatre lanes (CONCEPT, 0.9)
- Builder Pool —utilise→ single-writer par partition (METHODOLOGIE, 0.89)
- routing de modèle —est_basé_sur→ rail density, escalation ladder, DAG float (CONCEPT, 0.89)
- merge-forecast —prédit→ conflits de merge avant le lancement du travail (CONCEPT, 0.9)
- merge-forecast —mesure→ largeur certifiée typique de 3 à 5 agents (MESURE, 0.87)
- désambiguïsation par consensus —surpasse→ questions de clarification au modèle (METHODOLOGIE, 0.88)
- désambiguïsation par consensus —permet→ mesurer l'ambiguïté via le désaccord entre N agents (CONCEPT, 0.88)
- phase orchestration —fait_partie_de→ cycle agentique en huit phases (METHODOLOGIE, 0.85)

---
Canonical: https://www.thekb.eu/en/fiches/williams-adlc-5-three-dials-parallel-agents-2026-06-12/