Cognitive architecture

On this page 7

A cognitive architecture is the fixed blueprint of an intelligent system: the set of memory stores, reasoning processes, perception channels and action mechanisms, together with the rules for how they interact, that turn goals and inputs into behavior. In artificial intelligence, and especially in the design of AI agents, the term describes what stays constant across tasks, while knowledge and goals change.

The idea comes from cognitive science, where classic architectures such as Soar and ACT-R were built as unified theories of human cognition. Today the same term describes how language model agents are organized: which memory they keep, how they plan, how they choose actions and how they learn from outcomes. A good architecture makes an agent predictable, inspectable and extensible; a weak one produces agents that improvise structure on every run.

Core components of a cognitive architecture

Almost every cognitive architecture separates memory, decision making and interaction with the environment. The details differ, but the functional roles recur across symbolic systems, hybrid systems and modern agent designs built around a large language model.

The table below lists the components that appear in most designs and the role each one plays.

ComponentRoleAgent-era equivalent
Working memoryHolds the current situation and active goalsContext window and agent scratchpad
Episodic memoryRecords past experiences and outcomesLogged trajectories and conversation history
Semantic memoryStores general facts and conceptsRetrieval index or knowledge graph
Procedural memoryEncodes skills and how to actModel weights, prompts and agent skills
Decision cycleSelects the next operationAgent loop with planning and tool selection
Perception and actionConnects the system to its environmentTool calls, browser and computer-use interfaces
Typical components and their roles

The decision cycle is the heart of the architecture. In Soar it proposes, evaluates and applies operators; in ACT-R production rules fire based on buffer contents; in a language model agent the model reads working memory, reasons, and either calls a tool or produces an answer, repeating until a stopping condition is met.

Classic and modern families

Cognitive architectures fall into symbolic, emergent and hybrid families, distinguished by how they represent knowledge. Symbolic systems manipulate explicit rules and structures, emergent systems rely on learned distributed representations, and hybrid systems combine both.

FamilyExamplesStrengthWeakness
SymbolicSoar, BDI agent frameworksTransparent, verifiable reasoningBrittle outside hand-coded knowledge
Hybrid symbolic-subsymbolicACT-R, CLARIONModels human timing and learningComplex to build and calibrate
Emergent or connectionistDeep reinforcement learning agentsLearns directly from dataOpaque, needs large training budgets
Language model agentReAct, plan-and-execute, CoALA-style designsBroad knowledge and flexible reasoningUnreliable, costly, hard to verify
Representative architecture families

The CoALA framework (Cognitive Architectures for Language Agents) explicitly maps modern agents onto the classic vocabulary: working memory, long-term memory types, internal actions such as reasoning and retrieval, and external actions such as tool use. It shows that many agent frameworks are variations of one decision loop rather than fundamentally new designs.

How an architecture differs from a framework or model

A cognitive architecture is a design specification, not a piece of software or a trained model. The same architecture can be implemented in several agent frameworks, and the same model can power several architectures.

ConceptWhat it definesExample question it answers
Cognitive architectureStructure of memory, reasoning and actionWhere does the agent store what it learned
Agent frameworkSoftware library implementing agent patternsWhich code orchestrates tool calls
Foundation modelLearned capability for language and reasoningHow well can the agent interpret text
Agent harnessRuntime that executes and constrains the agentWhich tools and permissions exist
Agent orchestrationCoordination of several agents or stepsWhich agent handles which subtask
Related concepts compared

Confusing these layers leads to poor decisions. Replacing the model does not fix an architecture with no long-term memory, and adopting a new framework does not add reflection or planning unless the architecture includes them.

Design choices for language model agents

Designing a cognitive architecture for an agent means deciding what the agent remembers, how it plans and how it checks itself. Each decision affects cost, latency and reliability.

  • Memory scope: whether to keep only the current context, add retrieval over past episodes, or maintain a curated semantic store.
  • Planning style: interleaved reasoning and acting as in ReAct, or an explicit plan followed by execution.
  • Self-evaluation: reflection steps such as Reflexion that critique outcomes and store lessons.
  • Control structure: a single agent loop, or a hierarchical multi-agent system with an orchestrator and subagents.
  • Learning channel: whether experience updates prompts, stored skills, retrieval data or model weights.

A practical rule is to add structure only where failures appear. A simple loop with tool calling and context compaction handles many tasks; long-running agents need persistent state, checkpointing and episodic memory to resume work and avoid repeating mistakes.

Limitations and open problems

No existing cognitive architecture delivers general, reliable intelligence. Classic systems reason transparently but require extensive knowledge engineering, while language model agents are flexible but can hallucinate, lose track of goals and behave inconsistently between runs.

Memory is a persistent weak point. Agents that store everything accumulate noisy or contradictory memories, and agents that store too little forget user preferences. Evaluation is also difficult, because a component that helps on one benchmark can hurt on another, so architecture claims need task-specific testing rather than general promises.

In simple terms

A cognitive architecture is the floor plan of a thinking system. It says where short-term notes are kept, where long-term knowledge lives, how decisions are made and how the system acts in the world.

Think of a well-organized office: an inbox for current tasks, filing cabinets for records, a manual of procedures and a manager who decides what happens next. The people and documents change every day, but the layout stays the same. AI agents need a similar layout so that they can work on long tasks without losing track.

A practical example

A software company builds an agent that triages customer support tickets. The first version is a single prompt with tool calling, and it handles simple tickets but repeats the same wrong diagnosis for recurring issues because it remembers nothing between conversations.

The team redesigns the cognitive architecture. Working memory holds the current ticket, a semantic memory indexes product documentation, an episodic memory stores resolved tickets with their fixes, and a reflection step records why an answer was rejected by a human reviewer. Planning is split into diagnosis and response drafting. After two months, the share of tickets that human agents must rewrite drops from about 40 percent to about 20 percent, and engineers can trace each answer to the memories and steps that produced it.