🧬 biology

Cognitive Models and AI Algorithms Provide Templates for Designing Language Agents

This position paper argues that cognitive models and AI algorithms serve as effective blueprints for designing modular language agents by formalizing agent templates that specify how multiple LLMs can be combined to solve complex tasks beyond the capabilities of a single model.

Original authors: Ryan Liu, Dilip Arumugam, Cedegao E. Zhang, Sean Escola, Xaq Pitkow, Thomas L. Griffiths

Published 2026-02-27

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Ryan Liu, Dilip Arumugam, Cedegao E. Zhang, Sean Escola, Xaq Pitkow, Thomas L. Griffiths

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ⚕️ This is an AI-generated explanation of a preprint that has not been peer-reviewed. It is not medical advice. Do not make health decisions based on this content. Read full disclaimer

Imagine you have a super-smart, incredibly well-read robot (a Large Language Model, or LLM) that can write poetry, code software, and answer trivia. It's amazing on its own. But what happens when you give it a massive, complex mission? Like "Plan a surprise wedding for 200 people, manage the budget, hire the caterers, and handle a sudden rainstorm"?

A single robot might get overwhelmed, forget a step, or make a silly mistake. It's like asking one person to be the chef, the accountant, the decorator, and the security guard all at once.

This paper argues that to solve these big problems, we shouldn't just make the robot smarter. Instead, we should build a team of robots, each with a specific job, working together like a well-oiled machine.

But here's the tricky part: How do we design this team? Do we just guess who does what? Do we try a million different combinations until something works? That takes too long and costs too much money.

The authors of this paper have a brilliant idea: Stop reinventing the wheel.

The Core Idea: Borrowing Blueprints

The paper suggests that we don't need to invent new ways to organize teams from scratch. Instead, we should look at two existing libraries of "blueprints":

Cognitive Models: These are scientific maps of how the human brain solves problems.
AI Algorithms: These are mathematical recipes computers have used for decades to solve puzzles.

Think of it like building a house. You could try to invent a new way to put bricks together every time you build a wall. Or, you could look at the ancient, proven blueprints used by master architects for centuries. The paper says: Use the human brain's and old-school AI's blueprints to design your robot teams.

The "Agent Template": The Team Organizational Chart

The authors call these blueprints "Agent Templates."

Imagine you are the manager of a construction site. You don't just tell the workers, "Build a house." You give them a specific Organizational Chart (the template):

