Photo by the author
# Entry
Agentic artificial intelligence systems that exploit large language models (LLM) for reasoning, planning and executing multi-step tasks, promise a modern era of automation. However, their non-deterministic nature – producing a different result each time the same piece of data is entered – creates unique challenges such as the unpredictability of LLM, multi-step workflows fail during execution and agents lose significant context. Building systems that are not only functional, but also able to cope with failures and reliably manage condition, is the key to moving from prototype to production.
In this article, you’ll learn five basic design patterns that address these fundamental challenges. Using LangChain and him LangGraf extension as our reference platform, we will look at patterns that provide structure, resilience, and observability to your agent applications. The table below provides a brief overview of these patterns and their main advantages.
| Pattern | Basic idea | A key mechanism for endurance | The perfect exploit case |
|---|---|---|---|
| Single agent with ReAct loop | An autonomous agent that plans and acts iteratively | Self-correction through an integrated “thinking” step. | Open tasks requiring animated exploit of tools (e.g. research, analysis) |
| Sequential multi-agent workflow | A chain of specialized agents providing output in a linear fashion | Modularity isolates failures and clear data contracts | Structured, repeatable pipelines (e.g. data extraction, cleansing, loading) |
| Multi-agent collaboration and collection | Multiple agents work simultaneously; starting products are synthesized | Reducing delays and gathering diverse perspectives | Tasks with independent subtasks (e.g. multi-source analysis, validation) |
| Manager-Controller with State Checkpoint | A central controller manages a persistent state graph that can be resumed | Fault tolerance with state snapshots and human intervention in the loop | Long-running, convoluted or critical workflows |
| Reviewer-critic feedback loop | Generator performance is checked by a dedicated critic agent | Quality control through independent, objective validation | Results requiring high accuracy or compliance (e.g. code, content generation) |
# Single agent implementation with ReAct loop
The basic pattern of agent systems is a single agent equipped with tools and guided by a Reason and Action (ReAct) structure. This agent runs in a loop; justifies the task and its current state, decides on an action (often using a tool), acts, and then observes the result before repeating the cycle.
Single agent with ReAct | loop Photo by the author
IN LangChainthis is usually implemented using a file AgentExecutor. The robustness of this pattern comes from the agent’s ability to adjust its plan based on observations, which is a fundamental form of error recovery. However, its main obstacle is complexity limitations. As tasks become more convoluted, the performance of an individual agent may decline.
The implementation focuses on LangChain shows that robustness depends largely on rapid engineering and tool design. Clear tool descriptions and a well-organized system prompt that instructs the agent:think step by step“are critical to reliable reasoning.
# Manage sequential multi-agent workflows
For convoluted, structured tasks, work can be divided and assigned to a sequence of specialized agents. Each agent is an expert in a specific subtask, and the results of one agent become input to the next in a predefined, linear pipeline.
This design increases reliability through modularity and limpid contracts. A failure in a single agent is circumscribed and easier to debug than a convoluted failure in the logic of a monolithic agent. For example, in a data pipeline, a “Data Extractor” agent can pass raw data to a “Data Cleaner” agent, which then passes it to a “Data Loader” agent.
Multi-agent sequential workflow with ordered data forwarding | Photo by the author
The challenge is that the main risk is loss of context or corruption when transferring control. Prevent this by enforcing structured output schemas (e.g. JSON) between agents and using a shared state object (as in LangGraf) to convey context cleanly rather than relying on unstructured natural language.
# Coordinating parallel work and collection of multiple agents
When a task can be divided into independent subtasks, the parallel pattern can significantly reduce latency. Multiple specialized agents are invoked simultaneously, and their output is later collected and synthesized by the final agent.
Multi-agent collaboration and collection | Photo by the author
A classic exploit case is customer service ticket analysis, where one agent analyzes sentiment, another isolates key elements, a third categorizes the problem, and the final agent writes a summary based on all these parallel analyses.
The challenge posed by this pattern is the complexity of coordination and the risk of failure of the synthesis step due to conflicting inputs. Implement timeouts and circuit breakers for each parallel branch to prevent one tardy or out-of-order agent from blocking the entire process. The synthesis agent prompt must be designed to efficiently handle missing or partial input.
# Exploit of manager-controller with state checkpoints
It is a meta-pattern for configuring convoluted, long-running, or conditional workflows that is best implemented using LangGraf. This is the headquarters StateGraph defines different nodes (which can be agents, tools or logic) and conditional edges (transitions) between them. The graph manages the persistent state object that flows through the system.
The basis of the robustness of this pattern is the checkpoint. LangGraf automatically maintains a state object after each node execution. If a workflow crashes or is intentionally paused, it can be resumed exactly from the last completed node, without redoing work or losing context. This also enables the exploit of human-in-the-loop patterns, where a human can approve, modify, or redirect the workflow at specific points.
Manager-controller pattern with central state graph for persistence and checkpointing | Photo by the author
// Implementation goal (LangGraph)
Design your statechart carefully because it is the only source of truth for your workflow. Exploit LangGrafBuilt-in persistence and interrupt capabilities enable you to build traceable, restartable systems that are reliable enough for production applications.
# Using a reviewer-critic feedback loop
Quality assurance can be hard-coded into the system via the Reviewer Critic (or Generator Critic) pattern. This is often a specialized implementation of a loop pattern. One agent (Generator) creates a result, which is then evaluated by a separate, independent agent (Critic or Reviewer) according to specific criteria (accuracy, security, style).
This pattern is crucial when generating high-stakes content such as code or legal text. The critic provides an objective, external layer of validation, dramatically reducing hallucinations and specification deviations.
Reviewer-critic feedback loop | Photo by the author
A critic must be truly independent. It should exploit a different system prompt and perhaps even a different vast language model to avoid sharing generator assumptions or inferring blind spots. Always implement a maximum iteration limit to prevent endless evaluation loops.
# Summary of solid design patterns
These patterns are not necessarily separate; some of the most reliable production systems combine them. You can have a Manager-Controller graph (Pattern 4) that organizes a sequential workflow (Pattern 2), where one step involves parallel information collection (Pattern 3), and the last step involves a Reviewer-Critic loop (Pattern 5) for quality assurance.
The path to resilience begins with recognizing that failures are inevitable in agent-based systems. By adopting these structured patterns, especially those enabled by stateful orchestration with checkpoints LangGrafyou can move from creating fragile chains of prompts to designing resilient systems that can cope with uncertainty, fix errors, and provide the transparency necessary for continuous improvement and user trust.
I hope this detailed guide provides a solid foundation for designing hearty agent systems.
Shittu Olumid is a software engineer and technical writer with a passion for using cutting-edge technology to create compelling narratives, with an eye for detail and a knack for simplifying convoluted concepts. You can also find Shittu on Twitter.