Sébastien Fichot

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.

Sébastien Fichotprojects

Open the site

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:

  1. What problem does it solve?
  2. When should I not use it, and what should I use instead?
  3. How does work move through it? This level has a diagram, a step-by-step walkthrough and the ports.
  4. 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-5 and gpt-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:

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.