Cognitive Architectures

From classic cognitive science to modern neural-symbolic agents.

Classic Cognitive Architectures

Soar (State, Operator, And Result)

Agent relevance: Explicit separation of memory systems, automatic subgoaling, chunking as skill acquisition.

ACT-R (Adaptive Control of Thought—Rational)

Key equation: Activation = Base-level + Spread + Partial matching - Base-level = log(frequency × recency) - Explains human forgetting/practice curves

LIDA (Learning Intelligent Distribution Agent)

Modern Neural-Symbolic Architectures

Neuro-Symbolic Integration Spectrum

Pure Neural ←────────────────────────────────────────→ Pure Symbolic
     │                                                      │
     ▼                                                      ▼
LLM only                                            Logic/Planner
     │                                                      │
     ▼                                                      ▼
LLM + Tools                                        LLM-guided search
     │                                                      │
     ▼                                                      ▼
Neural Theorem Prover                           Neurosymbolic DSL
     │                                                      │
     ▼                                                      ▼
AlphaGeometry                                   Program Synthesis

Integration Patterns

Key Modern Architectures

1. LLM + Classical Planner

class NeuroSymbolicAgent:
    def __init__(self):
        self.llm = LLM()
        self.planner = PDDLPlanner()  # Fast Downward, etc.

    def act(self, goal, state):
        # LLM translates natural language → PDDL problem
        pddl_problem = self.llm.translate_to_pddl(goal, state)
        # Symbolic planner finds optimal plan
        plan = self.planner.solve(pddl_problem)
        # LLM translates plan → executable steps
        return self.llm.translate_plan(plan)

2. LLM + Constraint Solver / SAT

• Use case: Scheduling, resource allocation, code synthesis
• Pattern: LLM generates constraints → Z3/SAT solves → LLM interprets
• Tools: Z3, OR-Tools, MiniZinc, Picat

3. Program Synthesis / Inductive Programming

• DreamCoder — Wake-sleep: neural proposes, symbolic verifies, library learning
• CrossBeam — Neural guides symbolic search
• Applications: DSL synthesis, API sequence generation, SQL

4. Neural Theorem Proving

• Lean + LLM — LLM suggests tactics, Lean verifies
• Isabelle + LLM — Similar pattern
• Autoformalization — Natural language → formal proof

5. Neuro-Symbolic DSLs

Memory in Cognitive Architectures

Reasoning Systems Comparison

Implementing Neural-Symbolic Agents

Architecture Template

class NeuroSymbolicAgent:
    def __init__(self):
        # Neural components
        self.perception = MultimodalEncoder()
        self.reasoning = LLM()
        self.critic = LLM()  # For reflection/verification

        # Symbolic components
        self.planner = PDDLPlanner()
        self.solver = Z3Solver()
        self.knowledge_graph = GraphDB()
        self.skill_library = SkillRegistry()

        # Integration
        self.grounding = NeuralSymbolicGrounding()
        self.compiler = SkillCompiler()  # Neural → Symbolic

    def run(self, goal):
        # 1. Perceive & Ground
        state = self.perception.observe()
        symbolic_state = self.grounding.to_symbolic(state)

        # 2. Plan (Symbolic)
        plan = self.planner.solve(goal, symbolic_state)

        # 3. Execute with Neural Monitoring
        for step in plan:
            # Neural proposes concrete action
            action = self.reasoning.propose_action(step, state)
            # Symbolic validates
            if not self.solver.validate(action, symbolic_state):
                action = self.repair(action)
            # Execute
            result = self.execute(action)

            # Neural reflects
            critique = self.critic.reflect(step, result)
            if critique.learns_skill:
                self.compiler.compile(critique)  # Distill to skill

        return result

When to Use Neural-Symbolic

Related Notes

• Core Abstractions — Core building blocks
• Single Agent Patterns — ReAct, Plan-and-Execute as neural patterns
• Control Flow — Execution control structures
• Reasoning Models — o1, CoT, ToT as neural reasoning
• Neurosymbolic Integration — Deep dive on integration
• Formal Verification — Proof-carrying agents
• Coding Agents — Program synthesis, verification
• Scientific Agents — Theorem proving, discovery

Sources: Soar (Laird), ACT-R (Anderson), LIDA (Franklin), "Neuro-Symbolic AI" (Garcez et al.), "AlphaGeometry" (Trinh et al.), "DreamCoder" (Ellis et al.), "Lean + LLM" (First et al.), "Generative Agents" (Park et al.), "MemGPT" (Packer et al.), PDDL, Z3, OR-Tools docs.