Parallelisation (Sectioning & Voting)
Run multiple LLM calls concurrently, either on independent sub-tasks (sectioning) or the same task multiple times (voting), then aggregate.
This page is the complete instruction page for one pattern called "Parallelisation (Sectioning & Voting)." It explains the problem this pattern solves, the idea behind the solution, when you should (and should not) use it, and what happens afterward, both the good effects and the costs.
This matters because building AI agents is not just about making them clever. It is also about making them safe and predictable. Following a well-tested pattern like this one helps avoid common mistakes, and shows you exactly which safety rules and regulations it connects to, listed under "Standards Mesh" on this page.
Context
Some tasks split cleanly into independent parts. Others benefit from diversity: running the same prompt multiple times and taking the majority or best.
Problem
Sequential execution wastes wall time; single-shot generation misses easy quality lift from diversity.
Forces
- Cost vs latency vs quality
- Aggregation logic complexity
Solution
Sectioning: split the task into independent sub-tasks, run in parallel, aggregate programmatically. Voting: run the same task N times, combine via majority, best-of-N, or consensus. Both use programmatic aggregation, not a model call, where possible.
Where this pattern acts in the two lifecycles
04 Act. Tool call, API invocation, environment mutation. 15 of 61 catalogue patterns act at this stage.
04 Deploy. Staged rollout, sandboxing, whitelisting. 9 of 61 catalogue patterns act at this stage.
Stages and counts from the catalogue data. The Runtime lens is the loop the agent runs each turn; the AgentOps lens is the lifecycle the team runs the agent through. See the Matrix for every pattern at each stage.
Applicability
- Document analysis over many sections
- Safety-critical classification (voting reduces error)
- Time-sensitive workflows
Anti-Patterns
- Voting on tasks with no clear aggregation rule
- Parallelising tasks that share state
Consequences
- +Lower wall-clock latency
- +Voting improves accuracy on classification tasks
- −Multiplicative cost
- −Aggregation logic can hide errors
