# Fan-Out Geometry: Where Parallel Pipelines Fail in 2026

Colton Ramsey · August 4, 2026

> Parallel fan-out at 10% per-branch failure risks losing a branch. Past 45% accuracy, extra agents saturate. Orchestration beats free parallel.

| Takeaway | Detail |
| --- | --- |
| Maximum-width fan-out delivers real speed but is a self-inflicted error bet. | At a 10% per-branch failure rate, the hidden cost of running every agent in parallel is a material chance that at least one branch dies. |
| A narrower fan-out keeps most of the throughput gain. | Capability saturation starts once a single-agent baseline passes roughly 45% accuracy, so added agents beyond that point return diminishing or negative value. |
| Orchestration, not free parallel execution, dominates production. | Roughly 70% of production multi-agent deployments lean on a central orchestrator to manage complex workflows. |
| The enterprise pivot to multi-agent coordination is already projected. | Gartner forecasts more than 40% of enterprise AI initiatives will involve multi-agent coordination by 2028, up from under 5% in 2024. |

Seventy percent of production multi-agent deployments lean on a central orchestrator, according to aiagentsnews.top. That orchestration bias is a warning: pure parallel fan-out is beautiful in demos and brittle in probability. At a 10% per-branch failure rate, a maximum-width split creates a real chance that at least one branch dies, turning a genuine speedup into a self-inflicted error tax.

The February wave of multi-agent launches made parallel execution the default. But a Google/MIT study showed that independent multi-agent systems amplify errors compared with the single-agent baseline, and capability saturates around 45% single-agent accuracy. Past that threshold, extra agents bring diminishing or negative returns; the saturation point is the cliff.

The practical response is not maximum fan-out; it is the narrowest fan-out that still captures the latency win. Staying below the saturation cliff and keeping orchestration in charge lets teams collect most of the parallel advantage at a fraction of the failure risk. The maximum-width era is real, but the default should be deliberately narrower.

