Agentic Design Patterns: The 2026 Guide + Examples

Most AI agents fail for predictable reasons. They answer from stale training data, they call a tool without checking the result, they ship a sloppy first draft, or they take an irreversible action no one approved. Agentic design patterns exist to fix exactly these failures, one pattern per failure mode.

This guide covers the seven patterns that have become the shared vocabulary of agent engineering in 2026: Reflection, Tool Use, ReAct, Planning, Multi-Agent Collaboration, Evaluator-Optimizer, and Human-in-the-Loop. For each one you get the failure it solves, when to reach for it, and how to build it on a visual canvas in Heym. A symptom-to-pattern table near the end turns the whole thing into a lookup you can use while debugging.

What are agentic design patterns?

Agentic design patterns, also called AI agent design patterns, are reusable architectural approaches for structuring how an AI agent reasons, uses tools, and recovers from its own mistakes. Each pattern is a named answer to a specific weakness of a single LLM call.

A raw language model call has no memory of the outside world, no way to act on it, and no second look at its own output. Patterns add those capabilities back in a structured, repeatable way. Tool Use gives the agent hands. Reflection gives it a second look. Planning gives it a map. Because the patterns are architectural rather than tied to any framework or language, the same seven ideas show up whether you build in LangGraph-style code or on a visual workflow canvas.

The key mental shift: you do not pick one pattern and call it your architecture. You layer the few patterns that solve the failures you can actually see in your agent traces.

Workflows vs agents: the distinction that frames everything

Before the patterns, one boundary decides how much structure you need. In its 2024 Building Effective AI Agents guide, Anthropic split agentic systems into two camps:

• Workflows orchestrate LLMs and tools through predefined code paths that you control.
• Agents let the LLM dynamically direct its own process and tool usage, keeping control over how it reaches the goal.

Workflows are more predictable, cheaper to debug, and easier to trust. Agents are more flexible but harder to constrain. The practical rule: use a workflow when the steps are known in advance, and reach for an agent only when the path genuinely cannot be fixed ahead of time. Several patterns below, like Planning and Evaluator-Optimizer, started life as workflow patterns and now appear inside agents too. Knowing which camp you are in tells you how much autonomy to hand over.

Planning

Decompose

Break the goal into ordered steps

ReAct

Reason + act

Each step picks and runs a tool

Tool Use

Call tools

Live data, APIs, MCP servers

Reflection

Self-check

Evaluator scores the output

ends in

Auto

Return result

Score passes, agent finishes

HITL

Human review

Risky action pauses for approval

The 7 agentic design patterns

1. Reflection

What it is: the agent reviews its own output, finds weaknesses, and revises before returning a final answer. Instead of trusting the first draft, it runs a critique pass on itself.

The failure it fixes: sloppy or hallucinated first drafts. A single forward pass has no opportunity to catch its own errors.

When to use it: when output quality matters more than latency, such as long-form writing, code generation, or analysis where a wrong answer is expensive.

Example: a content agent drafts a section, critiques it for accuracy and tone, then rewrites the weak parts before moving on.

Build it in Heym: add an Eval Agent or LLM-as-Judge node that scores the generator output, then route a failing score through a Loop node so the generator revises until it passes. This is closely related to agent evaluation, where the same scoring idea grades agents offline.

2. Tool Use

What it is: the agent calls external functions, APIs, or data sources instead of answering from memory alone. This is the pattern that turns a text generator into a system that can read live data and take real actions.

The failure it fixes: stale knowledge and inability to act. Training data has a cutoff and cannot run your database query or send your email.

When to use it: almost always. Any agent that needs current information or has to do something in the world depends on Tool Use.

Example: a support agent looks up an order status through an API rather than guessing, then drafts a reply grounded in the real record.

Build it in Heym: the AI Agent node accepts tools three ways. You can attach Python tools, connect any canvas node as a tool by marking its fields with the bot icon, or call an external server with the MCP Call node. The agent decides at runtime which tool to invoke.

3. ReAct

What it is: ReAct interleaves reasoning and acting. The agent thinks about what to do, takes an action, observes the result, then reasons again with that new information. It is Tool Use plus an explicit reasoning loop.

The failure it fixes: blind tool calls. Without ReAct, an agent picks a tool once and cannot adapt when the result surprises it.

When to use it: multi-step tasks where each step depends on what the previous one returned, like research, troubleshooting, or data lookups across systems.

Example: an agent searches, reads the top result, realizes it needs a different query, and searches again, all driven by what it observed.

Build it in Heym: the AI Agent node runs the reason, act, observe loop natively. Give it tools and a clear goal, and it alternates between thinking and calling tools without any custom loop code. ReAct is the most common pattern in production agents because it handles uncertainty gracefully.

