Agent orchestration vs workflow automation: what's the difference?

Every few weeks, someone asks why Modulo is not built on Temporal, n8n, or LangGraph. The question makes sense on the surface - all of them orchestrate things. But workflow automation and agent orchestration serve fundamentally different purposes, and choosing the wrong one for your use case leads to a platform that does everything except what you actually need.

What workflow tools do

Workflow tools (Temporal, n8n, Airflow, Prefect, LangGraph) are designed for task sequencing and state management. They answer questions like:

Did step A complete before step B started?
If step C fails, should we retry or abort?
What is the current state of this long-running process?
How do we distribute work across workers?

These are important questions. They are also generic. A workflow tool does not know whether step A is "run a linter" or "charge a credit card" - it just knows that step A must finish before step B starts. This generality is a strength for infrastructure teams building custom pipelines, but it is a weakness when what you need is governance, not just sequencing.

What agent orchestration does

Agent orchestration answers a different set of questions:

Did the agent produce output that matches the expected schema?
Should this output be reviewed by a human before it reaches production?
What evidence supports the agent's decisions?
How do we know this agent is ready for more autonomy?
What happened in every run, and can we reproduce it?

These are governance questions. They are specific to the domain of AI agents producing work that affects production systems. A workflow tool can sequence the steps, but it cannot evaluate the output, enforce a gate, maintain an immutable audit trail, or progressively grant autonomy based on evidence.

The practical difference

Consider a concrete example. An agent writes a pull request. A workflow tool can:

Trigger when the PR is opened
Run the agent
Wait for the agent to finish
Post the result back to the PR

An agent orchestrator can:

Trigger when the PR is opened
Run the agent in an isolated sandbox
Validate the agent's output against a schema
Run deterministic gates (regex, schema check, scored eval)
If a gate fails, spawn a correction run with the gate's evidence attached
If all gates pass, present the evidence to a human reviewer
Record every decision in an immutable audit trail
Track whether this type of change has a history of passing gates, and adjust autonomy accordingly

Steps 3 through 8 are what make the difference between an agent that ran and an agent that ran with evidence, review, and a verifiable record.

Why Modulo is not built on a workflow tool

Modulo's pipeline model looks like a workflow on the surface - nodes connected by edges, triggers, conditions. But the semantics of each node are specific to agent governance: sandbox agent execution, schema validation, deterministic gates, HITL review, audit recording, autonomy adjustment. These are governance primitives, not generic workflow steps.

Building Modulo on Temporal or n8n would mean implementing every governance primitive as a custom extension on top of a generic engine. The result would be a less coherent system with more surface area for bugs and a harder time providing the guarantees that governance requires - immutability, reproducibility, evidence attachment.

The principle behind this: deterministic gates catch failures before they reach a human reviewer, and audit as a first-class output means the history you inspect is exactly what happened.