Parallelization

Two things get called parallelization, and they solve different problems.

Sectioning: split the work

The task divides into independent parts, each handled by its own call, and the results are stitched together. Reviewing a document against six criteria is six calls rather than one prompt juggling six concerns.

const criteria = [
  'accuracy', 'tone', 'completeness',
  'legal', 'clarity', 'length',
]

const reviews = await Promise.all(
  criteria.map((c) => review(document, c))
)

The win is not only latency. Each call gets a clean, narrow context, and a narrow instruction is followed far more reliably than a wide one. A prompt asked to check six things tends to do three of them well.

The requirement is genuine independence. If the legal review needs the accuracy findings, this is prompt chaining wearing a costume, and running it in parallel just loses the dependency.

Voting: ask repeatedly

The same question, several times, then aggregate. Different from sectioning in intent: you are buying confidence rather than speed, and you are spending more calls to get it. When the aggregation is a majority vote, this is self-consistency.

Useful where a single sample is unreliable and being wrong is expensive: classification near a boundary, a security judgement, anything you would want a second opinion on.

Choosing

• Sectioning when the task genuinely decomposes and you want each part done well.
• Voting when the task does not decompose but the answer is high-stakes.
• Neither when the task is small and reliable. Parallelism has real costs in tokens, complexity, and the aggregation step, which is itself somewhere to introduce bugs.