ChatGPT 
Summary
Key takeaways
- Agentic design patterns provide reusable ways to structure AI systems that can reason, use tools, maintain state, and complete multi-step work.
- ReAct is one of the foundational patterns because it alternates reasoning with actions and observations instead of trying to solve the entire task in one model response.
- Planning patterns separate task decomposition from execution, making complex workflows easier to inspect, control, and recover when individual steps fail.
- Reflection and critique patterns let an agent review its own output or use a separate evaluator before accepting a result.
- Tool-use patterns are most reliable when tools have typed schemas, strict permissions, predictable outputs, and clearly defined failure behavior.
- Human-in-the-loop patterns are essential for high-risk or irreversible actions such as payments, account changes, production operations, or regulated decisions.
- Multi-agent systems are useful when work naturally divides into specialized roles, but they add orchestration, latency, cost, and debugging complexity.
- Memory should be designed deliberately because working state, conversation context, retrieved knowledge, and long-term user memory solve different problems.
- Production agents need explicit stopping conditions, retry rules, fallback paths, and escalation behavior rather than an unrestricted autonomous loop.
- The best agentic architecture is usually the simplest pattern that can reliably complete the target workflow, not the system with the largest number of agents or reasoning steps.
When this applies
This applies when an AI system must do more than generate a single response and instead needs to plan, retrieve context, call tools, maintain state, evaluate intermediate results, or complete a workflow across several steps. It is especially relevant for customer operations, research assistants, coding agents, enterprise workflows, RAG systems with tool use, and applications where an agent must interact with APIs or internal systems. Agentic design patterns are also useful when teams need a repeatable way to introduce approvals, retries, reflection, delegation, and recovery into production AI systems.
When this does not apply
Agentic patterns are often unnecessary when the task can be solved reliably with one model call, deterministic application logic, a simple RAG pipeline, or a conventional workflow engine. Adding planning, reflection, memory, or multiple agents to a simple task can increase latency, token cost, failure surface, and operational complexity without improving the outcome. High autonomy is also inappropriate when the system cannot safely recover from incorrect actions or when every important decision already requires deterministic business rules.
Checklist
- Define the exact business task the agent must complete from start to finish.
- Determine whether the task actually requires an agent rather than a deterministic workflow or single LLM call.
- Break the workflow into explicit states, actions, and stopping conditions.
- Choose the simplest agentic pattern that can handle the required level of complexity.
- Define which decisions are made by the model and which remain deterministic.
- Wrap every external tool in a typed and validated interface.
- Apply least-privilege permissions to each tool and data source.
- Separate read-only tools from operations that change external state.
- Add idempotency and duplicate-prevention rules for state-changing actions.
- Define retry limits, timeout behavior, fallbacks, and exception handling.
- Add human approval gates for high-risk, irreversible, or low-confidence actions.
- Choose the correct type of memory for task state, retrieval, conversation, or long-term context.
- Log reasoning-relevant state transitions, tool calls, failures, approvals, and final outcomes.
- Build evaluation sets that test successful paths, edge cases, unsafe actions, and recovery behavior.
- Measure task completion, reliability, latency, cost, escalation rate, and human override rate before increasing autonomy.
Common pitfalls
- Using an autonomous agent for a problem that deterministic software could solve more reliably.
- Adding multiple agents when one orchestrated agent would be easier to test and operate.
- Allowing unrestricted reasoning loops without clear stopping conditions or budget limits.
- Giving tools broad permissions because the agent is expected to decide what is safe.
- Retrying external actions without checking whether the previous attempt already succeeded.
- Using long-term memory for information that should instead come from an authoritative system of record.
- Adding reflection loops without measuring whether they actually improve output quality enough to justify the extra cost.
- Letting agents perform irreversible actions without human approval or rollback mechanisms.
- Evaluating only final answer quality while ignoring tool selection, routing, recovery, and unsafe-action prevention.
- Increasing architectural complexity before a simpler agentic pattern has been tested against real production workflows.
Quick answer
Agentic design patterns are reusable ways to arrange model calls, tools, memory and checks so an AI system can finish a multi-step task. The Uvik Software Agent Pattern Map lists 12 patterns in 4 groups: workflow, agent, multi-agent and control. Each pattern prevents one failure mode. Pick the simplest pattern that passes your evaluation set.
Key findings
- The Uvik Software Agent Pattern Map gives 12 patterns, with the failure mode, the extra model calls and the production control for each.
- Anthropic measured that multi-agent systems use about 15 times more tokens than chats. Uvik Software ships a multi-agent design only when it beats a single agent on the same evaluation set.
- In a Uvik Software case study, guarded tool use cut Sierra’s agent wrong-action rate from 6.2% to 0.7%.
- In the Uvik Software AI Prototype-to-Production Failure Database 2026, 12 of 14 public failure records lacked human approval or accountable review.
What are agentic design patterns?
Short answer
Agentic design patterns are reusable shapes for AI systems that plan, call tools and check their work. Andrew Ng named 4 in 2024: reflection, tool use, planning and multi-agent collaboration. Anthropic added 5 workflow patterns. Uvik Software combines them into 12 patterns and gives each one a failure mode and a control.
Uvik Software defines an agentic design pattern as a reusable arrangement of model calls, tools, memory and checks for one class of multi-step task. Other names are agentic AI design patterns and AI agent design patterns.
Anthropic’s guide to building effective agents (December 2024) splits agentic systems into workflows and agents. “Workflows are systems where LLMs and tools are orchestrated through predefined code paths.” In agents, LLMs “dynamically direct their own processes and tool usage”.
In March 2024, Andrew Ng reported zero-shot HumanEval coding scores of 48.1% for GPT-3.5 and 67.0% for GPT-4. In an agent loop, GPT-3.5 reached up to 95.1%. Antonio Gullí’s 2025 book Agentic Design Patterns catalogs 21 patterns.
The Uvik Software Agent Pattern Map: 12 agentic design patterns
Short answer
The Uvik Software Agent Pattern Map lists 12 agentic design patterns in 4 groups. For each pattern, it gives the best use, the failure mode it prevents, the extra model calls and the production control Uvik Software adds. Use it to design a new agent or review a live one.
| # | Pattern | Use it when | Failure it prevents | Uvik Software production control | Extra model calls |
|---|---|---|---|---|---|
| 1 | Prompt chaining | The task splits into fixed steps | One overloaded call skips steps | A check between steps stops the chain | 1 per step |
| 2 | Routing | Inputs fall into clear classes | One prompt handles every input badly | Confidence threshold; low scores go to a person | +1 classifier call |
| 3 | Parallelization | Subtasks are independent or need votes | Slow serial work; single-sample errors | Timeout per branch; merge rules in code | 1 per branch |
| 4 | Evaluator and optimizer | Clear pass criteria exist | Unchecked output reaches users | Round limit; judge calibrated to human labels | +2 per round |
| 5 | Tool use | The task needs live data or actions | Invented facts and invented actions | Typed tool contracts; permission check at call time | +1 per tool turn |
| 6 | Planning | Steps are unknown at the start | Lost or repeated steps in long tasks | Plan saved as state; step and cost limits | +1 per plan |
| 7 | Reflection | An external test can check the output | First-draft errors | Critique backed by a test, schema or citation | +2 per round |
| 8 | Orchestrator and workers | The task is wide, with many subtasks | Context overload in one agent | Bounded subtasks; workers return summaries | 1 plan, N workers, 1 merge |
| 9 | Supervisor and hierarchy | One agent has too many tools or domains | Wrong tool or domain choice | One owner per resource; shared state in the graph | +1 per hop |
| 10 | Memory | Work spans steps, sessions or users | Lost state; stale or leaked facts | Checkpoints; scoped namespaces; source, date and expiry | 0 to 1 per write |
| 11 | Human approval | An action moves money or reaches customers | Unreviewed high-risk actions | Durable interrupt; expired approval fails closed | 0 (adds wait time) |
| 12 | Guardrails | Untrusted input or high-impact output | Prompt injection; off-policy output | Input, tool-call and output checks; rules before models | 0 (rules) or +1 |
Source: Uvik Software Agent Pattern Map, October 2026. Extra model calls follow from each pattern’s structure, not from measurements. CC BY 4.0, credit Uvik Software.
Figure 1. The Uvik Software Agent Pattern Map: 12 agentic design patterns and the failure mode each one prevents. Source: Uvik Software, October 2026.
Each control maps to the Uvik Software Harness Checklist. The pattern sets the shape of the work, and the harness keeps it safe. Price the extra calls with the Uvik Software AI agent cost guide.
Workflow patterns: chaining, routing, parallelization and evaluation
Short answer
Workflow patterns keep control in your code. Prompt chaining runs fixed steps in order. Routing sends each input to a specialist path. Parallelization runs independent calls at once, and an evaluator checks output against criteria. Uvik Software builds most business processes as workflows, because they are cheaper to test, trace and audit.
Prompt chaining. Each LLM call “processes the output of the previous one” (Anthropic). Uvik Software puts a check between steps. In a Uvik Software case study for a B2B workflow platform, each state transition is logged, testable and replayable. Manual triage fell from 18 to 3.6 minutes.
Routing. In the Uvik Software case study for Alan, high-confidence claims settle automatically and the rest go to a human queue. Claims processed without human review rose from 31% to 78%.
Parallelization. In the Uvik Software case study for Parloa, transcription, reasoning and speech run concurrently. The p95 response gap on live calls fell from 1.9 seconds to 280 ms.
Evaluator and optimizer. Anthropic recommends this loop “when we have clear evaluation criteria”. In the Uvik Software case study for Harness, each proposed fix runs in an isolated pipeline before an engineer sees it. 61% of the fixes are accepted unedited.
Agent patterns: tool use, planning and reflection
Short answer
Agent patterns let the model choose the next step. Tool use connects the model to live data and actions, planning breaks open-ended work into steps, and reflection makes the model critique its own draft. Uvik Software adds typed tool contracts, saved plans and external tests, because a loop repeats every unchecked error.
The base loop is ReAct (2022): the model writes “reasoning traces and task-specific actions in an interleaved manner”. Anthropic warns that agent autonomy “means higher costs, and the potential for compounding errors.”
Tool use. Tools let an agent act on real systems. In the Uvik Software case study for Sierra, every action became a typed schema with a policy check before execution. The wrong-action rate fell from 6.2% to 0.7%. For shared tools, Uvik Software builds MCP servers.
Planning. The agent writes a plan, executes it and revises it. Uvik Software saves the plan as state, outside the context window. In the Uvik Software case study for Glean, checkpointed runs stopped re-planning from the start. Multi-step p95 latency fell from 22 to 5 seconds.
Reflection. Reflexion agents keep feedback in an episodic memory buffer and reached 91% pass@1 on HumanEval, against 80% for GPT-4. Uvik Software accepts a self-critique only when a test, a schema or a citation check backs it.
What is agent orchestration?
Short answer
Agent orchestration decides which agent or step runs next, with what context, under which limits and when the run stops. Code can orchestrate, as in workflows, or a model can, as an orchestrator, supervisor or manager agent. Uvik Software orchestrates in code by default and lets a model decide only where steps cannot be listed in advance.
Uvik Software defines agent orchestration as the control of order, context, limits and stopping across agents and steps. The OpenAI Agents SDK docs agree: “Orchestration refers to the flow of agents in your app”. Uvik Software calls the shared layer of policies, approvals, budgets and traces the agentic control plane.
The Uvik Software framework crosswalk maps the names each framework uses.
| Pattern | Who picks the next step | Names in frameworks | Main failure mode | Uvik Software control |
|---|---|---|---|---|
| Sequential pipeline | Your code | Prompt chaining (Anthropic); sequential (Microsoft); sequential workflow (Google ADK) | A bad step passes downstream | Check between steps |
| Parallel fan-out | Your code | Parallelization (Anthropic); concurrent (Microsoft); parallel workflow (Google ADK) | Conflicting or duplicate results | Merge rules; timeout per branch |
| Routing and handoff | A classifier or triage agent | Routing (Anthropic); handoffs (OpenAI); handoff (Microsoft) | Misroute; context lost at handoff | Confidence threshold; full context at handoff |
| Orchestrator and workers | A lead model | Orchestrator-workers (Anthropic); manager with agents as tools (OpenAI); supervisor or subagents (LangGraph); magentic (Microsoft); coordinator (Google ADK) | Context overload; duplicate work | Bounded tasks; summaries back to the lead |
| Hierarchical teams | Supervisors of supervisors | Hierarchical systems (LangGraph supervisor library) | Slow, costly delegation chains | 2 levels at most |
| Group chat | Agents in one shared thread | Group chat (Microsoft) | Loops; conflicting decisions | Turn cap; one writer per resource |
Anthropic’s multi-agent research system uses a Claude Opus 4 lead with Claude Sonnet 4 subagents. It beat a single Claude Opus 4 agent by 90.2% on an internal eval. It also used about 15 times more tokens than a chat.
When should you use a multi-agent system?
Uvik Software uses several agents in 3 cases. The task is wide, one agent has too many tools, or parts of the work need separate permissions. Otherwise, one agent with good tools is cheaper and easier to test.
Anthropic names the poor fits: domains where all agents must “share the same context”, or with “many dependencies between agents”. Cognition gives similar advice: “Share context, and share full agent traces”. The MAST study annotated over 1,600 traces from 7 frameworks. It found 14 failure modes in 3 categories: system design, inter-agent misalignment and task verification.
In the Uvik Software case study for Zip, classification, policy lookup and approver resolution run as separate agent roles in one LangGraph graph. Cycle time fell from 11 days to 2 days, and rollbacks from 5.8% to 0.4% of runs. In the ClaimArc case study, intake, policy reasoning and routing agents cut manual document review by 35% to 50% on standard claims.
Uvik Software uses LangGraph as the default for production agents. The Uvik Software comparison of agentic AI frameworks covers 17 frameworks, and LangChain vs LangGraph explains the split.
Get your agent design reviewed by Uvik Software. Senior Uvik Software engineers map your agent to the 12 patterns, flag missing controls and send a prioritized fix list. Request a pattern review
What is AI agent memory?
Short answer
AI agent memory is the information an agent keeps beyond one model call. Uvik Software splits it into 3 layers: working memory in the context window, short-term state for one run or thread, and long-term memory across sessions. Long-term memory holds semantic facts, episodic experiences and procedural rules. Each layer needs scope, provenance and expiry.
Uvik Software defines AI agent memory as everything an agent can recall that is not in its current prompt. Working, episodic, semantic and procedural memory come from the CoALA paper. In CoALA, “episodic memory stores experience from earlier decision cycles”, and “semantic memory stores an agent’s knowledge about the world and itself.”
| Memory type | What it holds | Where Uvik Software keeps it | Failure mode | Uvik Software control |
|---|---|---|---|---|
| Working memory | Prompt, recent messages, tool results | Context window | Context rot; lost instructions | Token budget per source; compaction |
| Short-term state | Plan, progress and pending approvals | Checkpoint store | A crash restarts the task | Checkpoint after each step |
| Semantic memory | Facts and user profiles | Namespaced store with vector search | Stale or wrong facts | Source and date per fact; update, not append |
| Episodic memory | Past runs, examples and outcomes | Trace store and example index | A past mistake repeats | Keep only reviewed episodes |
| Procedural memory | System prompts, skills and tool rules | Versioned prompt and skill files | Silent behavior drift | Review and version before release |
Figure 2. The Uvik Software agent memory model: 3 memory layers and the controls Uvik Software adds. Source: Uvik Software, October 2026, after CoALA and LangGraph.
Write memory in the background where you can. The LangGraph memory documentation notes that deciding what to save in the hot path “can impact agent latency”.
In the Uvik Software case study for Trunk Tools, revision-aware retrieval cut answers from a superseded document revision from 12% to 0%. Glean checkpoints let 94% of interrupted runs resume. For retrieval design, read RAG architecture in 2026.
Control patterns: human approval and guardrails
Short answer
Control patterns limit what any agent may do. Human approval pauses a run before a high-risk action, and guardrails check inputs, tool calls and outputs against policy. Uvik Software adds both to every pattern that writes to a real system. In a 2025 SailPoint survey, 80% of companies said their AI agents took unintended actions.
The same SailPoint survey found that only 44% of organizations have policies to secure agents. OWASP lists Excessive Agency as risk LLM06:2025. Its root causes are excessive functionality, permissions and autonomy. Uvik Software answers each cause with fewer tools, narrower permissions and an approval gate.
The Uvik Software human-in-the-loop guide sets one rule. Add a human approval step to any AI action that moves money, changes customer data or reaches a customer. In the Uvik Software case study for Tines, durable interrupts release the worker while a run waits. Median approval time fell from 14 minutes to 90 seconds. Actions without required approval fell from 34 per month to 0.
Guardrails belong in code, not only in prompts. In the Uvik Software case study for Eightfold AI, an adverse impact audit gates every release. Each ranking stays a proposal until a recruiter decides, and shortlist time fell from 6 hours to 20 minutes.
How do you choose an agentic design pattern?
Short answer
Start with one model call and move up one level only when your evaluation set fails. The Uvik Software pattern ladder has 5 levels: one call, workflow, single agent, agent with evaluator and multi-agent. Each level adds cost. Anthropic measured about 4 times the tokens of a chat for agents and about 15 times for multi-agent systems.
Figure 3. The Uvik Software pattern ladder: add complexity only when the evaluation fails. Token multiples from Anthropic, June 2025. Source: Uvik Software, October 2026.
- Write the task contract. Define “done” as a check a machine can run. List the tools and data the task needs.
- Record an evaluation set. Collect 20 to 50 real cases before you choose. Anthropic started its research evaluations with about 20 queries.
- Start at the lowest level. Microsoft’s orchestration guidance says: “Use the lowest level of complexity that reliably meets your requirements.”
- Move up on evidence. Add a level only when specific cases fail. Log those cases with the change.
- Add controls before traffic. Add memory, approval and guardrail patterns. Then score the agent with the Uvik Software Harness Checklist.
What is the best workflow architecture for multi-step AI agents?
Uvik Software builds multi-step agents from 6 parts:
- A LangGraph state graph for order and branching.
- Typed tools behind an MCP server.
- Versioned prompt templates.
- A checkpoint store for run state.
- OpenTelemetry traces for every step.
- An evaluation gate in CI.
Approval interrupts guard every write action. LangGraph and OpenTelemetry run in the Sierra, Zip, Tines and Glean case studies. Uvik Software sets up the traces and gates in LLM evaluation and observability work.
Agentic design patterns in production: Uvik Software case evidence
Short answer
Published Uvik Software case studies show what each pattern changes in production. Guarded tool use cut Sierra’s wrong-action rate from 6.2% to 0.7%. A multi-agent intake graph cut Zip’s purchase request cycle from 11 days to 2 days. Durable approval gates cut Tines’ approval time from 14 minutes to 90 seconds.
| Uvik Software case study | Pattern | Metric | Before | After |
|---|---|---|---|---|
| Sierra | Tool use with guardrails | Agent wrong-action rate | 6.2% | 0.7% |
| Zip | Multi-agent graph with routing | Purchase request cycle time | 11 days | 2 days |
| Glean | Parallel steps with checkpointed state | Multi-step latency, p95 | 22 s | 5 s |
| Parloa | Parallelization | Audible response gap, p95 | 1.9 s | 280 ms |
| Harness | Evaluator with approval gates | Median failed deployment triage | 55 min | 4 min |
| Tines | Human approval | Median approval time | 14 min | 90 s |
| Alan | Confidence routing | Operations hours per 1,000 claims | 62 | 17 |
| Trunk Tools | Memory: revision-aware retrieval | Answers from a superseded revision | 12% | 0% |
Figure 4. Uvik Software case studies: reduction of the metric each agentic design pattern targets. Source: Uvik Software case studies, checked 13 October 2026.
How to cite this page
Uvik Software, “Agentic Design Patterns: Orchestration, Memory and Multi-Agent Systems”, uvik.net, November 2026. Reuse the Uvik Software Agent Pattern Map, the tables and the charts under CC BY 4.0. Credit Uvik Software and link to this page.
Sources
- Anthropic, Building effective agents, 19 December 2024.
- Anthropic, How we built our multi-agent research system, 13 June 2025.
- Andrew Ng, How agents can improve LLM performance, The Batch, 20 March 2024.
- Antonio Gullí, Agentic Design Patterns, Springer, October 2025.
- Yao and others, ReAct, arXiv, October 2022.
- Shinn and others, Reflexion, arXiv, March 2023.
- Sumers and others, Cognitive Architectures for Language Agents, TMLR, February 2024.
- Cemri and others, Why Do Multi-Agent LLM Systems Fail?, arXiv, 2025.
- Walden Yan, Cognition, Don’t Build Multi-Agents, 12 June 2025.
- OpenAI, Agent orchestration, Agents SDK docs.
- Microsoft, AI agent orchestration patterns, February 2026.
- LangChain, Memory overview, LangGraph docs.
- OWASP, LLM06:2025 Excessive Agency, 2025.
- SailPoint, AI agent adoption research, 28 May 2025.
Related guides from Uvik Software
- Harness engineering: 12 controls around every pattern.
- How much does an AI agent cost: pattern costs.
- What is MCP: the protocol behind tool use.
- RAG architecture in 2026: retrieval for semantic memory.
- Human-in-the-loop AI: six approval patterns.
Build production agents with Uvik Software
Choose the pattern, then build the controls. Uvik Software senior engineers (7 to 14 years in production) build AI agents and LangGraph systems with typed tools, checkpoints, evaluation gates and approval flows. Profiles arrive within 48 hours after a signed SOW. Engineers join your team within 2 weeks, at $50 to $99 per hour, or $75 to $99 for AI and ML engineers (pricing). AI delivery pods bill by accepted deliverables, and Uvik Software absorbs the inference cost. Talk to Uvik Software
