Scaling RDCO Pipeline-* From Single-Digit Fan-Out to 20-50 — The Architectural Lift

The question

What architectural patterns let Cloudflare Glasswing and Every's software factory run 50-100 concurrent narrow agents reliably, and which patterns would let RDCO's pipeline-spec/test/code/critic skills scale fan-out by 10x without losing reliability?

What we already know (from the vault)

[[01-projects/skill-pipelines/]] — RDCO's pipeline-spec/test/code/critic pattern is the agent-flow shape (sequential 4-stage assembly line), with fan-out currently in the 1-4 range per stage.
IndyDevDan Pi-to-Pi note (2026-05-18) — orchestrator-worker DIY pattern adjacent to the substrate question.
[[06-reference/2026-04-15-thariq-claude-code-session-management-1m-context.md]] — context-rot is the gating constraint; more parallel agents only help if each operates in an isolated context budget.
/verify-vault-write, /verify-strategic-output, /verify-dispatch — already-deployed fresh-eyes critic subagents — the seed of an adversarial-review pattern.

What the web says

Glasswing/Mythos = 8-stage pipeline with task-queue fanout at the Hunt stage. Stages: Recon → Hunt → Validate → Gapfill → Dedupe → Trace → Feedback → Report. Recon hierarchically reads the codebase and generates the task queue for downstream stages. Hunt runs ~50 concurrent narrow-scoped hunter agents, each paired (attack-class × scope-hint). Per-task scratch dirs provide process-level isolation. (Cloudflare blog — Project Glasswing)
Adversarial review is the integrity primitive. Validate stage uses a deliberately independent agent with different prompt and no generative capability — pure refutation role. Cloudflare's load-bearing claim: "putting two agents in deliberate disagreement is way more effective than just telling one agent to be careful." This catches a meaningful fraction of noise hunter-self-review misses.
Dedupe and Gapfill are necessary because of model drift. Hunters skew toward successful attack classes; Gapfill explicitly re-queues under-covered regions. Dedupe collapses variants sharing root cause — "variant analysis as a feature, not a way to inflate the queue."
Trace closes the cross-repo loop. Per-consumer tracer agents use shared symbol indices to check reachability. Confirmed-reachable findings feed back into Hunt as new tasks in consumer repos.
Three production-survivor patterns at scale (2026): (NiteAgent — Multi-Agent in Production 2026)
1. Agent-flow (assembly line): sequential stages, minimal state sharing, 3-5x token overhead (~$45-150/10k requests). Best for natural-stage workflows. (RDCO pipeline- lives here.)*
2. Orchestration (hub-and-spoke): central orchestrator holds full context, spawns isolated subagents returning compressed summaries, zero peer communication. 8-15x token overhead (~$120-450/10k requests). Industry default. Hub fragility — governance layer raises resilience 0.32 → 0.89.
3. Bounded collaboration (controlled peer mesh): shared workspace with explicit phase gates + arbiter. 15-25x token overhead (~$225-750/10k requests). Used only as subroutine inside a supervisor.
Five-vendor convergence on orchestrator + isolated subagents. Cognition (managed Devin subagents Mar 2026), Anthropic (brain/hands architecture, Apr 2026), OpenAI (Agents SDK nested-handoff opt-in, Apr 15 2026), AutoGen (merged into MS Agent Framework, peer GroupChat abandoned), LangChain (supervisor-as-tool replaced supervisor library). Peer-collaboration GroupChat patterns lost ground.
Cost reality is brutal. Multi-agent systems use 15x more tokens than chat; token usage explains 80% of perf variance. Single-agent often matches multi-agent on multi-hop reasoning at equal token budgets — fan-out is only justified when narrow-scope-per-agent is genuinely different work, not parallelized search of the same problem.
Bank "digital factory" case: legacy software modernization with specialized agents (docs, code-gen, peer-review, testing) → 50% dev-time reduction. Validates the agent-flow + orchestration hybrid for production work.

Convergences and contradictions

Vault and web converge sharply on the failure mode. RDCO's existing pipeline-spec/test/code/critic is exactly the agent-flow pattern that survived. The architectural lift to 20-50 fan-out isn't "build a new substrate" — it's "add the queue + adversarial review + dedupe primitives that Glasswing built around its existing pipeline."
The vault's verify- skills (fresh-eyes critic) are already implementing the Glasswing Validate pattern.* Just not at scale. The lift is making Validate run concurrently across many independent findings, not just on single artifacts.
Contradiction with naive scaling intuition: more agents ≠ more capability. The web is unanimous (5-vendor convergence + cost data) that peer-mesh collaboration underperforms orchestrator + isolated subagents at scale. The RDCO pattern of "supervisor + bounded subagents" is the right primitive to extend, not a peer-mesh redesign.
Cost data implies a hard ceiling. At 15x token overhead, scaling pipeline-* fan-out by 10x = 150x token cost vs single-agent baseline. If founder wants 20-50 concurrent at MAC-volume usage, the per-skill cost ceiling needs explicit budgeting, not implicit "spawn more subagents and pray."

