Agent Orchestration Patterns

When building AI agents beyond simple chat, you need orchestration patterns. Here are the most common ones.

Pattern 1: Sequential Pipeline (DAG)

The simplest pattern. Steps execute in order, each using output from the previous.

[Ingest] → [Clean] → [Classify] → [Summarize] → [Deliver]

This is the pattern used by the Agentic Universe pipeline itself — see architecture notes for the full stage-by-stage breakdown.

When to use: Deterministic workflows where each step is predictable. Example: News aggregation pipeline, data processing, ETL with LLM enrichment. Implementation: Plain async/await + direct API calls. No framework needed.

Pattern 2: Router

A classifier routes input to different processing paths based on content.

[Input] → [Router LLM] → Path A (simple)
                        → Path B (complex)
                        → Path C (special handling)

When to use: Different inputs need fundamentally different processing. Example: Customer support (billing vs technical vs general), content moderation. Implementation: One cheap LLM call to classify, then route to appropriate handler.

Pattern 3: Map-Reduce

Process items in parallel, then combine results.

[Input Items] → [Map: Process Each] → [Reduce: Combine]

When to use: Independent items that need individual processing, then synthesis. Example: Multi-document summarization, batch article processing. Implementation: Promise.allSettled() for map, single LLM call for reduce.

Pattern 4: Agent Loop

The agent decides what to do next based on observations.

[Observe] → [Think] → [Act] → [Observe] → ...

When to use: Open-ended tasks where the next step depends on previous results. Example: Coding agents (Claude Code, Cursor), research assistants. Implementation: LangGraph, CrewAI, or custom loop with tool calling.

Pattern 5: Multi-Agent Collaboration

Multiple specialized agents work on different aspects of a task.

[Planner Agent] → assigns tasks to:
  [Researcher Agent] → gathers information
  [Writer Agent] → produces content
  [Reviewer Agent] → checks quality

When to use: Complex tasks with distinct sub-skills. Example: Content creation pipelines, complex analysis. Implementation: CrewAI (role-based), AutoGen (conversational).

Pattern 6: Evaluator-Optimizer

An LLM generates output, another LLM evaluates it, and the first improves.

[Generate] → [Evaluate] → [Improve] → [Evaluate] → ...

When to use: Quality-critical output that benefits from iteration. Example: Code generation with test verification, content with style checking. Implementation: Custom loop with separate judge prompt.

When NOT to Use a Framework

Most production AI systems are Pattern 1 (Sequential Pipeline). If your workflow is:

• A straight line (A then B then C)
• Deterministic (same input = same path)
• No branching or looping

Then plain code is simpler, faster, and easier to debug than any framework. Reserve frameworks for Patterns 4-6 where agent autonomy is genuinely needed.