Individual agentic patterns are powerful on their own, but real-world systems often demand the composition of multiple patterns into unified architectures. The key is to combine patterns deliberately, adding complexity only when the task genuinely requires it.
Principles of Composition
When combining patterns, keep two guidelines in mind. First, start with the simplest pattern that could work and layer on additional patterns only when you hit a clear limitation. Second, define clean interfaces between patterns so that each stage has well-defined inputs and outputs. This makes the overall system easier to debug, test, and maintain.
Example Combinations
Routing + Prompt Chaining
A common composition pairs a router at the front with prompt chains behind each route. Incoming requests are classified by type --- a customer support system might route into billing, technical, or account categories --- and each category triggers a dedicated chain of steps tailored to that domain. The router keeps each chain focused, and the chains keep each step simple.
This works well when your system handles multiple distinct task types that each require multi-step processing. The router eliminates irrelevant context for downstream chains, improving both accuracy and latency.
Orchestrator-Worker + Evaluator-Optimizer
An orchestrator decomposes a complex task into subtasks and delegates them to workers. The results then pass through an evaluator-optimizer loop before the orchestrator assembles the final output. For example, a research agent might break a question into sub-questions, have workers gather evidence for each, and then run each answer through an evaluation step that checks for factual grounding and completeness, iterating until quality thresholds are met.
This combination is especially effective for tasks where quality is more important than speed, such as report generation, code review, or multi-source analysis.
Parallelization + Evaluator-Optimizer
When you need to generate multiple candidate outputs --- alternative designs, varied writing styles, different solution approaches --- you can parallelize the generation step and then feed all candidates into an evaluator that selects or synthesizes the best result. If no candidate meets the bar, the evaluator triggers another round of generation with refined instructions.
This pattern mirrors best-of-N sampling at an architectural level and is useful in creative tasks, optimization problems, and any scenario where exploring diverse options leads to better outcomes.
When to Combine --- and When Not To
Composed architectures introduce additional latency, cost, and failure modes. Before combining patterns, ask whether a single well-crafted prompt or a simple chain already solves the problem. If it does, stop there. Complexity should be the response to a demonstrated need, never a starting assumption.