Cognitive Architectures for Language Agents
Theodore R. Sumers12 min readResearch
FOUNDATIONALAI AgentsAdvanced
Key takeaway
Foundational work on memory, planning and action architecture.
Updated on Oct 3, 2026
01
Abstract
- CoALA stands for Cognitive Architectures for Language Agents.
- The paper proposes a systematic framework for organizing LLM-based agents.
- It draws on cognitive science and symbolic AI rather than treating agents as prompt patterns alone.
- CoALA represents an agent using modular memory, a structured action space, and a decision-making process.
- The framework is intended both to describe existing agents and guide future agent design.
- The paper positions language agents as a continuation of ideas from cognitive architectures.
- CoALA is an architectural framework rather than a new language model.
02
Introduction
- Recent LLM agents combine language models with external resources or internal control flows.
- Examples include Internet access, tools, retrieval, prompt chaining, reasoning traces, and environmental interaction.
- Despite empirical successes, agent designs were difficult to compare systematically.
- Cognitive science provides established concepts for memory, planning, action, and control.
- Symbolic AI provides ideas for modularity, explicit state, planning, and structured decision making.
- CoALA combines these perspectives with modern language-model agents.
- The framework aims to provide a common vocabulary for agent architecture.
03
Problem
- The paper identifies a lack of systematic organization across existing language-agent systems.
- The problem is not simply how to make an LLM answer better, but how to structure an agent around memory, actions, and control.
- An agent must interact with both internal information and an external environment.
- Long-horizon behavior requires mechanisms beyond a single context window.
- Different memories serve different functional roles and should not be collapsed into one store.
- Action selection should distinguish internal cognitive operations from external environment actions.
- A general architecture should accommodate different implementations and model capabilities.
04
Methodology
- CoALA describes an agent as repeatedly selecting actions based on its current memory state and observations.
- Internal actions operate on memory or cognitive state.
- External actions affect the environment through tools or other interfaces.
- The decision process can include reasoning and planning before an external action.
- Environment feedback becomes new information available to subsequent decisions.
- Memory updates allow information to persist beyond a single interaction.
- This produces a recurrent perception/decision/action/memory cycle.
- The architecture can support reactive behavior as well as deliberative planning.
Figure 1
05
Architecture
- The architecture separates memory, action, and decision-making modules.
- Working memory provides the immediate state used during control.
- Semantic memory represents generalized knowledge.
- Episodic memory represents particular experiences.
- Procedural memory represents learned or stored procedures.
- The action space includes internal operations such as memory retrieval and external operations such as tool calls.
- A controller or decision process chooses among these actions.
- The environment supplies observations that update the agent state.
- The modular decomposition allows different implementations for each component.
06
Dataset
- CoALA does not prescribe one fixed dataset because it is a conceptual architecture.
- Instead, it organizes evidence from a broad body of existing language-agent work.
- Existing systems are mapped to architectural components such as memory, actions, planning, and reasoning.
- Examples discussed by the framework include ReAct, Reflexion, Voyager, and other language agents.
- Different tasks require different combinations of memory and action capabilities.
- The framework therefore treats task environment and agent architecture as interacting design factors.
- Evaluation should ultimately test the capabilities enabled by these architectural components.
07
Training
- CoALA treats the language model as a central decision-making component rather than as the entire agent.
- LLMs can perform reasoning, planning, language understanding, and action selection.
- External memory and tools extend the model beyond its parametric knowledge and context window.
- Memory can be implemented with retrieval systems, databases, summaries, or other mechanisms.
- Procedures can be represented as reusable skills or programs.
- The architecture is compatible with both neural and symbolic components.
- The framework therefore does not require training a new foundation model.
08
Experiments
- The paper retrospectively uses CoALA to organize existing language-agent systems.
- It identifies architectural patterns across agents rather than comparing them only by benchmark score.
- ReAct illustrates interleaving reasoning and acting.
- Reflexion illustrates verbal feedback and episodic memory.
- Voyager illustrates procedural skill accumulation and environmental interaction.
- Other systems demonstrate retrieval, planning, tool use, or long-term memory.
- The analysis shows that apparently different agents can be understood through common architectural components.
- CoALA also identifies missing capabilities that suggest future research directions.
09
Baselines
- The framework can be contrasted with monolithic LLM prompting.
- Prompt-only systems primarily rely on the model's context and parametric knowledge.
- CoALA adds explicit memory and structured action mechanisms.
- It also differs from simple RAG because memory can include episodic and procedural information, not only retrieved facts.
- It differs from fixed workflows because the decision process can dynamically select among internal and external actions.
- Traditional cognitive architectures provide conceptual precedents for modular memory and control.
- CoALA adapts these ideas to language-model-based agents.
10
Results
- CoALA's main result is a systematic architectural vocabulary for language agents.
- The framework organizes memory into working, semantic, episodic, and procedural components.
- It explicitly represents actions that operate internally and externally.
- It places a generalized decision-making process between observations, memory, and actions.
- The retrospective analysis shows how existing agents instantiate different subsets of these capabilities.
- The framework identifies architectural gaps rather than claiming a single universally optimal agent.
- Its primary contribution is conceptual and organizational rather than a new benchmark score.
11
Conclusion
- CoALA provides a cognitive-architecture lens for designing LLM agents.
- Its key abstractions are modular memory, structured actions, and generalized decision making.
- Working, semantic, episodic, and procedural memory have distinct roles.
- Agents can act internally on their own state or externally on an environment.
- The framework unifies many previously separate agent techniques under a common architecture.
- It provides a roadmap for future work on persistent memory, planning, learning, and control.
- The paper argues that progress toward more capable language agents requires architectural organization beyond prompting alone.
12
References
- Theodore R. Sumers, Shunyu Yao, Karthik Narasimhan, and Thomas L. Griffiths, “Cognitive Architectures for Language Agents,” arXiv:2309.02427.
- The paper was published in Transactions on Machine Learning Research (TMLR).
- Primary source: https://arxiv.org/abs/2309.02427.
- CoALA is explicitly inspired by cognitive science and symbolic AI.
- Its core architecture comprises modular memory, a structured action space, and generalized decision making.
- Memory categories include working, semantic, episodic, and procedural memory.
- The paper uses CoALA to organize existing language-agent research and identify future architectural directions.
Source trail
Primary papers, implementation pages, and external source records used to ground this explainer.
Continue reading
Related research
AI Agents
GitSwarm
GitSwarm turns inference-time work into a persistent, branchable body of reusable contributions that later agents can build on.
AI AgentsLongHarness
LongHarness helps agents reason over 100M-token document collections by keeping evidence and conclusions as explicit, revisable states that guide one another.
AI AgentsGenerative Agents
An agent architecture combining memory, retrieval, reflection, and planning to simulate believable long-horizon behavior.