4. Planning

What it is: the agent decomposes a complex goal into an ordered set of steps before executing, rather than improvising one action at a time.

The failure it fixes: losing the thread on long tasks. Without a plan, an agent can wander, repeat work, or stop early.

When to use it: complex, multi-step goals where the overall shape of the work matters, such as generating a report or migrating data across several stages.

Example: a research agent first drafts a plan (gather sources, extract themes, write sections, review), then executes each step in turn.

Build it in Heym: enable the orchestrator option on an AI Agent node so it receives a call_sub_agent tool, or add Execute nodes that run specialized sub-workflows for each step. The orchestrator holds the plan while sub-agents do the focused work.

5. Multi-Agent Collaboration

What it is: several specialized agents cooperate, each owning one area of responsibility, coordinated by an orchestrator that distributes work and synthesizes results.

The failure it fixes: one agent overloaded with too many roles, too many tools, or an input too large for a single context window.

When to use it: parallelizable tasks or cross-domain work where specialization beats a single generalist agent.

Example: an analyst agent pulls data, a visualization agent builds charts, and a writer agent produces the summary, all under one orchestrator.

Build it in Heym: build one parent workflow as the orchestrator and one sub-workflow per specialized agent, connected through Execute nodes or the agent's call_sub_agent tool. Heym runs independent sub-agents concurrently. The full breakdown lives in the multi-agent AI systems guide. Shared state across runs is handled by persistent agent memory.

6. Evaluator-Optimizer

What it is: one component generates a response while a separate evaluator scores it against explicit criteria and sends feedback for another attempt. The loop repeats until the output meets the bar or hits a cap.

The failure it fixes: inconsistent quality with no measurable standard. Reflection is self-critique. Evaluator-Optimizer adds a distinct judge and objective criteria, which makes quality measurable rather than vibes-based.

When to use it: when you can write down what "good" means, such as passing tests, matching a schema, or hitting a factual checklist.

Example: a coding agent generates a function, an evaluator runs the test suite, and the failing result drives a revision until the tests pass.

Build it in Heym: pair a generator LLM node with an Eval Agent node that returns a structured pass or fail, then loop on failure with a hard iteration limit. This is the pattern that powers reliable, adversarial AI code review.

7. Human-in-the-Loop

What it is: the agent pauses at high-stakes moments and waits for a person to approve, edit, or reject before continuing.

The failure it fixes: risky autonomous actions. Some decisions, like issuing a refund or sending an external message, should never run unsupervised.

When to use it: any action with real side effects, regulatory weight, or a high cost of being wrong.

Example: a finance agent drafts a payment, then stops for a human to approve anything above a threshold before it executes.

Build it in Heym: enable HITL on the AI Agent node and describe the approval rules in the HITL summary field. The agent receives a request_human_review tool, pauses execution to a pending state at a shareable review URL, runs the review branch immediately, and resumes from the stored snapshot once a reviewer approves. If a later step also needs sign-off, the agent can open another checkpoint.

Which pattern fixes which problem

The fastest way to use this guide is backward: start from the symptom you see in production, then apply the matching pattern. Most competing guides list patterns without connecting them to observable failures. This table is the connection.

Symptom in your traces	Pattern to apply	Heym node
Agent gives outdated or made-up answers	Tool Use	AI Agent with tools, MCP Call
First draft is sloppy and needs cleanup	Reflection	Eval Agent into a Loop
Output quality swings run to run	Evaluator-Optimizer	Eval Agent with pass or fail, Loop
Agent calls tools blindly, never adapts	ReAct	AI Agent node (native loop)
Agent loses track on long, multi-step goals	Planning	Orchestrator agent, Execute nodes
One agent juggles too many roles	Multi-Agent Collaboration	Orchestrator plus sub-workflows
Agent takes risky actions unsupervised	Human-in-the-Loop	Agent HITL review tool
Agent forgets earlier context	Memory (supporting pattern)	Persistent agent memory

Combining patterns in production

No serious agent uses a single pattern. The skill is choosing the smallest stack that covers your failure modes. In the agent traces we review at Heym, the most common mistake I see is reaching for Multi-Agent or Planning first, when the real failure is almost always a missing Tool Use call or an absent Reflection pass. Start narrow and let the traces tell you what to add. Three common recipes:

