Agent Design Pattern Catalogue

Updated 6 September 2025

Agent Design Pattern Catalogue is a structured collection of reusable templates that standardize interactions and architectures in multi-agent systems.
It categorizes patterns across goal formulation, communication protocols, planning, and memory integration to improve system robustness and explainability.
The catalogue enables modular design and scalability through established templates such as mediator, observer, and hierarchical architectures.

An Agent Design Pattern Catalogue is a curated schema of reusable architectural and interaction templates for constructing agent-based software systems. Such catalogues encapsulate established solutions and design abstractions—covering communication protocols, memory structures, planning heuristics, modularity, and coordination methods—across both traditional and foundation-model agentic architectures. They provide a rigorous basis for modular design, extensibility, interoperability, and explainability in agentic systems spanning from web service orchestration to modern multi-agent LLM-based environments.

1. Foundations: Pattern Categories and Abstractions

Agent design pattern catalogues systematically classify and document recurring structures and mechanisms necessary for building robust multi-agent systems. Contemporary catalogues (Liu et al., 16 May 2024) organize patterns into cohesive groups along the agent’s operational pipeline:

Goal and Instruction Acquisition: Patterns such as Passive Goal Creator and Proactive Goal Creator support explicit (text-based) and contextually inferred (multimodal, proactive) goal formulation.
Prompt/Response Normalization: The Prompt/Response Optimiser augments user instructions for clarity, mitigating ambiguity and reducing risk of model hallucinations.
Knowledge Augmentation: Patterns encompass Retrieval Augmented Generation (RAG), Incremental Model Querying, and One-shot Model Querying, allowing agents to supplement foundation model knowledge with external data sources.
Plan Generation: Single-path and Multi-path Plan Generators facilitate the creation of sequential or alternative execution plans, supporting both efficient and preference-aligned behaviors.
Reflection and Cooperation: Self-, Cross-, and Human Reflection provide internal, peer, and user-driven plan validation; Voting-, Role-, and Debate-Based Cooperation structure agent collaboration for distributed reasoning or consensus.
Safety and Registry Patterns: Multimodal Guardrails enforce robustness, while Tool/Agent Registry patterns provide inventory and traceability of available tools and agents.

This typology allows for holistic system composition and context-dependent selection of architectural blueprints, ensuring modularity, explainability, and robustness in complex agentic applications.

2. Communication and Coordination Patterns

A recurring challenge in agent system design is the structuring of inter-agent messaging and negotiation. Catalogued communication patterns include:

Mediator Pattern: Centralizes agent message exchange through a supervisor or orchestrator, simplifying N² connectivity to O(N) (Sarkar et al., 26 May 2025).
Observer / Publish-Subscribe Pattern: Enables one-to-many event notifications, letting agents react asynchronously to environmental changes or system state updates.
Broker Pattern: Decouples clients and servers, routing messages and tool invocations through an intermediary (the Model Context Protocol (MCP) embodies this role, standardizing context sharing and request brokerage).

These patterns, often operationalized using protocols such as MCP (JSON-RPC 2.0, SSE), provide efficient, context-aware, and auditable multi-agent interaction, with mathematical relationships such as:

$L_{direct} = \frac{N(N-1)}{2},\quad L_{centralized} = N$

demonstrating the scaling benefits of centralization or brokering in dense agentic systems.

3. Planning, Reasoning, and Memory Patterns

Effective agentic systems benefit from dynamic, memory-augmented planning templates:

Dynamic Planning and Task Decomposition: Agents produce flexible, revisable execution plans $\mathcal{P} = (s_1, \ldots, s_n)$ , adaptively updating $\mathcal{P}' = revise(\mathcal{P}, \{o_{t-n+1}, \ldots, o_t\})$ in response to environmental feedback (Zhu et al., 17 Jun 2025).
Hierarchical Decomposition: Task graphs $\mathcal{D} = (\mathcal{S}, \varepsilon)$ organize dependencies among subtasks, enabling hierarchical reasoning.
Memory-Augmented Reasoning: Layered memory architecture—short-term buffers, memory summarization ( $z_i = Summarize(\{(s_t, a_t, r_t)\})$ ), vectorized retrieval, and long-term semantic storage—supports context tracking, knowledge reuse, and robust performance across long reasoning trajectories.
Minimalist Tool Integration: Restricting tool interface operations to atomic, composable actions (e.g., Search, Visit, Read in web browsing agents) reduces cognitive and implementation overhead without sacrificing extensibility (Zhu et al., 17 Jun 2025, Gao et al., 22 Aug 2025).

