The agentic design patterns directory

Each pattern links to the source this directory treats as most authoritative. The patterns are grouped into four families: single-agent core workflows, advanced capability and planning, multi-agent orchestration, and production reliability and safety.

Core workflows and basic reasoning (single-agent)

The foundational atomic building blocks.

• Single Augmented Agent: The baseline architecture. A single model loop equipped with memory, system instructions, and external tool attachments.
• Prompt Chaining: A linear workflow where a complex task is broken into a series of sequential LLM steps. The structured output of Step A directly populates the input prompt of Step B.
• Routing (Classifier-Dispatcher): A router — a lightweight LLM or a programmatic rule — evaluates an incoming request and directs it to a specialised agent, prompt template, or downstream pipeline.
• Parallelization / Fan-Out (Scatter-Gather): Spawning multiple independent LLM or agent processes to run simultaneously, then running a final synthesis step to merge their outputs.
• ReAct (Reason + Act): The iterative loop where the model explicitly alternates between writing its internal reasoning (Thought) and calling external APIs (Action) to process real-time outcomes (Observation).
• Tool Use: The agent calls external APIs, code executors, or proprietary data sources to access information absent from the model weights. A foundational building block for most other patterns.
• Perception-Reasoning-Action (PRA): Divides the agent workflow into three explicit stages — Perception handles raw input from sensors, APIs, or prompts; Reasoning selects the best course of action; Action executes outputs or triggers commands. Clear stage separation improves traceability and control.

Advanced capability and planning

Long-running jobs, over hours or days, that separate strategic thinking from execution.

• Plan-and-Execute (Planner-Worker Separation): Decouples strategy from execution. A planner generates a complete multi-step checklist upfront; an executor takes each item in sequence, triggering a replan only if a step fails outright.
• Dynamic Task-Ledger: An advanced variant of Plan-and-Execute where the agent maintains a live, stateful to-do list — writing new sub-tasks, deleting obsolete steps, and re-prioritising items on the fly as new data arrives.
• Reflection / Self-Correction (Reflect-Refine): A dual-prompt loop where the agent generates a draft, triggers a separate self-critique prompt that evaluates constraints such as correctness, style, and safety, and iterates before producing a final result.
• Streaming: A workflow designed to lower perceived latency. It emits real-time token streams, intermediate thought blocks, or live tool-invocation logs while background loops keep running.
• Memory Management: Lets an agent hold state across interactions — storing past exchanges, user preferences, and task progress across episodic, semantic, and procedural layers. Broader than RAG: this pattern also writes, updates, and evicts stored context.
• Learning & Adaptation: Agents that improve over time from accumulated experience across runs — distinct from Reflection, which only self-corrects within a single session. Enables long-term behavioural adjustment from outcomes, feedback, and environmental signals.
• Context Engineering: The deliberate selection, compression, and isolation of what enters the context window at runtime. Tackles the “lost-in-the-middle” problem in long-running agents by keeping high-value state present and evicting stale data.

Multi-agent orchestration and collaboration

Multiple agents with specialised domain knowledge.

• Orchestrator-Workers: A centralised supervisor breaks down a macro-goal, assigns distinct sub-tasks to isolated worker agents (each with its own instructions and tools), gathers their outputs, and produces a unified response.
• Handoff (Conversational Routing): A decentralised, linear pattern where Agent A finishes its task and explicitly ends its own loop by passing the active state and conversation history forward to Agent B.
• Group Chat: A shared-state environment where several independent agents communicate within one collective thread, reading and replying to each other to resolve a problem together.
• Evaluator-Optimizer (Generator-Judge): A strict dual-agent setup — a generator creates a complex deliverable and a separate evaluator acts as a harsh critic or test runner, rejecting the work until it passes strict quality criteria.
• Swarm / Mesh Network: A fully decentralised architecture where autonomous agents hand off sub-tasks dynamically, with no top-down manager or rigid DAG, reacting to peer-to-peer state signals.
• DAG (Directed Acyclic Graph) Orchestration: A rigid, deterministic state graph where tasks run along hard-coded paths. Parallel execution and conditional branching are handled through strict state-transition criteria.

Production, reliability and safety governance

Scalable, enterprise-grade production systems.

• Human-in-the-Loop (HITL): Intermittent human checkpoints that pause the autonomous loop at high-stakes boundaries — executing a financial transaction, merging code — to wait for manual approval or guidance.
• Model-to-Model Guardrails: Fast, specialised models placed on both sides of the agent loop to filter incoming prompt injections and sanitise outgoing responses before they reach the user.
• Inference-Time Scaling (Reasoning Compute): Allocating heavier compute and tokens — via Tree-of-Thoughts or Best-of-N sampling — at critical decision nodes, while defaulting to faster processing for simple tasks.
• Tool Capability Compartmentalization: Isolating high-risk tool operations such as terminal execution or database writes inside ephemeral, short-lived secure virtual machines or containers.
• RAG Grounding & Vector Cache: Tying agent execution to a deterministic retrieval pipeline so context stays grounded in factual documents with explicit provenance and source tracking.
• Bounded Execution / Circuit Breaker: Hard limits on iteration count, token spend, or wall-clock time that automatically halt a runaway loop — preventing infinite reflection cycles, cost overruns, and cascading failures.

Sources

The canonical reference behind each pattern above, deduplicated.

• Anthropic — Building effective agents
• ReAct: Synergizing reasoning and acting in language models (arXiv)
• DeepLearning.AI — Agentic AI
• Augment Code — Agentic design patterns
• LangChain — Plan-and-execute agents
• LangGraph — Memory
• LangChain — Context engineering for agents
• OpenAI — Swarm
• Microsoft — AutoGen
• LangGraph — Documentation
• LangGraph — Human-in-the-loop
• Tree of Thoughts: Deliberate problem solving with large language models (arXiv)
• Retrieval-augmented generation for knowledge-intensive NLP tasks (arXiv)