The Architect (LLM #1): Draws the plans.
The Engineer (LLM #2): Checks if the plans are safe.
The Foreman (LLM #3): Tells the workers what to do next.
The Inspector (LLM #4): Checks the work before moving on.

This chart tells you exactly who talks to whom and in what order. The paper says we can find these charts in science books!

Real-World Examples of Borrowed Blueprints

Here is how the paper translates these complex ideas into simple analogies:

1. The "Mind Reading" Team (Cognitive Models)

The Problem: You want a robot to write a message that will make a specific person feel happy.
The Human Blueprint: Psychologists have studied how humans understand each other. They use a concept called "Theory of Mind" (thinking about what others are thinking).
The Robot Team: Instead of one robot guessing, the paper suggests a team where:
- Robot A writes a draft.
- Robot B acts as the audience and simulates how they would react.
- Robot C looks at that reaction and says, "That won't work, try again."
- Result: The robot effectively "role-plays" the conversation before sending the message, just like a human does in their head.

2. The "Tree Climber" Team (Search Algorithms)

The Problem: You need to solve a hard math puzzle with many possible wrong turns.
The Old AI Blueprint: Decades ago, computer scientists invented "Tree Search." Imagine a tree where every branch is a possible answer. You don't just guess one branch; you explore many, check which ones look promising, and cut off the dead ends.
The Robot Team:
- Robot A (The Explorer) generates three different ways to solve the problem.
- Robot B (The Judge) checks which of the three looks best.
- Robot A then takes the best one and splits it into three new possibilities.
- Result: The team systematically explores the "tree" of solutions, avoiding dead ends much faster than a single robot guessing randomly.

3. The "Divide and Conquer" Team (Classic Algorithms)

The Problem: You have a giant, messy list of 1,000 items to sort.
The Computer Blueprint: A classic algorithm called "Divide and Conquer" says: "Don't sort the whole list. Break it into two lists of 500. Sort those. Then break those into 250. Keep going until you have tiny lists of 2 items, then merge them back up."
The Robot Team:
- Robot A (The Boss) breaks the big task into 10 small tasks.
- Robots B through K (The Workers) each solve one small task.
- Robot L (The Mergers) combines all the answers into the final result.
- Result: A massive problem becomes easy because it's broken down into tiny, manageable pieces.

Why Does This Matter?

The paper argues that if we use these "borrowed blueprints," we get three huge benefits:

It Works Better: These methods have been tested for 50+ years in human psychology and computer science. They are proven to work.
It's Easier to Understand: If a robot team fails, you can look at the blueprint and say, "Oh, the 'Judge' robot was too harsh," or "The 'Explorer' didn't look at enough branches." It's not a magical black box; it's a logical process.
It Saves Time: We don't have to waste years guessing which robot team structure works. We can just pick the blueprint that fits the job.

The Bottom Line

The authors are saying: Don't just throw more money at making bigger, dumber robots. Instead, look at how humans think and how old-school computers solve puzzles. Use those proven "recipes" to build teams of robots that are smarter, more reliable, and easier to understand.

It's like realizing that to build a better car, you don't need to invent a new wheel; you just need to look at the best wheel designs from the past and put them on a new chassis.

1. Problem Statement

While Large Language Models (LLMs) have achieved remarkable capabilities in isolation, designing effective language agents (systems where LLMs interact with tools or other LLMs to solve complex tasks) remains a significant challenge.

The Search Space Problem: The space of possible agent architectures is vast. Current design practices often rely on "folk intuition," manual trial-and-error, or opportunistic design rather than systematic exploration.
Data Scarcity: In high-stakes domains (e.g., healthcare), practitioners lack the data and resources to perform brute-force architectural searches or rely on simulated human data, which may not accurately reflect real-world reward distributions.
Lack of Interpretability: Many successful agent designs appear arbitrary, making them difficult to interpret, debug, or generalize to new problems.
The Gap: There is a disconnect between the rich history of cognitive science (models of human thought) and classical AI algorithms (proven solutions to search, planning, and decision-making) and the emerging field of modular language agents.

2. Methodology

The authors propose a framework where existing cognitive models and AI algorithms serve as templates for designing language agents.

A. Formal Definition: The Agent Template

The paper formalizes an Agent Template as a Directed Acyclic Graph (DAG) $G = (V, E)$ :

Vertices ( $V$ ): Represent modules, which are either LLMs or external tools.
Edges ( $E$ ): Represent the flow of data and execution order between modules.
Structure: The template specifies a set of functions and their interactions. Inputs enter at root vertices, flow through intermediate processing nodes (which may involve state updates, memory, or tool use), and exit at terminal vertices.
Statefulness: Unlike simple input-output mappings, these templates can consume and emit stateful information (e.g., updating a "posterior" belief or a count of visited states) to support sequential decision-making.

B. The Core Argument

The authors argue that instead of searching for a "best" design from scratch, researchers should instantiate these proven templates using LLMs.

Cognitive Models: Provide mechanistic hypotheses about how humans process information (e.g., recursive social inference, episodic future thinking).
AI Algorithms: Provide tested procedural solutions for problems like search, divide-and-conquer, and reinforcement learning (RL).
Implementation: LLMs act as the flexible, expressive engine to implement the specific functions (nodes) within these templates, leveraging natural language for reasoning and tool interaction.

3. Key Contributions and Survey of Templates

The paper surveys existing literature to demonstrate how specific agent designs are direct instantiations of cognitive models or AI algorithms.

A. Templates Based on Cognitive Models

Communication (Rational Speech Acts - RSA):
- Concept: Communication as a rational choice involving recursive social inference (thinking about what others think).
- Agent Template: $\{ \Lambda_{advisor}, \Lambda_{generator}, \Lambda_{profiler}, \Lambda_{simulator}, \Lambda_{aggregator} \}$ .
- Example: An agent simulates audience reactions to potential utterances to select the best one (Liu et al., 2023; Qiu et al., 2025).
Reasoning and Planning (Prefrontal Cortex Modeling):
- Concept: Planning as reasoning about actions, often involving decomposition and error monitoring.
- Agent Template: Modular Agentic Planner (MAP) with modules for decomposition, action proposal, monitoring, prediction, and orchestration.
- Example: Webb et al. (2025) use this to solve multi-step problems like the Tower of Hanoi.
Representation (Language of Thought - LoT):
- Concept: Thinking as executing code (variable manipulation, conditionals).
- Agent Template: $\{ \Lambda_{reasoner}, \Lambda_{interpreter} \}$ .
- Example: Program-aided Language Models (PaL) and Chain of Code, where LLMs generate code to solve math or logic problems, and an interpreter executes it.

B. Templates Based on AI Algorithms

Search Algorithms:
- Concept: Traversing a state space to find a solution.
- Templates:
  - Tree of Thoughts (ToT): Implements Breadth-First or Depth-First search using $\{ \Lambda_{generator}, \Lambda_{evaluator} \}$ .
  - Beam Search: Uses a "correctness" LLM to prune reasoning chains (Xie et al., 2023).
  - A Search:* Used for multi-modal web navigation (Koh et al., 2025).
  - Monte-Carlo Tree Search (MCTS): Suggested as a future template for complex domains like Go/Chess.
Divide and Conquer:
- Concept: Breaking problems into subproblems, solving them, and aggregating results.
- Templates: $\{ \Lambda_{decomposer}, \Lambda_{solver}, \Lambda_{aggregator} \}$ .
- Example: Least-to-Most prompting and HuggingGPT, where a controller decomposes tasks and assigns them to specialized models.
Reinforcement Learning (RL) Algorithms:
- Concept: Sequential decision-making under uncertainty.
- Templates:
  - Policy Iteration (ICPI): Uses $\{ \Lambda_{policy}, \Lambda_{transition}, \Lambda_{reward} \}$ to approximate MDPs and iteratively improve policies (Brooks et al., 2023).
  - Posterior Sampling for RL (PSRL): Uses $\{ \Lambda_{sample}, \Lambda_{policy}, \Lambda_{posterior} \}$ to sample plausible environment hypotheses and act optimally, enabling efficient exploration (Arumugam & Griffiths, 2025).
  - Information-Directed Sampling (IDS): Extends PSRL by explicitly scoring actions based on expected regret vs. information gain, allowing for deliberate exploration (Arumugam & Griffiths, 2025).

4. Results and Evidence

The paper does not present new empirical results but synthesizes evidence from existing literature to validate the template approach:

Performance: Agents instantiated from these templates (e.g., ToT, MAP, PSRL-based agents) consistently outperform baselines (like standard Chain-of-Thought or random policies) on benchmarks such as Tower of Hanoi, PlanBench, Wordle, and mathematical reasoning tasks.
Interpretability: By mapping an agent's architecture to a known algorithm (e.g., "this agent is doing Beam Search"), researchers can better understand why an agent succeeds or fails, rather than treating it as a black box.
Generalization: Templates like Divide-and-Conquer and Search have been successfully applied across diverse domains, including coding, image generation, and robotics.

5. Significance and Future Directions

Paradigm Shift: The paper advocates moving away from arbitrary, heuristic-driven agent design toward a principled approach grounded in decades of cognitive science and AI research.
Bridging Fields: It highlights the synergy between cognitive science (understanding human cognition) and AI (building intelligent systems), suggesting that LLMs can now scale these cognitive models to new, complex environments.
Call to Action: The authors encourage researchers to:
- Explore underutilized templates from hypothesis generation, information theory, and evolutionary algorithms.
- Apply multi-agent system concepts (e.g., voting, game theory) to collaborative agent design.
- Use these templates to reverse-engineer and improve cognitive models by testing them in open-ended, realistic agent environments.

Conclusion: The paper posits that the "blueprints" for the next generation of robust, interpretable, and effective language agents already exist in the literature of cognitive models and classical AI algorithms. The task for the AI community is to recognize these patterns and systematically instantiate them using the flexibility of LLMs.