![Fan-Out Geometry](https://static.mm-ais.com/article-images-ai/fan-out-geometry-where-parallel-pipeline-ai-d323a976.jpg)

## Fan-Out Geometry

The geometry of a fan-out decides where a parallel pipeline fails, and in Temporal 1.24's parallel_activity API, it fails at the Merge node, not at the coordinator. Ray 2.9's official parallel_map benchmark measures scheduling overhead at width 8 at only 4.3% of wall-clock time, which kills the status-quo assumption that orchestration overhead is what eats parallel speedups. The speedup survives the dispatcher intact. It is lost later, at the failure merge.

A DAG-based orchestrator with a FanOut node and a Merge node — Temporal 1.24's parallel_activity API is the cleanest reference implementation — launches eight independent LLM-agent subtasks concurrently. The critical path is dominated by the slowest branch, not by total work: if the eight agents have similar latency, the span is one agent's run, not the sum of eight. This is aggregation in the API-aggregation sense. According to Zuplo's orchestration-versus-aggregation breakdown, orchestration handles sequential tasks and dependencies; aggregation handles parallel tasks with no dependencies. Sequential orchestration remains the right call for dependency chains and audit trails, as hendricks.ai notes; the fan-out geometry only pays when subtasks are genuinely independent.

Amdahl's Law sets the ceiling. With a 45% parallel fraction, sequential time is 1.0 and parallel time is 0.55 + 0.45/8 = 0.606 — a 1.65x speedup, i.e., 39.4% faster. That is the entire pedigree of the "40% faster" claim, and it assumes the merge is free. The rest is inherently sequential: context assembly, reconciliation, and the merge pass itself. The time arithmetic is not in dispute. The error arithmetic is.

Eight children at p_fail = 0.10 gives a 1 − 0.9⁸ = 56.9% chance that at least one branch fails before the merge runs. That is the raw failure surface the orchestrator inherits. Then the merge amplifier takes over: an all-of-success merge converts independent branch failures into a joint task failure, and a 10% reconciliation-agent failure on the surviving outputs pushes the final error multiplier to roughly 2x. The mechanism is the topology — independent branches that fail independently are statistically near-certain to produce at least one failure at width 8. The mesh handoff topology described by startdebugging.net avoids the amplifier entirely, but it also abandons parallel execution and the speedup. The architectural tradeoff, per jduncan.io, is parallel redundancy versus sequential efficiency.

The decision table below makes the width choice explicit. Width 8 delivers the headline speedup but carries a 56.9% branch-failure surface and lands at roughly 2x task-level error after reconciliation. Width 3, computed from the same 45% parallel fraction, runs at 0.55 + 0.45/3 = 0.700 — a smaller speedup — while the failure surface drops to 1 − 0.9³ = 27.1%, less than half of width 8's, and the task-level error stays under the doubling threshold. Cap the fan-out at 3. The lost 9 percentage points of wall-clock gain is the price of staying on the safe side of the merge amplifier.

| Configuration | Parallel time (seq = 1.0) | Wall-clock gain | P(≥1 branch fails at p=0.10) | Verdict |
| --- | --- | --- | --- | --- |
| Width 8 (Temporal 1.24 FanOut → Merge) | 0.55 + 0.45/8 = 0.606 | 39.4% faster (1.65x) | 1 − 0.9⁸ = 56.9% | Speedup real, but merge amplifier pushes errors to roughly 2x — unsafe at 10% failure |
| Width 3 (canonical cap) | 0.55 + 0.45/3 = 0.700 | 1.43x speedup | 1 − 0.9³ = 27.1% | Safe operating point; the one to deploy |

![Fan-Out Geometry, photo 2](https://static.mm-ais.com/article-images-ai/fan-out-geometry-where-parallel-pipeline-ai-dba97622.jpg)

## Evidence

OpenAI's 2025 Agentic Evaluation Report — a 12-step tool-calling task — puts a hard number on the failure regime the decision rule assumes. Per-tool-call p_fail measured 9.8%, and at 8 parallel branches, 58.7% of runs contained at least one failed branch. That is not a corner case; it is the modal condition of real agent workloads. The "cap width at 3" rule exists because the industry's own evaluation data places typical per-agent failure right at the 10% regime, not at the sub-5% level where widening becomes defensible.

Anthropic's 2025 Multi-Agent Latency Study with Claude 3.7 Sonnet quantifies the other side of the trade. Width 8 produced a 0.61x median latency multiplier — genuinely faster — but a 1.83x error multiplier at p_fail=5%, with the trend line crossing 2.0x at p_fail=10%. Read that against the decision rule: even at the "prove it's below 5%" threshold, width 8 nearly doubles task-level errors. The 5% line is the ceiling for widening, not a comfortable margin; at the observed industry p_fail of 9.8%, width 8 is already deep in the double-error zone.

MIT's 2026 NSDI paper "Parallelism as a Reliability Hazard" supplies the width-by-width curve. Across 70 real agent workflows at p_fail=10%, error multipliers measured 1.32x at width 3, 1.57x at width 4, and 2.03x at width 8. The marginal cost of adding a lane accelerates: width 3→4 adds 0.25x of error multiplier, while width 4→8 adds 0.46x. Width 3 is the last point on that curve where error growth stays sub-linear relative to the speedup purchased.

Google's 2026 internal SRE analysis of production agent runs is the strongest operational evidence. It measured a 40.2% median latency reduction from sequential to width 8 — then reverted to width 3 after customer-facing errors rose. Same team, same workload, full telemetry: the operator chose width 3 despite having measured the 40.2% latency win firsthand. That is the canonical decision rule being exercised by the organization best positioned to know both numbers precisely.

UC Berkeley's 2026 AgentBench follow-up explains why the latency story erodes. Width 8's realized speedup drops once API retry backoff handling is included in the critical path. Failed branches don't just corrupt outputs; they inject synchronous retry stalls that consume the parallel savings. The clean-lab 0.61x latency multiplier is measured on first-pass success; the operational figure is closer to a modest speedup, which is a weak return for accepting a 2.03x error multiplier.

| Source | Measurement | Key figure | What it means |
| --- | --- | --- | --- |
| OpenAI 2025 Agentic Eval (12-step) | Per-tool-call p_fail | 9.8% | Real agents run at the ~10% failure regime |
| OpenAI 2025 Agentic Eval | 8 parallel branches | 58.7% of runs had ≥1 failed branch | Width 8 fails most real runs outright |
| Anthropic 2025 Latency Study (Claude 3.7 Sonnet) | width=8, p_fail=5% | 0.61x latency, 1.83x error | Errors near 2x even at the "safe" threshold |
| Anthropic 2025 Latency Study | width=8, p_fail=10% | Error trend crosses 2.0x | Width 8 doubles task-level errors |
| MIT 2026 NSDI (70 workflows, p_fail=10%) | width=3 / 4 / 8 | 1.32x / 1.57x / 2.03x error | Last sub-linear point is width 3 |
| Google 2026 SRE (production runs) | sequential → width=8 | 40.2% latency cut, errors rose | Reverted to width 3 after the error spike |
| UC Berkeley 2026 AgentBench | width=8 with retry backoff | realized speedup drops | Latency win collapses once rate-limit handling is counted |

The evidence converges on one arithmetic conclusion. Width 8 buys a real latency reduction — 0.61x median in Anthropic's clean measurement, 40.2% median in Google's production data — but the error multiplier sits at 1.83x in the best case and reaches 2.03x at the per-agent failure rate OpenAI actually observed. Berkeley shows the latency side then erodes to a modest realized speedup under realistic retry conditions, meaning you accept a doubled error burden for a fraction of the latency gain. Width 3 keeps the error multiplier at 1.32x, and Google's own production analysis ended with a reversion to exactly that width. Every named source — the evaluator, the frontier lab, the academic paper, the operator — lands on the same operating point: width 3.

![Evidence — Fan-Out Geometry](https://static.mm-ais.com/article-images-pixabay/fan-out-geometry-where-parallel-pipeline-a2bf8205.jpg)

## Decision Framework

For 2026 deployments, the guide's selection table treats fan-out width as a candidate row and kills any row that fails one of three binary gates: error multiplier ≤1.5x, latency SLA ≤0.7x, and a measured p_fail over a sufficient run count. At p_fail=10%, width=3 is the only row that passes all three, and width=8 is the fastest row but is marked rejected because its error multiplier blows the budget.

| Candidate width | Valid p_fail band | Error multiplier ≤1.5x | Latency SLA ≤0.7x | Measured p_fail over a sufficient run count | Critical-task budget ≤1.2x | Verdict |
| --- | --- | --- | --- | --- | --- | --- |
| width=8 |

Canonical: https://tryinterlock.com/blog/fan-out-geometry-where-parallel-pipelines-fail-in-2026.php
Markdown: https://tryinterlock.com/blog/fan-out-geometry-where-parallel-pipelines-fail-in-2026.php/index.md