Agentic Architectures: 35 patterns, from the problem to a prompt
A site I built around one question: which agent architecture fits your problem? It covers 35 architectures, says when to avoid each one, and chains them into a single prompt.
There are many named ways to arrange agents: ReAct, a supervisor with specialists, several kinds of RAG, debate, tree search. Most explanations start from the mechanism. I wanted one that starts from the reader’s problem, so I built Agentic Architectures.
The site is static. It has no backend, no login, and makes no model call while you use it. Every page is generated from data files, one per architecture.
35 architectures in 8 families
| Family | What its agents do | Architectures |
|---|---|---|
| Tools & Action | Act on the world through tools, one step at a time | 6 |
| Reasoning & Self-critique | Improve an answer by examining their own thinking | 4 |
| Retrieval | Ground answers in documents they fetch and judge | 5 |
| Memory | Keep facts, skills or lessons from one run to the next | 5 |
| Sampling & Search | Explore several candidate paths and keep the best | 5 |
| Multi-agent Coordination | Take different roles on one problem | 4 |
| Guardrails & Routing | Decide whether, how and by whom a request is handled | 4 |
| Evolution & Emergence | Reach a result through many small scored or local steps | 2 |
Four questions, in the reader’s order
Each architecture opens level by level:
- What problem does it solve?
- When should I not use it, and what should I use instead?
- How does work move through it? This level has a diagram, a step-by-step walkthrough and the ports.
- What do I ask my assistant to set up? This level lists the agents to launch, a framework-agnostic prompt, and code in four SDKs.
Take ReAct. Its page opens with “Why does a tool-using agent lose its way on longer tasks?”. The second level is as direct about the limits. If one or two tool calls answer the question, the reasoning trace adds cost and nothing else, and the page sends you to Tool Use. If the steps are known before starting, it sends you to Planning.
Every level ends with a question put to the reader. The answer stays hidden until you ask for it.
Blocks with typed ports
To chain architectures, the site treats each one as a block with ports. A chain enters a block through its entry port and leaves through an exit port. Some architectures have several exits, for example executed and blocked, and an exit that is not linked ends the chain.
Ports carry a payload kind. There are 14 of them: task, question, plan, draft, answer, evidence, verdict and others. Memory that outlives a run sits on a separate state port, which cannot be linked.
Which chains hold up
35 architectures give 1,225 ordered pairs, self-pairs included. A link from A to B exists only if A’s result is itself what B works on.
- 1,094 pairs are refused by rule: the exit of A and the entry of B share no payload kind, or the pair chains an architecture into itself.
- The other 131 were rated by two models,
claude-opus-5-5andgpt-6.1-sol, following one written rubric. - When both gave the same verdict, it was kept. That happened 98 times.
- When one said direct and the other conditional, the pair became conditional. That happened 17 times.
- When one allowed the link and the other refused it, a third model,
claude-fable-5-2, voted and the median was kept. That happened 16 times.
The result is 35 direct links, 74 conditional ones and 1,116 refusals. Each verdict carries its justification, and the data records who voted what, so the disagreements stay visible.
The composer
The composer chains architectures, the end of one into the start of the next. It only offers the links the matrix allows, 109 in all.
It produces one prompt for the whole chain. Prompts are not stored as text. They are rendered from the structured fields of each architecture: its agents, its procedure, its stop rule and its exits. A chain’s prompt is rendered from its stages and from the hand-off sentences in the matrix, which is why the composer does more than paste prompts together.
A composition can be exported and imported as a small JSON file, built and read in your browser. The composer works with taps only, on a phone.
The code snippets
Each architecture has a skeleton in LangGraph, the Claude Agent SDK, the OpenAI Agents SDK and the Vercel AI SDK. I chose those four from download counts in November 2026. The snippets are generated ahead of time and type-checked against the SDK packages. They are starting points and should not go to production as they are.
How I use it
I pass this site to Volaris portfolio companies when they ask for it, or when I see the need come up. It brings them ideas, and a useful maieutic: the pages ask before they answer. That helps a team integrate AI more effectively in its own context.
The research behind the patterns
Most of these architectures come from published research. The site names the source paper on the page of each architecture that has one, 22 of the 35:
- Reflection. Madaan et al., 2023. Self-Refine: Iterative Refinement with Self-Feedback
- Tool Use. Schick et al., 2023. Toolformer: Language Models Can Teach Themselves to Use Tools
- ReAct. Yao et al., 2023. ReAct: Synergizing Reasoning and Acting in Language Models
- Planning. Wang et al., 2023. Plan-and-Solve Prompting: Improving Zero-Shot Chain-of-Thought Reasoning by Large Language Models
- Blackboard. Erman et al., 1980. The Hearsay-II Speech-Understanding System
- Tree of Thoughts. Yao et al., 2023. Tree of Thoughts: Deliberate Problem Solving with Large Language Models
- Reflexion. Shinn et al., 2023. Reflexion: Language Agents with Verbal Reinforcement Learning
- Self-Discover. Zhou et al., 2024. Self-Discover: Large Language Models Self-Compose Reasoning Structures
- Chain of Verification. Dhuliawala et al., 2023. Chain-of-Verification Reduces Hallucination in Large Language Models
- Self-Consistency. Wang et al., 2022. Self-Consistency Improves Chain of Thought Reasoning in Language Models
- Language Agent Tree Search. Zhou et al., 2023. Language Agent Tree Search Unifies Reasoning, Acting, and Planning in Language Models
- Corrective RAG. Yan et al., 2024. Corrective Retrieval Augmented Generation
- Self-RAG. Asai et al., 2023. Self-RAG: Learning to Retrieve, Generate, and Critique through Self-Reflection
- Adaptive RAG. Jeong et al., 2024. Adaptive-RAG: Learning to Adapt Retrieval-Augmented Large Language Models through Question…
- GraphRAG. Edge et al., 2024. From Local to Global: A Graph RAG Approach to Query-Focused Summarization
- Debate. Du et al., 2023. Improving Factuality and Reasoning in Language Models through Multiagent Debate
- Skill Library. Wang et al., 2023. Voyager: An Open-Ended Embodied Agent with Large Language Models
- STORM. Shao et al., 2024. Assisting in Writing Wikipedia-like Articles From Scratch with Large Language Models
- Tiered Memory. Packer et al., 2023. MemGPT: Towards LLMs as Operating Systems
- Constitutional Critique. Bai et al., 2022. Constitutional AI: Harmlessness from AI Feedback
- SWE Agent. Yang et al., 2024. SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering
- Workflow Memory. Wang et al., 2024. Agent Workflow Memory
Credits
The list of 35 patterns follows the inventory made popular by Fareed Khan’s all-agentic-architectures. I reused the list of names and concepts only. All the content was written for this site, and the families, the port model, the compatibility matrix and the composer are original.