Parallelize independent agents, serialize only true…
Run independent agents (those with no input dependencies on each other) in parallel to compress total execution time, and serialize only those agents where one genuinely requires the other's output.
Why This Is a Rule
Unnecessary serialization is one of the biggest hidden time costs in cognitive workflows. When steps that could run simultaneously are executed one after another because "that's the order I always do them," the total execution time equals the sum of all steps. When truly independent steps run in parallel, total time equals the longest step — potentially cutting total time by 50% or more.
The criterion is dependency: does step B genuinely require step A's output as input? If yes → serialize (B must wait for A). If no → parallelize (both can run simultaneously). Decouple independent sub-behaviors into separate agents… established this for behavioral agent sub-behaviors. This rule extends it to all cognitive workflow steps: the dependency map (Map agent dependencies and arrange in topological order…) reveals which steps are genuinely dependent and which are merely habitually sequential.
In practice, parallelization of cognitive tasks means interleaving or concurrent processing: start a literature review (runs in background) while outlining the document (active foreground task). Both produce outputs the final writing will need, neither requires the other's output, and running them sequentially doubles the total time for no benefit.
When This Fires
- When optimizing any multi-step workflow for time efficiency
- After mapping dependencies (Map agent dependencies and arrange in topological order…) and discovering steps that are habitually serialized but not dependent
- When total workflow time feels excessive relative to the actual productive work within it
- Complements Map agent dependencies and arrange in topological order… (topological ordering) with the parallel execution optimization
Common Failure Mode
Serializing everything because it's simpler: "First I'll do X, then Y, then Z." If Y doesn't depend on X's output, running X then Y wastes the time during X when Y could have been progressing. The simplicity of linear execution comes at the cost of total duration. For time-sensitive workflows, the dependency analysis (Map agent dependencies and arrange in topological order…) + parallelization is worth the upfront design effort.
The Protocol
(1) From your dependency map (Map agent dependencies and arrange in topological order…), identify sets of agents/steps that have no dependencies on each other. These are candidates for parallel execution. (2) Assess feasibility: can you actually perform these steps concurrently? Some cognitive tasks (writing + reading) compete for the same resource (language processing) and can't truly parallelize. Others (downloading data + outlining a report) use different resources and can. (3) For feasible parallel sets → design concurrent execution. Start both; let whichever finishes first wait for the other if a downstream step needs both outputs. (4) For steps with genuine dependencies → serialize in topological order (Map agent dependencies and arrange in topological order…). Don't try to parallelize what's truly dependent. (5) Visualize the workflow as a DAG (directed acyclic graph): parallel steps are horizontal; dependencies create vertical chains. The critical path (longest serial chain) determines minimum total time.