Why all systems become pipelines
This article is part of a series on agentic systems:
- Agentic systems are struggling to scale (this should feel familiar)
- Agentic systems are still in the artisanal era
- Agentic systems are bound by the same fundamental limits
- Artifacts are compression: how systems handle complexity
- Why all systems become pipelines 👈
- Long-lived systems need modularity
- Designing agentic systems for engineering organizations
- Writing this series with AI: a postmortem
Pipelines are easy to mistake for bureaucracy until the work actually has to survive multiple stages.
Artifacts only work because pipelines exist.
Not every exploratory task needs one, but once work becomes multi-stage, interdependent, and high-consequence, staged flow stops being optional.
NASA’s systems engineering handbook and Anthropic’s guide on building effective agents describe different domains, but both converge on the same point: scaled work moves through explicit stages with different responsibilities and outputs.
Why stages appear
Pipelines are not a stylistic choice; they are a response to how complex work behaves.
| Force | Why it creates stages |
|---|---|
| Specialization | Different stages need different kinds of reasoning |
| Dependency | Some work cannot begin until earlier decisions exist |
| Risk management | Early stages reduce uncertainty before later stages commit resources |
Those pressures keep reappearing even when the vocabulary changes.
Convergence across systems
Software delivery moves from planning to design to implementation to testing to deployment. NASA describes comparable lifecycle stages for systems engineering, while Anthropic describes workflow patterns such as chaining, routing, orchestrator-workers, and evaluator loops. The vocabulary changes, but the requirement does not: multi-stage work needs explicit transitions.
The canonical flow
While terminology varies, most systems still look broadly like this:
graph LR
Research --> Planning --> Design --> Implementation --> Testing --> Deployment --> Support
Each stage consumes an artifact, transforms it, and emits a new artifact for the next stage.
Pipelines matter because they are not just sequences of tasks. They are coordination mechanisms for turning one usable representation of work into the next.
Where agentic systems drift
Many agentic systems still ignore this shape. They rely on:
- A single agent handling multiple stages
- Loosely defined transitions between steps
- Minimal separation between planning and execution
It can look flexible in a demo, but it scales poorly. Work loops, direction drifts, and validation gets deferred.
Anthropic explicitly recommends simple, composable patterns instead of unnecessary framework complexity for exactly this reason.
Security is another reason stages appear
Prompt injection makes the security case concrete. OWASP treats indirect prompt injection as a major risk for systems that read external content and recommends least-privilege access plus human approval for high-risk actions.
That principle should already feel familiar from human systems. NIST recommends only giving users, or processes acting on their behalf, the least privilege needed for assigned tasks. In practice, a stage that reads broadly from untrusted sources should produce an artifact, not take broad write actions; review happens there, and only later stages get narrower permissions.
What pipelines still do not solve
A pipeline explains how work moves. It does not explain why that flow survives change.
Stages can be clear and still remain fragile if their meaning lives in one operator, one model, or one transcript. Durability comes from boundaries that can survive changing tools, teams, and requirements.