Synthesis for RDCO

The 2-3 primitives RDCO needs to add to pipeline- to scale fan-out 10x:*

Recon-style task-queue generator (load-bearing). Today pipeline-* takes a founder ask and runs a fixed 4-stage sequence. To scale, the first stage needs to generate the task queue itself — decompose the ask into N parallel narrow-scope subtasks, each shippable to an isolated subagent. This is the Recon stage from Glasswing. For RDCO concretely:
- /research-brief already does this implicitly when dispatching multiple sub-queries — formalize it as a task-queue file (per-run scratch dir, queue.jsonl).
- /deep-research already dequeues N questions in parallel — same pattern, scale the N.
- New primitive needed for pipeline-* fan-out: a queue.jsonl scratch file per run, with explicit task-class × scope-hint per row, that workers pull from instead of being explicitly invoked.
Adversarial-review at task granularity (not just output granularity). Today the verify-* skills run once on the finished artifact. Glasswing's Validate runs on every individual finding with a deliberately independent prompt + no generative capability. For RDCO: as fan-out scales, every concurrent worker's output should pair with an independent validator subagent. The validator does pure refutation — can't generate new findings, only confirm-or-reject. Cost: doubles agent count, but the [[~/rdco-vault/06-reference/feedback_fresh_eyes_subagent_for_own_artifacts.md]] discipline already says this is required for own-artifact review. Bake it into the pattern, not a separate skill invocation.
Dedupe + Gapfill loop (closes the model-drift gap). As workers fan out, they cluster on the easy/successful patterns. Add a Dedupe pass (collapse findings with identical root causes — for RDCO this is "collapse identical research conclusions across sub-queries" or "collapse identical code patches across critic axes"). Add a Gapfill pass that explicitly re-queues under-covered regions (concretely: if 8/10 sub-queries hit the same conclusion and 2 are silent, the silent regions get re-queued with a different angle).

What NOT to do — three anti-patterns the web validates:

Don't move to peer-mesh collaboration. All 5 vendors abandoned it. The orchestrator + isolated subagents (which RDCO already does via Task tool + general-purpose subagent) is the right primitive. Just extend.
Don't scale fan-out without per-agent cost ceilings. Glasswing has per-task scratch dirs (isolation) but no public per-task budget. RDCO needs explicit per-subagent token caps in the dispatch prompt, otherwise 50 concurrent agents on a runaway prompt becomes the cost-explosion failure mode the vault warned about implicitly.
Don't add bounded-collaboration peer mesh unless the task genuinely requires consensus. It's 15-25x token overhead and is only justified in incident-response-shaped problems. None of RDCO's current pipeline-* work fits this shape.

Concrete 30/60/90 plan if founder wants to actually do this:

30d: Add queue.jsonl scratch-file pattern to one existing pipeline (start with /deep-research since it already has the dequeue shape). Add per-task scratch dir. Document the primitive in a SOP at ~/rdco-vault/02-sops/.
60d: Add concurrent validator subagent per worker output across pipeline-spec/test/code/critic. Measure: does verify-* false-negative rate drop? (Should — adversarial review at finding granularity is more thorough than artifact-level review.)
90d: Add Dedupe + Gapfill stages. Pick the first pipeline skill where fan-out actually reaches 20+ workers to test against. Likely candidate: a new /process-vault-batch style skill that fans 50 docs through a single classifier — large enough to need the primitive, narrow enough to validate cheaply.

Strategic implication for MAC content:

The "how do you actually run 50 concurrent agents reliably" question is exactly the operator-tier content gap MAC targets. The 5-vendor convergence story + the Glasswing architecture breakdown is a Sanity Check piece in its own right. Sanity Check angle: "Everyone converged on the same multi-agent pattern in 2026 — and most of you are still building peer-mesh."

Open follow-ups

What's the actual queue.jsonl spec used by Glasswing? (Cloudflare blog doesn't publish; reasonable to spec our own.)
Does the Anthropic "brain/hands" architecture have a public spec / SDK pattern, or is it only documented in their internal tooling?
How does Cognition's managed-Devin-subagents handle per-subagent cost ceilings? (Public docs unclear; would help RDCO budgeting.)
At what fan-out N does the orchestrator itself become the bottleneck? Glasswing implies ~50 is fine; what's the breakpoint?
Is there a Cloudflare Workers / Sandbox SDK pattern that maps to the per-task scratch dir + isolation primitive, so RDCO could borrow infrastructure instead of building it?

Sources

Vault:

[[01-projects/skill-pipelines/]]
[[06-reference/2026-04-15-thariq-claude-code-session-management-1m-context.md]]
[[06-reference/2026-05-18-agentway-harness-engineering-claude-code-design-guide.md]]
IndyDevDan Pi-to-Pi note (2026-05-18)
/verify-vault-write, /verify-strategic-output, /verify-dispatch SKILL.md

Web: