Agent Design Patterns and Architectures for LLM-Based AI Agents (2025)

Introduction

Large Language Models (LLMs) are increasingly used as the "brains" of autonomous agents, giving rise to a broad landscape of agent design patterns and architectures. Researchers and industry practitioners have proposed numerous strategies for how an LLM-based agent can plan, reason, incorporate tools or memory, and even coordinate with other agents. This report compiles a comprehensive taxonomy of current agent design patterns – from single-LLM agent loops to complex multi-agent systems – without filtering out experimental or emerging approaches. We draw from academic literature (e.g. recent AI conference papers, arXiv preprints, workshops) as well as industry frameworks (LangChain, AutoGPT, Open Agents, CrewAI, etc.) to map out the design space. The patterns are organized into logical groups (reactive vs deliberative agents, planning vs tool-augmented strategies, cooperative vs competitive multi-agent coordination, agent loop variants, etc.), with references to sources for further reading. The goal is to provide both practitioners and researchers a clear overview of the architectures that empower modern AI agents.

An LLM-driven agent serves as a central reasoning module, complemented by a Planning component (for subgoal decomposition, chain-of-thought reasoning, and self-reflection), a Memory module (short-term context and long-term vector-store memory), and a suite of Tools or APIs it can call (e.g. web search, calculators, code execution). This blueprint highlights how an LLM "brain" interfaces with external tools and memory to achieve autonomy. The planning module can involve techniques like reflection or self-criticism, while the tools enable the agent to act on the world beyond text.

In the rest of this report, we first review a general taxonomy of agent architectures, then detail single-agent LLM patterns (reasoning loops, memory integration, tool use, etc.), followed by multi-agent systems patterns (communication protocols, coordination strategies like role assignments, voting, debate, etc.). We then highlight notable frameworks implementing these patterns in practice, and provide a comparative summary table of key architectures.

Background: Taxonomy of Agent Architectures

Before diving into specific LLM-agent designs, it is useful to frame a taxonomy of agent architectures in general. Classic AI literature distinguishes reactive agents (which respond to the environment with minimal internal planning) from deliberative agents (which construct and execute explicit plans), as well as hybrid approaches that combine both. Modern LLM-based agents often blend these paradigms, leveraging the LLM's generative reasoning for deliberation while reacting in real-time to observations or user input. Additionally, multi-agent systems introduce dimensions of coordination (cooperative vs competitive) and communication protocols. We briefly summarize these axes of classification:

Reactive vs. Deliberative Agents

Reactive agents act on stimulus-response rules, making decisions moment-to-moment without explicit long-term planning. In classical design, Rodney Brooks' subsumption architecture is an example of a purely reactive design with layered behaviors. In the context of LLMs, a reactive agent might be a single prompt-response system: the agent directly generates an answer or action given the current input, without maintaining an internal plan or memory beyond the immediate context. This simple mode is fast but can struggle with complex, multi-step tasks. It is analogous to a "one-shot" approach – the LLM produces an output in one go. Some LLM applications (like straightforward Q&A chatbots) follow this reactive pattern by design.

Deliberative agents, on the other hand, maintain an internal model of state, goals, and plans. They may decompose tasks, consider alternative actions, and anticipate future steps. Traditional deliberative architectures include the Belief-Desire-Intention (BDI) model, where an agent's beliefs (information about the world), desires (objectives), and intentions (committed plans) drive its behavior. BDI agents continually update beliefs, generate desires, and select intentions, enabling goal-directed behavior. Contemporary LLM agents are often deliberative: they use the LLM to plan sequences of actions or thoughts and adjust their approach based on intermediate results. For example, an LLM agent might break down a user's request into sub-tasks and decide on a plan (this is a deliberative step) before executing each sub-task. Many LLM agent loops explicitly prompt the model to "think step-by-step" – a form of internal deliberation.

Modern research indicates that combining both approaches is powerful. An LLM agent might operate reactively at each step (responding to current observations with an action), but also engage in deliberation by generating a multi-step plan or reasoning chain. This blend is seen in patterns like ReAct, where the agent reacts to observations but also maintains a chain-of-thought (planning) in its prompt.

Hybrid Architectures and Cognitive Blueprints

Over decades of AI research, hybrid architectures have been proposed to get the best of reactive and deliberative systems. A classic example is the three-layer architecture: a reactive layer for real-time response, a deliberative layer for goal-directed planning, and a meta-reasoning layer for monitoring and adjusting strategies. While these were originally conceived for robotics and symbolic AI, similar concepts appear in LLM agents. We often see:

A planning module (deliberative) that formulates a high-level plan or reasoning steps.
An execution or reactive module that carries out individual steps.
A monitoring or reflection module that checks outcomes and can re-plan or adjust if needed.

In LLM-based systems, these "modules" might all be implemented via prompt patterns or multiple LLMs. For instance, one prompt might ask the LLM to generate a plan (like a list of steps), and subsequent prompts execute each step and gather results, and another prompt may evaluate the results. This modularization mirrors the hybrid architecture concept.

Another important architectural blueprint is the blackboard model (common in multi-agent or multi-module systems), where agents or sub-processes communicate via a shared memory (the "blackboard"). In LLM agents, an analogy is using a shared context or a common memory store that different agent components read and write (for example, a task list that a planning agent updates and an execution agent consumes). We will later see how some multi-agent frameworks use a shared knowledge repository or environment for coordination.

Finally, when multiple agents are involved, we consider architectures for how they are organized: Are agents homogeneous (all using similar reasoning processes) or heterogeneous (different roles or capabilities)? Is there a central coordinator or is control distributed? How is communication managed? These structural questions form a multi-dimensional taxonomy proposed in recent literature. This taxonomy reflects the need to balance an agent system's level of autonomy with its alignment to user goals and values.

With this background, we now delve into concrete patterns observed in today's LLM-based agents. We start with single-agent architectures, where one LLM (possibly with extensions) is the focus, then expand to multi-agent systems.

Single-Agent LLM Architectures and Patterns

Single-agent patterns refer to designs where a single LLM-centric agent is solving tasks, potentially with the help of tools or external resources, but not requiring explicit coordination with peer agents. Even so, these agents can have complex internal loops and sub-components. We categorize the patterns by their primary innovation: planning strategy, tool use, memory integration, and self-optimization. In practice, many implementations (like AutoGPT or LangChain agents) combine multiple patterns – for example, an agent might use a planning strategy and tool usage and memory. For clarity, we discuss them separately, but note that they are often composed together in real systems.

Planning and Reasoning Strategies

One of the most distinctive aspects of LLM agents is how they plan out their reasoning and actions instead of answering immediately. Several design patterns have emerged for planning:

Chain-of-Thought (CoT) prompting: This prompting technique explicitly guides the LLM to "think step by step" and produce intermediate reasoning steps before a final answer. CoT is inherently linear and is often combined with tool use, leading into the ReAct pattern.
ReAct (Reasoning and Acting loop): The ReAct pattern integrates a chain-of-thought reasoning phase with discrete action commands in an interleaved loop. In a ReAct agent, the LLM alternates between Thought (its internal reasoning), Action (calling a tool or executing a step), and Observation (reviewing the result from the tool or environment). This loop repeats until the task is complete.
Plan-and-Execute (Two-Phase): This design separates the process into two phases: a planning phase where a complete or partial plan is generated, followed by an execution phase that follows the plan. This approach improves coherence on complex tasks and may delegate the execution to simpler sub-models while retaining a high-level plan from the LLM.
Multi-Path Reasoning (Tree-of-Thoughts): Instead of a linear sequence of thought, the agent explores multiple reasoning paths simultaneously or in a branching tree structure. This allows backtracking or comparing different solutions before settling on an answer. Techniques like generating several independent solutions and then voting on the best one fall under this category.
Goal Decomposition and Task Lists: Many LLM agents generate and maintain a list of subtasks to be executed. This pattern involves breaking a high-level goal into smaller, manageable subtasks and iteratively executing them while updating the task list with new subtasks as needed.

Tool Use and External Action

A key feature of many modern LLM agents is the ability to interact with tools, APIs, code executors, and external environments:

