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.

🔄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.

📐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.