LLM Agent Design Patterns

🧠7 Cognitive-Function Axes

Dimensions of Agent Cognition

The framework decomposes an agent's cognition into 7 axes: (1) Perception — how inputs are processed; (2) Memory — how context is retained; (3) Planning — how tasks are decomposed; (4) Reasoning — logic and inference patterns; (5) Execution — how tools are used; (6) Learning — how experience is integrated; (7) Communication — information exchange between agents. The combination across these 7 axes defines an agent's 'cognitive profile.'

🗂️3 Tiers of Memory

In-context · External · Episodic

The memory axis is implemented in three tiers. (1) In-context: held directly inside the LLM's context window — fast, but size-limited. (2) External: vector DBs, graph DBs, KV stores — high-capacity, but with retrieval latency. (3) Episodic: storing past task history and success/failure patterns — enabling long-term learning. GraphBit implements all three tiers, eliminating context loss on long-running tasks.

🔍The ReAct Pattern

Reasoning + Action, Alternating

ReAct is the most battle-tested reasoning pattern: it loops Thought → Action → Observation. Upside: the intermediate reasoning is transparent and debuggable. Downside: cost and latency grow linearly as the step count rises. Plan-and-Execute instead drafts the full plan up front and then executes it — better for parallelization, but less flexible when the plan needs revising.

🌐6 Execution-Topology Axes

How Agents Are Wired

The execution structure of an agent system is classified along 6 axes: (1) single vs. multi-agent; (2) centralized vs. distributed control; (3) synchronous vs. asynchronous execution; (4) fixed vs. dynamic role assignment; (5) serial vs. parallel task execution; (6) trust/verification escalation paths. The combination across these 6 axes defines an agent's 'topology,' and the 7×6 matrix generates 27 distinct patterns.

👥Supervisor–Worker Pattern

The Most-Adopted Topology

The most widely adopted multi-agent topology. A supervisor (orchestrator) decomposes the task and assigns it to worker agents, each holding specialized tools and context. Upsides: separation of roles, parallel execution, failure isolation. Downsides: the supervisor is a single point of failure, plus the cost of sharing context across workers. This pattern is LangGraph's default structure.

open_in_new startupxo.com/ko/news/2026/05/llm-agent-design-patterns-production

🔄DAG Execution Engine

GraphBit's Core Innovation

GraphBit (arXiv:2605.13848) represents the task-execution graph as a DAG (directed acyclic graph) and runs it on a Rust engine. DAG upsides: dependency-driven parallelism, deterministic execution paths, and partial re-runs after a failure. The Rust engine adds memory safety plus high performance. Result: 67.6% on GAIA (+14.7pp) with 0% hallucination. Its execution reliability is structurally different from prior Python agent frameworks.

📊GAIA 67.6%

+14.7pp · 0% Hallucination

GAIA (General AI Assistant) is a benchmark that evaluates AI agents on real-world tasks — web search, file manipulation, code execution, and multi-step reasoning. GraphBit's 67.6% is a 14.7pp gain over the previous SOTA, and the 0% hallucination follows from the DAG structure cutting off uncertain reasoning paths. The practical takeaway: GAIA-level task-completion rates are becoming the reliability bar for production agents.

⚖️5 Empirical Laws

The Criteria for Choosing a Pattern

The 5 empirical laws for pattern selection derived in arXiv:2605.13850: (1) Time budget — tight timeouts call for simple patterns; (2) Privilege — high-privilege tasks require verification escalation; (3) Cost of failure — irreversible actions demand human-in-the-loop; (4) Throughput — high-throughput needs call for parallel topologies; (5) Uncertainty — high uncertainty calls for iterative-refinement patterns. These laws mark a paradigm shift: not 'can GPT-4 do it?' but 'which structure fits this risk profile?'

🛡️Human-in-the-Loop

When the Cost of Failure Is High

The implementation of the 'cost of failure' law: irreversible actions (sending email, making payments, deploying code, deleting files) are not run autonomously — the agent asks a human to confirm. The pattern: detect a decision below the confidence threshold → present it to a human with context → resume after approval. An agent without this pattern simply can't be shipped to production.

🔧Framework Selection Guide

LangGraph · CrewAI · Anthropic SDK

Apply the taxonomy to real tool choices: (1) complex, state-machine-based workflows → LangGraph; (2) role-based multi-agent → CrewAI; (3) single-agent tool use → the Anthropic Tool Use API directly; (4) DAG-based, high-reliability production → reference the GraphBit architecture; (5) fast prototypes → LangChain Agents. Framework choice should be the consequence of choosing a topology — never the other way around.

open_in_new startupxo.com/ko/news/2026/05/llm-agent-design-patterns-production

📐Agentic-AI Engineer

A New Role in Demand

Engineers who understand the 27 patterns and the 5 selection laws are 2026's most in-demand AI specialization. The difference between a chatbot implementer and an agentic-systems engineer: the former calls a model; the latter designs structures for reliable task completion. Tool-design quality > prompt quality — the schema of the tools an agent uses determines the agent's performance.