Agent Orchestration

A single prompt that asks an AI to research, analyse, and write simultaneously forces competing objectives into the same context window. The model must allocate attention between finding information, evaluating it critically, and presenting it engagingly — three tasks that benefit from different temperatures, instruction sets, and evaluation criteria. The result is typically mediocre at all three because the model compromises between conflicting requirements.

Orchestration solves this by task decomposition. A research agent searches broadly with instructions optimised for coverage and source quality. An analysis agent receives the researcher's structured output and applies critical frameworks with instructions optimised for rigour. A writing agent receives the analysis and crafts the final deliverable with instructions optimised for clarity and audience fit. Each agent excels at its narrow task because it doesn't have to compromise.

The quality improvement from orchestration is most noticeable on tasks where the sub-tasks have fundamentally different character. Research requires breadth and curiosity; analysis requires scepticism and precision; writing requires empathy and clarity. Forcing a single prompt to embody all three stances simultaneously dilutes each one.

Sequential pipelines are the simplest pattern: Agent A's output feeds Agent B, whose output feeds Agent C. This works well for linear workflows like research-then-analyse-then-write. The orchestrator passes structured data between stages and handles errors at each transition point. Most teams start with sequential pipelines because they're easy to understand, debug, and extend.

Parallel fan-out runs multiple agents simultaneously on different aspects of the same task — for example, three agents each researching a different competitor — and a synthesis agent combines their findings. This pattern reduces latency for tasks that are naturally parallelisable and can produce more comprehensive results than a single sequential pass.

Iterative refinement loops an output through a critic agent that evaluates quality and sends it back for revision. The loop continues until the critic's score exceeds a threshold or a maximum iteration count is reached. This pattern is particularly effective for writing, code generation, and any task where quality can be assessed programmatically. The risk is that undisciplined iteration loops can consume significant resources without converging on improvement.

Hierarchical orchestration introduces supervisor agents that manage sub-teams. A project manager agent decomposes a complex task into subtasks, assigns them to specialist agents, reviews their outputs, and assembles the final deliverable. This mirrors how human teams operate and scales to tasks that would be unmanageable in a flat pipeline. Frameworks like CrewAI are specifically designed to support this hierarchical pattern.

The most common failure is over-engineering. Not every task benefits from multiple agents. If a single well-crafted prompt produces acceptable results, adding orchestration complexity increases cost, latency, and maintenance burden without proportional quality improvement. Orchestration should be introduced when single-prompt attempts demonstrably fail, not as a default architecture for every AI workflow.

Poor handoff design is another frequent issue. When agents pass unstructured text between stages, each handoff loses information and introduces interpretation errors. Effective orchestration defines structured interfaces between agents — typed fields, expected formats, and validation rules — so downstream agents receive clean, unambiguous inputs. This is the same principle behind A2A protocols applied at the workflow design level.

Debugging complexity grows nonlinearly with the number of agents. When a three-agent pipeline produces a bad output, determining which agent introduced the error requires inspecting intermediate outputs at each handoff. Without structured logging and intermediate output capture, debugging multi-agent workflows can be harder than debugging the equivalent single-prompt approach.

Cost escalation is often underestimated. Each agent in the pipeline makes at least one API call, and iterative patterns multiply that cost. A five-agent pipeline with one refinement loop each makes at least ten API calls per task. At production scale, the cost difference between a single-prompt approach and an orchestrated pipeline can be an order of magnitude. The quality improvement must justify this cost differential.

The handoff between agents is where most orchestration quality is won or lost. A well-designed handoff includes a structured output schema from the sending agent, validation logic that rejects malformed outputs before they reach the next agent, and a clear specification of what the receiving agent should do with each field. Treating handoffs as formal interfaces rather than informal text passing prevents the degradation that accumulates across multi-agent pipelines.

Context compression at handoffs is equally important. The research agent may produce ten pages of raw findings, but the analysis agent only needs a structured summary with key data points, source references, and confidence indicators. Passing the full raw output wastes context window space and forces the analysis agent to extract the relevant information itself — a task it may perform inconsistently. The orchestrator should define what gets passed forward and what gets archived for later reference.

Error handling at handoffs determines whether the pipeline fails gracefully or cascades. If the research agent produces incomplete results, the orchestrator should decide whether to proceed with partial data, retry with modified search parameters, or flag the gap for human review. Defining these failure policies at each handoff point before building the pipeline prevents ad-hoc error handling that leads to silent data loss.

In a single-agent system, debugging is straightforward: examine the prompt, the model's response, and the output. In an orchestrated system, the same bug might originate in any agent, at any handoff, or in the orchestrator's routing logic. Without observability — structured logs of each agent's inputs, outputs, reasoning traces, and execution timing — diagnosing problems requires manually replaying the entire pipeline, which is slow and often non-reproducible due to model non-determinism.

Effective observability captures three levels: the macro level (overall pipeline execution time, total cost, final output quality), the agent level (each agent's input, output, token usage, and latency), and the handoff level (what data was passed between agents, whether validation succeeded, and what was filtered or compressed). Tracing frameworks that assign a single trace ID to a pipeline run and attach all agent-level events to that trace make it possible to reconstruct the full execution path for any given output.

Observability also enables continuous improvement. By analysing patterns across hundreds of pipeline runs — which agent is the bottleneck, which handoff has the highest error rate, which agent's output quality varies most — teams can target their optimisation efforts on the components that will produce the largest overall improvement. Without this data, optimisation is guesswork.