Function Calling and API Integration: LLM agents are augmented with tool registries that allow them to choose from a predefined set of functions (like web search, calculation, etc.). The agent outputs a command, and the function is executed separately—thus extending the agent's capabilities.
Code Execution as a Tool: In this pattern, the agent writes and executes code (often Python) to solve parts of a task, such as performing precise calculations or generating figures. Tools like OpenAI's Code Interpreter are common examples.
Simulated Environments as Tools: The agent can interact with a simulated world (like a video game) through specific APIs, effectively using the environment as a tool to solve tasks or learn from real-time feedback.
Orchestrating Other AI Models: An LLM acting as a controller can call on other specialized AI models (such as for vision or speech) to integrate multi-modal capabilities, forming a pipeline of expert tools managed by the central LLM.

Memory and Knowledge Integration

LLM agents need to handle memory since their intrinsic context is limited. Common patterns include:

In-Context Memory (Short-Term): The agent's immediate prompt history acts as short-term memory, occasionally summarized when the interaction length grows.
Retrieval-Augmented Generation (RAG): The agent queries an external knowledge base (often through vector databases) to retrieve relevant information, effectively augmenting its limited internal context.
Long-Term Persistent Memory: Beyond context windows, agents may store and retrieve episodic memories (previous interactions or learned experiences) to maintain continuity over longer periods.
Working Memory and Scratchpads: The agent keeps intermediate computations or state variables in a virtual "scratchpad" during reasoning, emulating human working memory.

Self-Reflection and Self-Correction

To improve robustness, many agents are designed to internally critique and refine their outputs:

Self-Refinement Loops: After generating a solution, the agent revisits its response, critiques it, and iteratively refines the answer. This "think → draft → revise" loop can significantly enhance performance.
Critic and Coach Agents (Dual-Agent Reflection): In some configurations, one agent generates a solution while another, acting as a critic, reviews and suggests improvements. This adversarial (yet cooperative) setup boosts reliability.
Human Feedback and Corrections: Some designs incorporate a human-in-the-loop, where human oversight can offer corrections or guidance to the agent's self-refinement process.
Evaluator or Filter Modules: Separate from self-reflection, these modules evaluate the final output for quality, safety, or consistency before it is delivered.

Multi-Agent Systems and Coordination Patterns

Multi-agent systems involve multiple interacting agents that may either cooperate or compete. Here, the design challenges include communication protocols, task division, and conflict resolution. Key patterns include:

Communication and Interaction Protocols

Natural Language Communication: Agents exchange information in plain language, leveraging the strengths of LLMs in generating human-like text. Many multi-agent frameworks simulate a group chat where agents naturally dialogue.
Structured Communication (APIs or DSLs): Some systems enforce structured message formats (like JSON) or use domain-specific languages for inter-agent communication, reducing ambiguity.
Turn-Taking vs. Simultaneous Interaction: Systems may enforce ordered turns in the conversation (similar to moderated dialogue) or allow more fluid, event-driven interactions.
Communication with Humans in the Loop: Occasionally, multi-agent systems integrate human participants who may moderate, join, or direct the conversation.

Cooperative Architectures

For agents collaborating towards a common goal, several patterns emerge:

Role-Based Teams: Each agent is assigned a specific role (e.g., Planner, Executor, Reviewer) based on expertise. This simulates a human team with divided responsibilities and is common in frameworks like MetaGPT and ChatDev.
Voting and Consensus (Ensemble Cooperation): Multiple agents tackle the same task independently, after which their outputs are aggregated through voting or consensus to determine the best solution.
Hierarchical Manager-Worker Agents: A manager agent decomposes the task and delegates sub-tasks to worker agents, integrating results to form the final solution.
Shared Memory and Collaborative Reasoning: Agents might use a common "blackboard" or shared memory, posting intermediate results that all agents can reference.
Cooperative Task Allocation: Agents negotiate task assignments dynamically, often using conversational cues or predefined protocols to ensure optimal task distribution.

Comparative Summary of Agent Patterns

Below is a summary table mapping key design patterns with their properties and example implementations:

