-
Notifications
You must be signed in to change notification settings - Fork 2
AI Agentic Architectures
35 agentic AI architectures to learn from.
The 35 agentic design patterns are production-grade architectures categorized into eight families: Reasoning & Reflection, Sampling & Search, Retrieval (RAG), Memory, Tools & Actions, Multi-Agent, Safety & Routing, and Specialty. These patterns are designed as "workflow shapes" - graphs of nodes where control flows, often utilizing loops where an agent acts, checks results, and iterates until a task is complete.
Below is a comprehensive list of the 35 patterns, organized by family, with descriptions and links to their example implementations (Jupyter notebooks).
-
Learn Every AI Agent Pattern From One Video - Great video by Theaiautomators that actually runs all 35 patterns and explains them with examples via repository code below
-
Theaiautomators GitHub Repository - this repo is a teaching harness around that excellent library (see How this uses the base repo)
These patterns use self-critique loops to iterate on and improve answer quality.
- Reflection: A producer drafts an answer, and a critic scores/critiques it; the agent then refines the output until it meets a target score.
- Reflexion: Attempts a task, evaluates the answer, and stores a "verbal lesson" in episodic memory to inform future retries.
- Chain-of-Verification (CoVe): Drafts a baseline answer, generates independent verification questions for each claim, and rewrites the final response based only on verified facts.
- Self-Discover: Composes a custom reasoning "recipe" by selecting thinking modules (e.g., critical thinking, analogies) and adapting them to solve novel problems.
- Constitutional AI: Checks a draft against a list of explicit rules (a "constitution"); each rule receives a pass/fail pass, followed by revisions to fix failures.
These patterns generate multiple candidates to find the best possible answer through search or voting.
- Self-Consistency: Generates multiple reasoning paths for the same question and uses a majority vote on the final answer.
- Tree of Thoughts: Conducts a beam search over reasoning steps; an evaluator scores thoughts to prune the search tree.
- LATS (Language Agent Tree Search): Implements Monte Carlo Tree Search (MCTS) over reasoning moves, using a rubric to judge progress and propagate rewards back up the tree.
- Mental Loop: Simulates and scores distinct candidate actions before choosing the best one to execute.
- Ensemble: Uses multiple independent "voters" (e.g., analytical, skeptical, pragmatic) and selects a final answer through weighted aggregation.
These patterns focus on grounding agent responses in external knowledge bases.
- Agentic RAG: The agent decides when and what to retrieve, potentially calling tools multiple times to flesh out knowledge.
- Corrective RAG (CRAG): Grades retrieved documents and discards irrelevant chunks; it can trigger a web search if the internal knowledge is insufficient.
- Self-RAG: Emits "reflection tokens" to assess if retrieved passages are relevant, supported, or useful before answering.
- Adaptive RAG: Classifies incoming queries to decide if retrieval is needed and determines whether to use simple or complex retrieval tracks.
- GraphRAG: Builds a Knowledge Graph (KG) of entities and relationships; it answers global questions by summarizing "communities" of related entities.
These patterns define different storage shapes to allow agents to remember context across sessions.
- Episodic + Semantic: Saves conversational turns (episodic) while extracting and storing specific facts into a Knowledge Graph (semantic).
- Graph Memory: Stores knowledge as triples (subject, predicate, object) for fact-based retrieval.
- MemGPT: Uses an OS-style "virtual memory" approach, paging facts in and out of the context window from an archival storage tier.
- Voyager: Discovers and saves reusable Python skills as real scripts in a library for later execution.
- Agent Workflow Memory (AWM): Mines successful multi-step task completions to create "workflow recipes" that guide future similar tasks.
These patterns enable agents to interact with environments, from single tools to web browsers.
- Tool Use: The most basic loop where an agent identifies a task, calls a tool, and synthesizes the result.
- ReAct: Combines explicit reasoning ("Thought") with actions ("Act") and results ("Observation") in a continuous cycle.
- Planning: Decomposes a goal into a stepped plan, executes steps, and has the ability to "re-plan" if results change the situation.
- Plan-Execute-Verify (PEV): Adds an impartial evaluator agent to judge if the output of an execution step meets specific rubric criteria.
- SWE-Agent: A coding-specific agent that interacts with a sandboxed file system to list, read, and write files.
- BrowserAgent: Uses a real Playwright-driven browser to navigate websites and interact with page elements.
These patterns orchestrate collaboration between multiple specialized agents.
- Multi-Agent: A supervisor agent routes sub-tasks to specialists, each with their own tools and personas, and then consolidates their work.
- Blackboard: Specialists "bid" on their ability to contribute to a shared workspace; a synthesis agent eventually merges the board into a final answer.
- Debate: Multiple agents answer independently and then read and argue against each other's positions for several rounds.
- STORM: A multi-perspective research system that spawns personas to interview a topic and generate a structured article.
- Meta-Controller: A high-level router that chooses the most appropriate architecture (e.g., Planning vs. Reflection) for a given task.
These focus on specialized behaviors like security gates and self-improvement.
- Dry-Run: An agent proposes an action, a simulator predicts its effects, and a reviewer must approve it before execution.
- Reflexive Metacognitive: An agent assesses its own competence before answering, choosing to hedge with caveats or escalate to a human.
- RLHF Self-Improvement: Scores candidates against detailed dimensions (e.g., "avoids cliches") using deterministic rubrics and iterates until a threshold is met.
- Cellular Automata: An LLM applies rules to nodes across a grid to simulate complex emergent behavior.
- Computer Use (Mock): Drives a simulated GUI through a safety gate to evaluate if actions like navigating to a site are secure.