• Customer support agent: Tool Use to read orders and accounts, ReAct to diagnose the issue step by step, Memory to recall the conversation, and Human-in-the-Loop to gate refunds above a threshold.
• Research agent: Planning to decompose the question, Multi-Agent Collaboration to gather and analyze in parallel, Tool Use for live retrieval, and Reflection to fact-check before delivery. When retrieval itself needs to adapt, this becomes agentic RAG, which the 2025 Agentic RAG survey frames around exactly these patterns.
• Coding agent: Planning to lay out the change, ReAct to execute each step with tools, and Evaluator-Optimizer to re-run tests until they pass.

Start with one pattern that solves your most painful failure. Add a second only when the traces show a second failure. Stacking patterns you do not need adds latency, token cost, and surface area for bugs.

Cost and guardrails

Patterns that loop, like Reflection and Evaluator-Optimizer, multiply token usage, because every revision is another model call. Three guardrails keep that under control:

• Cap iterations. Always set a hard limit on revision loops so a stubborn evaluator cannot spin forever. Heym's Loop node makes the cap explicit.
• Keep nesting shallow. Multi-agent depth compounds cost. Heym allows up to five nested sub-workflow calls, which is enough for almost every real architecture.
• Right-size the model per step. A cheap model can handle Tool Use and routing while a stronger model handles the final synthesis. See AI agent cost optimization for the full breakdown.

The cheapest reliable agent is the one that uses the fewest patterns required to stop failing. Reach for sophistication only after a trace proves you need it.

How to build agentic design patterns in Heym

Every pattern above maps to a node on Heym's visual canvas, so you assemble architectures by connecting nodes instead of writing orchestration code.

Pattern	How to build it in Heym
Tool Use	AI Agent node with Python tools, canvas node tools, or MCP Call
ReAct	AI Agent node, native reason-act-observe loop
Reflection	Eval Agent node feeding a Loop node
Evaluator-Optimizer	Generator LLM plus Eval Agent with pass or fail, capped Loop
Planning	Orchestrator agent (call_sub_agent) or Execute nodes
Multi-Agent	Orchestrator workflow plus one sub-workflow per agent
Human-in-the-Loop	Agent HITL with request_human_review and a review branch

Because all of this runs on one canvas, the execution trace panel shows every reasoning step, tool call, and approval in a single view, which is what turns the patterns from theory into something you can debug. Start from a single AI agent, confirm it works, then layer the next pattern your traces ask for.

FAQ

What are agentic design patterns?

Agentic design patterns are reusable architectural approaches for structuring how an AI agent reasons, uses tools, and recovers from errors. The seven core patterns are Reflection, Tool Use, ReAct, Planning, Multi-Agent Collaboration, Evaluator-Optimizer, and Human-in-the-Loop, and production agents usually combine several of them rather than using one alone.

What is the difference between workflows and agents?

A workflow runs LLMs and tools through predefined code paths you control. An agent lets the LLM direct its own process and tool usage at runtime. Workflows are more predictable, so use them when the steps are known in advance, and use an agent only when the path cannot be fixed ahead of time.

What is the most important agentic design pattern?

Tool Use is the foundation, because it lets the agent read live data and take real actions. ReAct is the most common in production, because it adapts to each observation. Most reliable agents start there and add Reflection or Human-in-the-Loop only where quality or risk requires it.

How many agentic design patterns are there?

The field has converged on seven that cover most production needs, with Memory and prompt chaining as supporting patterns. You rarely need all seven in one agent. Pick the ones that solve a failure you can observe in your traces.

Do I need to write code to implement agentic design patterns?

No. The patterns are architectural, so they work in code or on a visual canvas. In Heym, the AI Agent node covers ReAct and Tool Use, the Eval Agent node covers Evaluator-Optimizer, orchestrator agents and Execute nodes cover Planning and Multi-Agent, and the agent's review tool covers Human-in-the-Loop.

Conclusion

Agentic design patterns are not a checklist to implement top to bottom. They are a vocabulary for fixing specific, observable failures. Tool Use ends stale answers. ReAct ends blind tool calls. Reflection and Evaluator-Optimizer raise quality. Planning and Multi-Agent handle scale. Human-in-the-Loop keeps the risky actions supervised.

The discipline is restraint. Start from a symptom in your traces, apply the one pattern that addresses it, and add the next only when the next failure appears. In Heym, each pattern is a node or a small group of nodes on the canvas, so you can layer them visually and watch every step in the execution trace.

Next step: build a single AI agent foundation first, then study the multi-agent AI systems guide for the orchestration patterns and LLM orchestration for coordinating agents at the pipeline level.

---

References: Anthropic, "Building Effective AI Agents" (2024), anthropic.com/engineering/building-effective-agents; Singh et al., "Agentic Retrieval-Augmented Generation: A Survey on Agentic RAG," arXiv:2501.09136 (2025), arxiv.org/abs/2501.09136.