Pattern / Architecture	Key Idea	Properties (Planning, Memory, Tools, Multi-agent)	Example Systems / Sources
Reactive Agent (One-shot)	Direct response to input with no multi-step reasoning.	No explicit planning; uses prompt context only; single-agent.	Basic Q&A Chatbots, early GPT-3 API usage.
Deliberative Agent (BDI-inspired)	Maintains explicit goals, beliefs, and plans.	Explicit planning, state updating; may use tools; typically single-agent.	Classical BDI frameworks; modern adaptations in LLM agents.
Chain-of-Thought Prompting	"Think step-by-step" before the final answer.	Implicit planning via intermediate text; uses context window.	GPT-4 reasoning examples; prompt engineering literature.
ReAct (Reason + Act loop)	Interleaves reasoning with discrete actions/tools.	Stepwise planning, tool calls, short-term memory; single-agent loop.	LangChain's default agent; OpenAI ReAct implementations.
Plan-and-Execute (Two-Phase)	Plans fully, then executes sequentially.	High-level planning phase, execution phase; may use multiple calls.	LangChain Plan-and-Execute; BabyAGI.
Task Decomposition & Task List	Breaks high-level goal into subtasks to process iteratively.	Iterative re-planning and task list; uses memory; single-agent behavior.	AutoGPT; BabyAGI.
Multi-Path Reasoning / Tree-of-Thoughts	Explores multiple solutions concurrently then selects.	Branching planning and comparison; can be resource intensive.	Tree-of-Thoughts; voting-based self-consistency methods.
Tool-Augmented Agent (Function-Calling)	Augments reasoning with external function/API calls.	Integrates tool registry; uses planning to choose tools; single-agent.	Toolformer; OpenAI function-calling; LangChain tool integrations.
Code Writing and Execution Agent	Uses generated code to perform tasks.	Generates and executes code; integrates with a runtime; often single-agent.	OpenAI Code Interpreter; Voyager; GPT Engineer.
Retrieval-Augmented Generation (RAG)	Retrieves external documents to enhance responses.	Utilizes an external knowledge base; integrates with vector DB; single-agent.	Bing Chat; LlamaIndex-powered bots.
Long-Term Memory Agent	Stores and recalls previous interactions persistently.	Utilizes persistent storage (DB, files); supports episodic memory.	Generative Agents (sandbox simulations); personal assistant agents.
Self-Reflection / Self-Refine	Iteratively critiques and improves its output.	Looping critique and refinement; internal evaluation; single-agent.	Self-Refine and Reflexion frameworks.
Critic and Producer Agents (Dual-agent)	One agent generates, another critiques the output.	Adversarial yet cooperative; splits roles; multi-agent setup.	Two-agent reflection models; AI Socratic setups.
Role-Based Multi-Agent Team	Divides tasks among agents with distinct roles.	Role specialization; collaborative planning; multi-agent coordination.	MetaGPT; ChatDev; CrewAI.
Voting Ensemble of Agents	Multiple agents independently solve then vote on answers.	Redundant planning and solution verification; loosely coupled; multi-agent.	Ensemble LLM methodologies; voting-based verification patterns.
Manager-Worker (Hierarchical) Agents	Manager agent delegates subtasks to worker agents.	Hierarchical task assignment; multi-agent, structured communication.	Microsoft AutoGen; HuggingGPT.
Natural Language Messaging Protocol	Agents use free-form language for interactions.	Conversational, flexible communication; uses dialogue history; multi-agent.	CAMEL; many multi-agent chat simulations.
Structured Communication / Blackboard	Uses formal message formats or shared memory spaces.	Reduces ambiguity; uses common data structures; multi-agent.	Blackboard architectures; JSON-based messaging in agent frameworks.
Debate (Adversarial Collaboration)	Agents debate to collaboratively refine the truth.	Structured adversarial dialogue; encourages self-improvement; multi-agent.	AI safety debates; structured debate frameworks.
Competitive Game/Negotiation Agents	Agents with conflicting goals interact competitively.	Adversarial planning; negotiation dynamics; multi-agent competitive.	CICERO for Diplomacy; negotiation simulation agents.
Emergent Agent Society	Many agents interact to yield collective behavior.	Decentralized, emergent planning; individual memory with shared environment; large-scale multi-agent simulation.	Generative Agents town simulation; experimental large-scale frameworks.
Ensemble Verification / Red Teaming	Multiple agents verify each other's outputs.	Cross-checking and validation; potentially adversarial; multi-agent verification.	LLM red-teaming setups; self-play paradigms.
Evaluator or Filter Module	Evaluates and filters outputs from other agents.	Acts as a quality or safety gate; can be integrated into a pipeline; often single-agent or supervisory multi-agent.	OpenAI's evaluation messages; filtering modules in complex agent systems.