These patterns are formalized into modular APIs, programming abstractions (e.g., AUML class diagrams for agent types (Maalal et al., 2012)), and extensible memory backends.

4. Modular and Scalable Architectures

Scalable agent systems require patterns that decouple roles, responsibilities, and execution environments. Examples include:

Component-Oriented Architecture: The separation of Environment, Agent, Action, and Interaction classes enables independent component development, plug-and-play extensibility, and systematic evolution (Maalal et al., 2012, Gao et al., 22 Aug 2025).
Hierarchical Agent Architectures: Agents are structured in multi-level hierarchies (e.g., Planner vs. Navigation agents in web automation (Abuelsaad et al., 17 Jul 2024)) to support task decomposition, error backtracking, and parallel refinement.
Specialized Generalist Integration: Platforms such as AgentStore (Jia et al., 24 Oct 2024) employ a MetaAgent and AgentToken strategy—each agent is encoded as a learnable token appended to the LLM’s vocabulary, enabling plug-and-play routing and top‑K collaborative assignment via:

$P_m(t_i | t_{<i}) = softmax([W_v; W_\mathcal{A}] \cdot h_{i-1}),\quad T^*_i = TopK_{t \in \mathcal{A}}(P_m(t_i | t_{<i}), K)$

This paradigm supports dynamic enroLLMent, plug-and-play expansion, and efficient evaluation of both generalized and highly specialized agents.

5. Interaction with Web Services and Tool Orchestration

Patterns for web service and tool orchestration focus on semantic interoperability and dynamic composition:

Ontology-Based Communication: Declarative, OWL-based operational ontologies (covering interaction protocols, communicative acts, content languages, actions, and mental attitudes) define a shared vocabulary facilitating agent-to-agent and agent-to-service interoperability (0906.3769).
Control Plane as a Tool: Encapsulates orchestration logic behind a unified tool interface, allowing agents to invoke a single abstract tool, which routes requests to appropriate modules based on context, metadata, or policy (Kandasamy, 11 May 2025). Logging, validation, and feedback modules enforce safety and support dynamic composition.
Self-Adaptive Infrastructure: Virtual Environment, Situated Agent, Selective Perception, Behavior-Based Action Selection, and Protocol-Based Communication collectively enable decentralized adaptation, rapid local response, and robust collaborative negotiation in open, dynamic environments (Weyns et al., 2019).

6. Evaluation, Reproducibility, and Engineering Considerations

Catalogues include standardized evaluation protocols (Zhu et al., 17 Jun 2025) due to the high variance in agentic system runs:

Reproducibility: Standardized metrics (Pass@N), run settings, and consistent configurations ensure empirical results are attributable to architectural innovations, not implementation artifacts.
Scalable Evaluation Modules: Modules supporting distributed benchmarking (e.g., RayEvaluator in AgentScope (Gao et al., 22 Aug 2025)) and studio interfaces enable visual diagnosis and long-horizon profiling of agent behavior.
Runtime Sandboxing: Dedicated execution sandboxes with consistent interfaces secure tool invocations, file operations, and browser automation against security risks.
Engineering Hooks and Extension Points: Modular APIs, hook systems (for input/output customization), and dynamic tool provisioning allow rapid adaptation to evolving requirements and integration of new models, tools, or protocols.

7. Impact, Limitations, and Outlook

These catalogued design patterns underpin the construction of context-adaptive, reliable, and extensible agentic systems, spanning applications from dynamic workflow composition and resource allocation (Reale et al., 2022) to autonomous business process automation (AzariJafari et al., 29 Jul 2025). Their principled use addresses:

Scalability: Modular, decoupled patterns avoid combinatorial link explosion.
Explainability and Accountability: Reflection, registry, and collaboration patterns support transparent reasoning and auditing.
Safety and Robustness: Guardrails and validation layers enforce constraints and mitigate the risks of hallucinations or unsafe tool execution.
Generalizability: The same architectural templates are applicable to LLM-driven, RL-based, and classical symbolic multi-agent scenarios.

However, catalogues also highlight standing challenges: communication overhead in highly decentralized systems (scaling as $O(N^2)$ ), security risks (e.g., agent-in-the-middle attacks), and the need for human-in-the-loop mechanisms to align and govern agentic decision making (Sarkar et al., 26 May 2025).

In summary, the Agent Design Pattern Catalogue provides a rigorous, modular, and extensible suite of design abstractions guiding the scientific construction and deployment of agentic systems across diverse domains and requirements, and frames contemporary advances in the context of foundational software engineering principles and emerging AI infrastructure.