AT-201a · Module 2
Pipeline Orchestration
3 min read
A pipeline is a sequential chain: Agent A produces output that Agent B consumes, which produces output that Agent C consumes. Each stage transforms the data. Research produces raw findings. Drafting produces prose. Review produces feedback. Formatting produces the final deliverable. The pipeline is the right topology when the work has a natural order that cannot be parallelized — each stage genuinely depends on the previous stage's output.
The coordinator's role in a pipeline is stage management. It does not just pass Agent A's output blindly to Agent B. Between each stage, the coordinator extracts the relevant data, formats it for the next agent's input contract, and verifies that the output from the previous stage meets the quality threshold to proceed. This intermediate processing is the pipeline's quality assurance — it prevents bad data from cascading through subsequent stages.
Pipeline orchestration has a critical timing consideration: stage latency compounds. If each stage takes 2 minutes, a 4-stage pipeline takes 8 minutes minimum. There is no parallelism to speed this up because each stage depends on the previous one. The way to optimize pipeline latency is to optimize individual stage performance — tighter prompts, smaller context, more focused specialists — rather than adding more agents.
The other optimization is knowing when to short-circuit. If stage one (research) returns empty results, there is no point running stage two (drafting). The coordinator should detect the empty result, report the failure, and offer to retry with different parameters. Short-circuiting saves time and tokens on work that was doomed from the start.
Do This
- Use pipelines when each stage transforms the data in a way the next stage depends on
- Have the coordinator process data between stages — extract, format, and verify
- Short-circuit on failure — do not run the draft stage if research returned nothing
- Optimize individual stage performance rather than adding parallel stages
Avoid This
- Use a pipeline for independent tasks — that is fan-out, not pipeline
- Pass raw output from one agent to the next without coordinator processing
- Let failures cascade through all stages before discovering the problem
- Add stages to improve quality — improve individual stages instead