SOAR Cognitive Architecture – Allen Newell & John Laird

The pursuit of synthetic intelligence has historically oscillated between two distinct methodological paradigms: the development of isolated, task-specific algorithmic optimizations and the construction of comprehensive, domain-general cognitive architectures. While the former approach has yielded extraordinary mathematical breakthroughs in narrow domains—ranging from game-theoretic tree searches to contemporary deep statistical pattern recognition—it frequently sidesteps the foundational question that animated the pioneers of artificial intelligence: how can a single, integrated computational system organize perception, deliberative reasoning, motor actuation, and continuous learning within an ecologically valid, real-time environment? Standing at the theoretical and historical pinnacle of this integrative quest is the Soar cognitive architecture, conceived and developed by Allen Newell, John Laird, and Paul Rosenbloom.

Emerging from decades of foundational inquiry at Carnegie Mellon University and the University of Michigan, Soar represents one of the most ambitious and rigorously formalized attempts to instantiate a Unified Theory of Cognition. Rather than viewing intelligence as an ad hoc collection of disparate functional modules, Soar posits that general intelligence arises from a parsimonious, highly constrained computational engine grounded in the search of symbolic problem spaces. Through an unwavering commitment to the Physical Symbol System Hypothesis, Soar operationalizes the mind not as a statistical black box, but as a deliberate, goal-directed, and reflective symbolic processor capable of converting continuous environmental feedback into discrete, actionable representations of state and intention.

Over four decades of continuous theoretical refinement and engineering evolution, Soar has progressed from an early experimental system implemented in Lisp to a high-performance, multi-paradigm C++ architecture that synthesizes symbolic deliberation with episodic memory, semantic networks, spatial-visual simulation, and reinforcement learning. This article provides an exhaustive, mathematically and computationally rigorous investigation into the structural anatomy, procedural mechanics, algorithmic underpinnings, real-world deployments, and enduring epistemological legacy of the Soar cognitive architecture, establishing its indispensable role in the ongoing pursuit of robust, transparent, and verifiable artificial general intelligence.

1. Historical Genesis and Theoretical Foundations of Soar

1.1 Allen Newell and the Quest for Unified Theories of Cognition

In his landmark 1973 paper, “You Can’t Play 20 Questions with Nature and Win,” Allen Newell issued an uncompromising methodological challenge to the cognitive psychology and artificial intelligence communities. Newell observed that psychological science had fragmented into an uncoordinated matrix of binary, micro-theoretical debates—such as whether processing was serial or parallel, analog or propositional, conscious or unconscious. He argued that simply continuing to accumulate empirical micro-theories of narrow experimental phenomena would never coalesce into a comprehensive science of the mind. Instead, Newell insisted that the path forward required the formulation of Unified Theories of Cognition (UTC): integrated, computationally realized theoretical architectures capable of simultaneously explaining how perceptual processes, motor execution, memory retrieval, problem-solving, and continuous learning operate in concert within a single, bounded cognitive agent.

The philosophical and technical zenith of this manifesto arrived during Newell’s 1987 William James Lectures at Harvard University, later formalized in his seminal 1990 book, Unified Theories of Cognition. In these lectures, Newell laid out the computational criteria that any viable candidate architecture must satisfy to credibly model human intelligence. An authentic cognitive architecture, Newell posited, must operate under severe temporal and informational constraints. It must exhibit real-time performance, executing discrete cognitive cycles on the order of tens of milliseconds while accommodating continuous, high-bandwidth perceptual inputs and generating coordinated motor behaviors. Furthermore, it must demonstrate robust goal-directed behavior, adapt dynamically to novel and unexpected environmental configurations, employ vast bodies of declarative and procedural knowledge, and perpetually acquire new capabilities without succumbing to catastrophic interference.

This theoretical stance marked a critical epistemological pivot away from the earlier heuristic search programs that Newell, along with Herbert Simon and Cliff Shaw, had constructed in the 1950s and 1960s, such as the Logic Theorist and the General Problem Solver (GPS). While GPS demonstrated that complex deductive tasks could be formulated as search through state spaces guided by means-ends analysis, it remained an isolated, task-specific reasoning tool that relied on hand-coded heuristics and external scaffolding. Soar was engineered to transcend these foundational limitations by embedding problem space navigation directly into the immutable micro-architecture of the system. Through this synthesis, Newell envisioned Soar not merely as an artificial intelligence framework, but as an empirical hypothesis concerning the fundamental computational architecture of human cognition.

1.2 The Collaborative Development: John Laird and Paul Rosenbloom

The realization of Newell’s grand architectural vision required an exceptional convergence of systems engineering, theoretical computer science, and empirical psychology. This synergy materialized in the late 1970s and early 1980s through the intensive collaboration between Allen Newell at Carnegie Mellon University and his doctoral students, John Laird and Paul Rosenbloom. Laird brought a formidable systems perspective and a profound insight into real-time execution, focusing on the rigorous mechanization of problem spaces, the design of dynamic working memory systems, and the elimination of architectural bottlenecks that had historically paralyzed complex production rule engines. Rosenbloom, meanwhile, had been investigating the empirical dynamics of human learning—most notably the universal power law of practice, which describes how reaction times on cognitive tasks diminish as a power function of cumulative trials.

The core computational breakthrough of this partnership was the synthesis of problem space navigation with an automatic, universal learning formulation known as chunking. Rosenbloom and Laird discovered that by instrumenting the problem solver to continuously monitor its own internal impasses—situations where the current knowledge base was insufficient to determine the next cognitive step—the architecture could automatically compile the deliberative, multi-step subgoaling processes required to resolve those impasses into new, atomic procedural production rules. This single, elegant mechanism unified task execution and continuous acquisition of expertise, allowing Soar to exhibit the power law of practice purely as an emergent property of its internal structural operations.

The engineering trajectory of Soar spans more than four decades of continuous development. Soar 1, instantiated in 1983, was an interpretive prototype coded in Franz Lisp, designed primarily to validate the theoretical cohesion of universal subgoaling and problem space search. Recognizing that Lisp implementations imposed severe memory overhead and non-deterministic garbage collection pauses incompatible with real-time operational guarantees, Laird orchestrated a comprehensive architectural rewrite. Soar 6, completed in the early 1990s, transitioned the entire engine to ANSI C, yielding orders of magnitude improvements in execution velocity and memory footprint. This transition enabled the deployment of Soar agents in real-time military simulations and autonomous robotics. The architecture subsequently evolved through Soar 7 and Soar 8, which overhauled the decision cycle and memory persistence semantics, culminating in Soar 9, an industrial-strength, object-oriented modern C++ architecture that expands classical symbolic processing with native subsymbolic, spatial-visual, and long-term declarative memory systems.

1.3 The Physical Symbol System Hypothesis as an Epistemological Core

At the deepest philosophical level, Soar rests upon the Physical Symbol System Hypothesis (PSSH), articulated by Allen Newell and Herbert Simon in their 1975 Turing Award lecture. The hypothesis makes a radical, foundational empirical claim: a physical symbol system possesses the necessary and sufficient means for general intelligent action. A physical symbol system is formally defined as a physical machine that realizes a set of physical components (symbols) that can appear as component parts of other structures (symbol structures or expressions). The system contains processes that operate on these structures, creating, modifying, replicating, and destroying them according to dynamically interpreted computational laws. The designation “physical” emphasizes that these systems are subject to the laws of physics and can be realized within physical hardware—whether that hardware consists of biological neural networks or silicon microprocessors.

To fully grasp the epistemological architecture of Soar, one must maintain the critical distinction introduced by Newell between the knowledge level and the symbol level. At the knowledge level, an intelligent agent is characterized entirely by its goals, its knowledge of its environment, and the principle of rationality: the postulate that an agent will select an action that its knowledge indicates will lead to the satisfaction of its goals. The knowledge level is completely independent of algorithmic representations or computational mechanics. The symbol level, by contrast, constitutes the operational realization of the knowledge level; it is the concrete, mechanistic tier where symbols, pointers, production rules, and data structures interact under algorithmic control to approximate the ideal rational behavior prescribed by the knowledge level.

Throughout its history, Soar has served as the primary computational bulwark defending symbolic architectures against the recurring critiques of pure connectionism, radical embodiment, and dynamic systems theory. Early connectionists asserted that symbolic systems were inherently brittle, incapable of robust generalization, and fundamentally detached from continuous perceptual realities. In response, the architects of Soar demonstrated that the perceived limitations of classical symbolic systems were not intrinsic to symbolic processing itself, but were artifacts of flawed architectural choices—such as rigid, hand-coded control flows, isolated reasoning modules, and the absence of intrinsic learning mechanisms. By providing an integrated engine where symbolic structures are continuously matched, evaluated, and compiled at the millisecond scale, Soar established that symbolic manipulation can achieve high-performance real-time reactivity, graceful degradation under uncertainty, and robust lifelong adaptation.

2. The Problem Space Hypothesis and Core Computational Philosophy

2.1 Mathematical and Conceptual Formulation of Problem Spaces

The fundamental computational axiom of Soar is the Problem Space Hypothesis, which posits that all goal-directed cognitive behavior, across all domains and levels of abstraction, is formulated as search through discrete problem spaces. Mathematically, a problem space within Soar can be defined as a formal quadruple consisting of a set of states, a set of operators, an initial state representation, and a goal specification. Formally, let a problem space $PS$ be denoted as:

$$PS = \langle S, O, s_0, G \rangle$$

where $S$ represents the set of all realizable symbolic states, $O: S \rightarrow S$ represents a set of partial transition functions designated as operators, $s_0 in S$ represents the initial state configuration, and $G: S \rightarrow {\text{true}, \text{false}}$ is a dynamic predicate that evaluates whether a given state satisfies the terminal criteria of the current objective.

Within this paradigm, navigation through a problem space proceeds through the sequential selection and application of operators. An operator is the discrete, indivisible quantum of purposeful cognitive progression. While the working memory of an agent may undergo continuous, monotonic elaboration as new inferences are derived, the agent only makes progress toward its goal when an operator is formally applied to mutate the current state $s_t$ into a new state $s_{t+1}$. This operationalization applies universally: whether an agent is calculating a complex mathematical theorem, interpreting an ambiguous acoustic token, navigating an obstacle-laden terrain, or selecting a conversational utterance, the behavior is executed as an explicit sequence of operator selections and applications inside an appropriately configured problem space.

The topological characteristics of problem spaces vary dramatically along a continuum from knowledge-lean to knowledge-rich domains. In a knowledge-lean domain—such as the classic Tower of Hanoi or the 8-puzzle—the agent possesses minimal domain-specific heuristics. Consequently, the problem space exhibits a high branching factor, necessitating explicit combinatorial search, state tree expansion, and heuristic backtracking. Conversely, in a knowledge-rich domain—such as grandmaster chess play or expert medical diagnosis—vast repositories of procedural and declarative knowledge immediately constrain the branching factor. In an optimally knowledgeable Soar agent, the problem space collapses into a linear trajectory: at each state $s_t$, the system’s compiled production rules directly identify and apply the uniquely optimal operator $o^*$, eliminating combinatorial exploration entirely through immediate, associative cognitive execution.

2.2 Deliberation Versus Reaction in Problem Space Traversal

A perennial tension in cognitive modeling and autonomous systems engineering is the architectural dichotomy between deliberative, slow, lookahead planning and rapid, unthinking, reactive execution. Soar resolves this tension not by segregating deliberation and reaction into disconnected software modules, but by unifying them within a single computational cycle that dynamically transitions between the two modes based entirely on knowledge availability. Deliberation in Soar is realized through the explicit formulation and traversal of sub-problem spaces, wherein an agent can project simulated actions into hypothetical futures, evaluate intermediate states, and mentally backtrack without committing to physical motor actuation.

Reaction, on the other hand, is realized through the instantaneous parallel firing of procedural production rules. When the agent’s procedural memory contains direct, unambiguous associations between the current perceptual configuration and an appropriate operator, that operator is proposed, selected, and applied within a single cognitive cycle (typically benchmarked at approximately 50 milliseconds in human psychometrics). This architectural formulation mirrors the psychological transition from controlled processing to automaticity described in human performance literature. When an agent first encounters a complex task, it operates in a heavily deliberative regime, systematically decomposing goals into subgoals, evaluating hypothetical paths, and slowly reasoning through first principles. As expertise is compiled via Soar’s learning mechanisms, these multi-step deliberative traversals are automatically compressed into direct reactive rules, transforming computationally expensive deliberation into zero-latency pattern-driven execution.

The bounding of combinatorial explosion during problem space traversal is achieved through functional goal decomposition. Rather than maintaining an monolithic, unmanageable search tree, Soar decomposes goals into structured hierarchies of subgoals. Each subgoal defines its own localized problem space, complete with isolated states, localized operators, and constrained termination criteria. By dynamically restricting the scope of search to compact, context-specific sub-problem spaces, the architecture prevents the factorial explosion of variable bindings and heuristic evaluations, maintaining tractable operational bounds even in environments characterized by vast state-action spaces.

2.3 Heuristic Search Strategies and Search Control

In classical artificial intelligence systems, search control is typically hard-coded into the algorithmic driver through static traversal routines such as depth-first search, breadth-first search, or $A^*$ search with fixed numeric heuristics. In Soar, search control is entirely symbolic, declarative, and dynamic. Search control is mediated by the generation of symbolic preferences, which are first-class computational tokens asserted into working memory by procedural rules during the evaluation of proposed operators. These preferences express qualitative and comparative judgments regarding the desirability of pursuing specific operators in the current context.

Soar provides an expressive lattice of preference semantics. Categorical preferences assert properties of a single operator in isolation: acceptable indicates that an operator is legally viable for consideration; require mandates that the operator must be selected unless a catastrophic conflict occurs; reject completely removes an operator from the candidate pool; and prohibit forbids selection within the current decision context. Comparative preferences establish explicit partial orders between pairs of operators: an operator can be asserted as better or worse than another candidate. Finally, indifferent preferences—which can be numeric or non-numeric—state that the system has no qualitative basis for favoring one candidate over another, permitting random or probabilistic selection.

This declarative preference regime empowers knowledge-directed pruning of redundant state spaces. If the agent’s procedural memory holds knowledge indicating that a particular branch of exploration is deadlocked or redundant, a rule immediately asserts a reject or worse preference, instantaneously pruning that entire subtree from consideration. Furthermore, Soar gracefully accommodates imperfect, incomplete, or ambiguous domain knowledge. When knowledge is insufficient to yield a strict total order over candidate operators, the architecture does not fail silently or force an arbitrary decision; instead, it detects the mathematical ambiguity as an impasse, cleanly transitioning from direct execution into reflective, subgoaling search. Under bounded rationality constraints, this guarantees that Soar agents converge on optimal paths when sufficient knowledge is present, while falling back gracefully on principled heuristic exploration when knowledge is incomplete.

3. Structural Anatomy: Memory Systems and Representation in Classical Soar

3.1 Working Memory Architecture and Working Memory Elements

At the operational core of classical Soar is its working memory (WM), a dynamic, globally accessible symbolic scratchpad that maintains the agent’s current understanding of its internal cognitive state, environmental perceptions, and ongoing behavioral intentions. Structurally, working memory is organized not as a flat list or an associative array, but as a rooted, directed, connected graph. The fundamental atomic building block of this graph is the Working Memory Element (WME, pronounced “whammy”). Each WME is a discrete semantic triple composed of three components: an identifier, an attribute, and a value:

$$\text{WME} = \langle \text{Identifier}, \text{Attribute}, \text{Value} \rangle$$

The identifier is a unique system-generated symbolic token (such as S1, O4, or C12) that designates a node within the working memory graph. The attribute is an augmentative label that characterizes an outgoing directed edge originating from that node (such as ^type, ^distance, or ^child). The value can be either a primitive terminal literal (such as a string, integer, or floating-point constant) or another identifier, which establishes a directed pointer to another node in the graph. Through this recursive referencing mechanism, working memory represents deeply nested, relational structures—ranging from syntactic parse trees and hierarchical scene graphs to complex causal networks and dynamic plan representations.

Working memory elements possess distinct persistence semantics based on the functional nature of the production rules that create them. Classical Soar distinguishes between two fundamental classes of support: I-support (instantiation support) and O-support (operator support). I-support is strictly monotonic and truth-functional; WMEs generated by I-supported elaboration rules remain active in working memory only as long as the exact conditions that triggered the production rule continue to be satisfied. The moment any constituent condition becomes false—such as a perceptual cue disappearing from the sensory buffer—the corresponding I-supported WME is instantly retracted by the architecture. In contrast, O-support governs state transformations resulting from operator applications. WMEs created via O-support persist indefinitely in working memory until an explicit architectural or operator-driven action modifies or deletes them. This vital dichotomy ensures that while momentary perceptual deductions remain epistemically synchronized with external reality, deliberate cognitive commitments and state mutations survive transient perceptual shifts.

To maintain architectural integrity and prevent unbound memory expansion, Soar incorporates continuous, deterministic garbage collection mechanisms. Because working memory is defined as a rooted graph—anchored at the top-level state identifier—any subgraph that becomes disconnected from the active goal hierarchy due to operator application or preference retraction becomes functionally unreachable. The architecture’s memory manager immediately identifies and reclaims these unlinked WMEs, preventing memory leaks and mitigating the severe computational overhead that unmanaged working memory churn would otherwise impose on the rule-matching engine.

3.2 Production Memory and Asynchronous Pattern Matching

While working memory represents transient, dynamic state information, long-term procedural knowledge in classical Soar is instantiated entirely within production memory. Production memory consists of an unbounded collection of condition-action rules, known as productions. Formally, a production rule $P$ consists of a left-hand side (LHS) containing a conjunction of positive and negative relational patterns to be tested against working memory, and a right-hand side (RHS) specifying a set of symbolic actions to be executed upon the successful satisfaction of the LHS:

$$P: \quad C_1 wedge C_2 wedge dots wedge \neg C_k long\rightarrow A_1, A_2, dots, A_m$$

The conditions on the LHS match against WMEs, binding symbolic variables to identifiers and values across the working memory graph. The actions on the RHS assert new WMEs, create qualitative preferences, or queue output commands for external motor effectors.

A foundational architectural property of Soar’s production memory is symmetric matching. Unlike classical von Neumann computational architectures, which rely on explicit program counters, sequential instruction pointers, and rigid subroutines, Soar’s production memory is completely non-sequential and asynchronous. Rules do not invoke other rules directly, nor do they possess knowledge of which production fired previously. Instead, every production acts as an independent, autonomous cognitive daemon that perpetually and passively monitors working memory. The moment the current configuration of working memory satisfies the LHS conditions of a production, the rule instantiates immediately and symmetrically, driven entirely by the availability of data.

Critically, classical Soar completely eschews the rule conflict resolution mechanisms common to early expert system shells, such as OPS5. In typical expert systems, if fifty rules match the current working memory simultaneously, a conflict resolution algorithm (such as recency, specificity, or arbitrary ordering) selects exactly one rule to fire while suppressing the remaining forty-nine. Newell and Laird recognized that conflict resolution at the production level constitutes an artificial, ungrounded cognitive bottleneck. In Soar, there is no conflict resolution among productions during the elaboration phase: all matching productions fire simultaneously in parallel. This parallel monotonic elaboration ensures that the agent rapidly deduces all logically accessible inferences from the current state within a single cognitive instant, preserving purely deductive completeness prior to engaging in deliberative operator selection.

3.3 Algorithmic Efficiency: The Rete Algorithm in Soar

Evaluating thousands of complex, highly variable production rules against a dynamically mutating graph of tens of thousands of working memory elements at every millisecond step represents a computational challenge of staggering proportions. A naive pattern matcher that iterated through every production rule and re-tested its conditions against working memory on every cycle would scale with an unacceptable polynomial or exponential complexity, instantly violating Newell’s mandate for real-time operational execution. To overcome this fundamental scalability barrier, Soar implements a highly customized, radically optimized variant of Charles Forgy’s Rete algorithm.

The Rete algorithm operates by compiling the LHS conditions of all production rules in production memory into an expansive, unified dataflow network. This compiled network is structured into two primary components: the Alpha Network and the Beta Network. The Alpha Network is responsible for performing intra-element, non-variable feature tests. When a WME is added to or removed from working memory, it enters the root of the Alpha Network, which rapidly filters the token based on constant attribute and value tests (e.g., verifying whether ^type == aircraft). Tokens that pass these localized tests are stored in specialized Alpha Memories, which represent the current set of working memory elements satisfying single, isolated conditions.

The Beta Network manages inter-element variable bindings, performing relational join operations across disparate conditions. The nodes in the Beta Network—primarily two-input join nodes and Beta Memories—receive inputs from both the Alpha Memories and preceding Beta nodes. A join node tests whether variables shared between different conditions match the identical working memory identifiers or values (e.g., confirming that the ?aircraft identifier bound in Condition 1 is identical to the target identifier bound in Condition 2). The catastrophic combinatorial cost of multi-variable pattern matching is mitigated through extensive sub-network sharing: if hundreds of distinct production rules share common subsets of conditions, the Rete compiler unifies those conditions into a single physical path within the network, completely eliminating redundant computations.

In Soar, the standard Rete algorithm is modified to accommodate the exceptional churn and structural dynamics of graph-based working memory. Soar introduces aggressive memory-node unlinking optimizations. When a specific branch of the Beta Network detects that one of its constituent memory nodes has become empty (meaning no WMEs currently satisfy that condition), the architecture dynamically unlinks that node from the active evaluation chain. Consequently, incoming tokens bypass the inert subgraphs entirely, shielding the pattern matcher from computational degradation. These architectural refinements allow Soar agents possessing tens of thousands of complex productions to execute hundreds of decision cycles per second, achieving genuine real-time cognitive performance.

4. The Soar Decision Cycle: Deliberative Temporal Dynamics

4.1 Input and Elaboration Phases

The dynamic execution of a Soar agent is governed by a recurring, highly structured architectural sequence known as the Soar Decision Cycle. This cycle represents the fundamental clock tick of the cognitive architecture, temporally aligned with the 50-millisecond threshold observed in human psychological chronometry. The decision cycle does not progress via linear, procedural programming steps; rather, it transitions through distinct, deterministic phases that alternate between continuous sensory transduction, parallel deductive reasoning, fixed algorithmic decision-making, and motor actuation. The cycle initiates with the Input Phase, wherein the architecture reads high-bandwidth environmental signals from external sensory buffers. These continuous physical inputs—whether originating from robotic sensors, virtual game worlds, or textual streams—are converted by interface transductors into discrete Working Memory Elements and grafted directly onto the sensory root nodes of the working memory graph.

Once the sensory inputs are synchronized into working memory, the system transitions into the Elaboration Phase. The elaboration phase is a monotonic, parallel deductive cascade. During this phase, all production rules whose conditions are satisfied by the current state fire simultaneously. Crucially, the firing of these rules asserts new working memory elements, which in turn satisfy the conditions of additional productions, triggering a subsequent wave of parallel firings. This iterative cascade continues uninterrupted across multiple internal cycles until the working memory graph achieves a state of formal quiescence—a mathematical condition where no further production rules in procedural memory can legally match the current state.

The elaboration phase is rigorously guaranteed to exhibit termination properties provided the rule base adheres to standard stratified monotonic design. Because elaboration rules only derive implicit relational consequences, synthesize candidate operators, and assert evaluative preferences without mutating the underlying state of the current problem space, this phase functions as an instantaneous logical closure of the agent’s knowledge base. It is during this elaboration cascade that the architecture evaluates incoming perceptual tokens, computes derived geometric relationships, tests contextual affordances, and proposes candidate operators for subsequent selection.

4.2 Operator Proposal and Evaluation Mechanics

The cognitive transition from passive state awareness to active, goal-directed behavior occurs through the dual mechanisms of operator proposal and operator evaluation, both of which are executed via production firings during the elaboration phase. An operator is never arbitrarily injected into working memory; it must be proposed by a rule that detects a specific, actionable configuration within the current state. When an operator proposal rule fires, it constructs an operator identifier in working memory and links it to the current state via an ^operator attribute, simultaneously generating an acceptable preference token. This acceptable preference signifies to the architecture that the candidate operator is legally valid for consideration in the present context.

Simultaneously, specialized operator evaluation rules fire to analyze the candidate operators. These rules examine the relationship between the proposed operators, the agent’s active goal hierarchy, internal drives, and contextual constraints. The output of these evaluation rules is not a set of procedural code instructions, but an expressive network of preference assertions deposited directly into an internal architectural structure known as the preference cache. These preferences can take multiple forms, including:

• Categorical Preferences: Unary assertions regarding a single operator, such as acceptable (viable), require (mandatory), reject (disqualified), and prohibit (forbidden).
• Comparative Preferences: Binary relational assertions that establish relative superiority, specifying that operator $O_a$ is strictly better than operator $O_b$, or conversely that $O_c$ is worse than $O_d$.
• Indifferent Preferences: Assertions stating that multiple operators possess equivalent qualitative value, which can be non-numeric (indicating arbitrary choice) or numeric (providing real-valued scalars utilized by reinforcement learning mechanisms).

Through this modular decoupling of proposal and evaluation, Soar achieves remarkable cognitive flexibility. One set of rules can propose five distinct candidate actions (e.g., advancing, retreating, taking cover, communicating, or observing), while an entirely independent set of rules—embodying tactical doctrines, safety constraints, or ethical boundaries—generates comparative preferences that systematically rank, filter, and arbitrate between those candidates. The preference assertions form a directed graph of comparative precedence, which the architecture subsequently evaluates through a mathematically formalized decision procedure.

4.3 Decision and Application Phases

Once the elaboration phase reaches quiescence and no further preferences can be asserted, the architecture initiates the Decision Phase. Unlike the preceding elaboration phase, which is driven entirely by the open-ended matching of dynamic production rules, the decision phase is executed by an immutable, hardwired architectural algorithm: the Decision Procedure. The decision procedure acts as an impartial, definitive arbiter that analyzes the contents of the preference cache to select a single operator for installation onto the current state. The algorithm processes the preference graph through a strict, hierarchical logic:

1. Any candidate operator that has received a reject preference (or a context-active prohibit preference) is immediately excised from the candidate pool, regardless of what positive preferences it may have received.
2. If any single candidate operator possesses a require preference, and no other conflicting require preferences exist, that operator is immediately selected.
3. The procedure evaluates the comparative preference network (better and worse tokens), constructing a topological sort to identify dominant candidates.
4. If the topological sort yields a single, uniquely dominant candidate operator, the decision procedure selects that operator, terminating the phase.
5. If the preference network contains mutually indifferent candidates, the architecture uses either random selection (for non-numeric indifferents) or a Boltzmann softmax distribution (for numeric indifferents) to resolve the choice deterministically.
6. If the preference network is mathematically indeterminate—due to a complete lack of candidates, an unresolvable tie between competing candidates, or circular, contradictory comparative preferences (e.g., $O_1 > O_2$ and $O_2 > O_1$)—the decision procedure halts execution and architecturally generates an impasse.

Assuming an operator is successfully and unambiguously selected, the architecture transitions directly into the Application Phase. During application, specialized operator application productions match against the newly selected operator identifier and fire to modify working memory. Crucially, while elaboration rules provide transient I-support, operator application rules generate persistent O-support. These application rules systematically add, modify, or retract WMEs on the state node, transforming the current state $s_t$ into the succeeding state $s_{t+1}$. Finally, during the subsequent Output Phase, any WMEs linked to the external output buffer are parsed by environmental transductors and transmitted as physical motor commands to external actuators, completing the deliberative temporal cycle.

5. Impasses, Universal Subgoaling, and Architectural Metacognition

5.1 Taxonomy and Formal Etiology of Impasses

The hallmark of classical expert systems and rigid software architectures is their catastrophic fragility when confronted with incomplete, conflicting, or missing knowledge: when an anticipated condition is unmet, execution abruptly terminates with an unhandled exception or enters an infinite loop. Soar inverts this paradigm entirely. Within Soar, the absence of actionable knowledge is not an unrecoverable failure; it is the fundamental catalyst for advanced cognition, learning, and autonomous reflection. Whenever the architectural decision procedure is mathematically incapable of selecting a single, unambiguous operator, the system encounters an impasse.

Soar formalizes exactly four mutually exclusive, computationally exhaustive classes of impasses based on their underlying preference topology:

• Tie Impasse: Occurs when two or more candidate operators have received acceptable preferences, but the comparative preference network fails to isolate a single superior candidate, and the candidates have not been asserted as mutually indifferent. This represents a state of knowledge-level underdetermination.
• Conflict Impasse: Arises when the preference network contains contradictory comparative assertions that cannot be resolved through topological sorting—such as an assertion that Operator A is better than Operator B alongside an assertion that Operator B is better than Operator A. This represents a state of knowledge-level contradiction.
• Constraint Failure Impasse: Generated when multiple mutually exclusive operators concurrently receive require preferences, or when an operator is simultaneously subjected to require and prohibit directives.
• State No-Change Impasse: Occurs when an operator has been successfully selected and installed onto the current state, but after reaching quiescence in the subsequent elaboration phase, no operator application rules fire to modify the state, or the application fails to satisfy the operator’s intended transformation. This indicates that the agent lacks the direct procedural knowledge required to execute the chosen action.

The formal etiology of an impasse is always traced to a gap between the structural demands of the task environment and the procedural knowledge currently compiled within the agent’s production memory. Rather than relying on external diagnostic routines, the architecture itself detects the precise mathematical failure within the preference cache, converting a procedural halt into a structured, epistemically rich opportunity for autonomous problem-solving.

5.2 Universal Subgoaling Mechanics

The architectural response to an impasse is instantaneous, automatic, and absolute: Soar executes Universal Subgoaling. The moment an impasse is detected, the micro-architecture automatically synthesizes a brand-new, isolated working memory context known as a substate. This substate is appended directly below the stalled parent state in working memory, establishing a hierarchical link. The substate is populated with an explicit, architectural representation of the impasse itself, detailing the exact type of impasse (e.g., ^type tie), the candidate operators involved in the deadlock, and pointers to all relevant WMEs from the parent context.

By creating a substate, the architecture transforms the computational impasse into an autonomous, reflective problem space: the agent now possesses a meta-goal to resolve the impasse that paralyzed its parent state. Within this newly spawned substate, the full machinery of Soar operates without restriction. The agent initializes a sub-problem space, proposes sub-operators, evaluates them via newly asserted preferences, and navigates the substate using its standard decision cycle. If the substate encountered an operator tie, the sub-problem space may implement an explicit evaluation strategy: it can propose a lookahead operator that mentally simulates the application of candidate Operator A to observe its downstream consequences, compares those consequences against a simulated application of candidate Operator B, and subsequently derives a comparative preference based on empirical projection.

Because universal subgoaling is an intrinsic architectural primitive, it is fundamentally recursive. If an agent working within a substate encounters another situation of incomplete knowledge while attempting to evaluate a simulated operator, the decision procedure detects a secondary impasse and automatically spawns a sub-substate. There is no theoretical limit to the depth of this reflective hierarchy: Soar agents can maintain deep, arbitrary stacks of subgoals, dynamically reflecting upon their own internal reasoning processes, evaluating competing strategies, interrogating long-term declarative memories, or executing complex metacognitive meta-reasoning across deeply nested layers of abstraction.

5.3 Impasse Resolution and Substate Collapse

An impasse persists only as long as its underlying mathematical etiology remains unresolved in the preference cache. The moment the reasoning processes executing within a substate achieve an epistemic breakthrough, the substate’s purpose is fulfilled. Consider a tie impasse between Operator A and Operator B: the agent simulates both candidates across multiple decision cycles within its substate, ultimately discovering that Operator A leads directly to a critical sub-goal success state. Armed with this deduction, a production rule within the substate fires to assert a comparative preference in the parent context: Operator A is better than Operator B.

The assertion of this preference instantly updates the parent context’s preference cache. On the very next decision cycle evaluation, the decision procedure re-evaluates the parent context. The mathematical ambiguity that triggered the tie impasse has vanished: Operator A now stands as the uniquely dominant candidate. Consequently, the decision procedure selects Operator A, and the impasse is formally broken. What follows is the immediate, architectural collapse of the substate. The architecture recognizes that the condition which necessitated the creation of the substate no longer exists; it instantly severs the substate identifier from working memory.

This substate collapse triggers immediate garbage collection, pruning all intermediate working memory elements, exploratory branches, and transient hypotheses constructed during the substate’s internal reasoning. However, through the foundational mechanism of persistent O-support and the operation of the chunking engine, the validated epistemic results—the resolving preference and any state modifications exported to the parent—survive the collapse completely intact. Through this mechanism, Soar achieves sophisticated architectural metacognition: the agent reflects upon its own operational limits, executes targeted internal problem-solving to overcome them, and cleanly incorporates the resulting insights into its primary behavioral stream without the intervention of an external meta-interpreter.

6. Learning Mechanisms: The Architecture of Chunking

6.1 Explanation-Based Learning Foundations

The primary computational mechanism for lifelong learning in classical Soar is chunking. Chunking is not an arbitrary statistical heuristic, nor is it an empirical curve-fitting procedure. Computationally and theoretically, chunking is a specialized, highly operationalized variant of Explanation-Based Learning (EBL). The foundational insight of EBL is that an intelligent system can acquire general, robust capabilities from a single training instance, provided that the system possesses a domain theory capable of deductively explaining why that instance succeeded or failed.

In Soar, the substate problem-solving that occurs during universal subgoaling serves as the deductive explanation. When an agent resolves an impasse, the sequence of production firings and working memory state mutations executed within the substate constitutes a formal, constructive proof that a specific configuration of parent-level conditions yields the resolving result. Chunking operationalizes this proof: it automatically analyzes the dependencies that underpinned the substate resolution and compiles that multi-step, multi-cycle deductive derivation into a single, permanent production rule known as a chunk.

This mechanism constitutes what Newell and Rosenbloom termed epistemic caching. Prior to chunking, the agent must expend substantial computational resources—potentially consuming hundreds of decision cycles, exploring hypothetical lookahead branches, and evaluating sub-operators—to determine how to resolve the impasse. Once the chunk is formed and installed directly into procedural memory, subsequent encounters with identical or structurally isomorphic situations bypass the impasse entirely. The newly compiled chunk fires immediately during the initial elaboration phase, instantly asserting the resolving preference or state modification in a single, zero-latency cognitive cycle. Learning in Soar is thus lifelong, continuous, and intrinsically woven into the fabric of execution.

6.2 Dependency Tracing and Rule Formation Mechanics

The mathematical formation of a chunk is executed by an architectural module that performs continuous dependency tracing throughout the life of a substate. The architecture maintains a dynamic, directed acyclic graph that records the causal provenance of every working memory element generated within the substate. Specifically, it tracks precisely which WMEs served as conditions for which production firings, and which rule firings generated subsequent WMEs. When a production rule within the substate finally asserts a result into the parent context (such as an operator preference or a state augmentation), the chunking mechanism initiates a backward traversal across this dependency graph.

Starting at the resolving result, the dependency tracer works backward, recursively traversing the antecedents of each rule firing that contributed causally to that result. The algorithm terminates its backward search the moment it intersects working memory elements that were already present in the parent context prior to the creation of the substate, or that were provided as external perceptual inputs. The collection of parent-level WMEs discovered at these terminal boundaries forms the foundational basis for the Left-Hand Side (LHS) of the new chunk, while the resolving result constitutes its Right-Hand Side (RHS).

Crucially, during this backward trace, the chunking mechanism performs aggressive condition pruning and structural generalization:

• Pruning of Irrelevant Intermediates: Any exploratory dead-ends, failed hypotheses, or intermediate substate calculations that did not contribute causally to the final resolving result are completely excised from the rule formulation.
• Variable Generalization: The concrete symbolic identifiers specific to the current working memory instance (e.g., S1, O4, A12) are systematically replaced with generalized production variables (e.g., <s>, <o>, <a>). This step ensures that the resulting chunk is not tied to the specific transient identifiers of the substate, but will match any future state that exhibits the identical relational topology.
• Immediate Rete Integration: The newly generalized production is instantaneously compiled into the active Rete match network, rendering it immediately available to fire on the very next decision cycle without requiring system restart or offline recompilation.

6.3 Pathologies of Chunking: The Utility Problem and Overgeneralization

Despite its theoretical elegance, the mechanization of universal chunking revealed profound computational and epistemological pathologies during extensive empirical deployments in the late 1980s and 1990s. The most severe of these phenomena is the celebrated Utility Problem, extensively investigated in Soar by Milind Tambe, Robert Doorenbos, and Allen Newell. The utility problem manifests when an agent, accumulating thousands of compiled chunks over long operational lifespans, experiences severe cognitive degradation: the computational cost of testing and matching the complex, highly interconnected LHS conditions of learned chunks within the Rete network dramatically exceeds the computational cost of simply resolving the impasses via deliberative subgoaling from first principles.

The root of this pathology lies in what Tambe identified as expensive chunks. When an impasse involves deep, non-linear combinatorial search or tests vast structural relations within a substate, the dependency tracer produces chunks featuring dozens of interconnected variables and extensive relational join operations within the Beta Network. Evaluating these cross-condition joins can trigger worst-case exponential matching complexity inside the Rete engine. To combat the utility problem, Doorenbos introduced the Unique-Attribute heuristic and strict architectural constraints on chunk formation, culminating in the design of algorithms that bound the combinatorial complexity of Rete matching by enforcing structural limits on the topology of allowable learned productions.

A second, equally dangerous pathology is overgeneralization. Overgeneralization occurs when a learned chunk fires in a novel context where its application is semantically invalid, leading to incorrect actions or systemic catastrophic failure. This occurs primarily because classical dependency tracing operates purely on the explicit conditions matched by production rules, remaining blind to implicit dependencies or negative reasoning (e.g., concluding that a condition holds because an exhaustive search failed to find a counterexample). If a substate relies on the absence of an obstacle to assert an operator, a standard dependency trace may omit the absence test from the chunk’s LHS, generating an ungrounded rule that asserts the operator even when an obstacle is physically present. Modern iterations of Soar (specifically Soar 8 and Soar 9) addressed these vulnerabilities by overhauling the dependency tracer to comprehensively track non-monotonic conditions, architectural negation, and identity constraints, establishing formal correctness proofs that ensure chunks preserve strict deductive fidelity to the underlying domain theory.

7. Evolution to Soar 9: Expanding Beyond Pure Symbolism

7.1 Episodic Memory (EpMem): Mechanics and Integration

For nearly three decades, Soar operated under an unyielding architectural dogma: all persistent long-term knowledge had to be encoded exclusively as procedural production rules, and all learning had to occur via chunking. However, extensive cognitive modeling and engineering trials revealed that procedural memory alone is fundamentally ill-suited for capturing continuous, temporal, autobiographical experiences. An agent relying purely on procedural rules struggles to answer basic retrospective questions, such as “Where was Object X located five minutes ago?” or “Have I visited this room previously, and what action did I attempt there?” To resolve these systemic limitations, John Laird and his collaborators fundamentally expanded the architecture, culminating in the release of Soar 9.

The first major architectural expansion in Soar 9 is the integration of Episodic Memory (EpMem). EpMem provides the agent with an automatic, autobiographical record of its experienced history. At every decision cycle, the EpMem module automatically captures a complete, structured snapshot of the active working memory graph. To prevent memory exhaustion during lifelong continuous operations, EpMem does not duplicate the entire working memory graph at each tick; instead, it utilizes a highly compressed, interval-based directed acyclic graph (DAG) storage engine. In this model, working memory elements are stored once, annotated with valid temporal intervals $[t_{\text{start}}, t_{\text{\end}}]$ denoting the exact span of decision cycles during which they were continuously active.

Episodic retrieval is actively controlled by the agent via dedicated working memory buffers. When an agent requires retrospective historical context, it populates an EpMem query buffer with a cue graph—a partial structural pattern describing the features of the past event it seeks to recall. EpMem then executes a cue-directed retrieval algorithm across its compressed historical store. If an exact temporal match does not exist, EpMem performs a similarity-weighted partial match, using continuous mathematical scoring functions to return the historical episode that exhibits the highest structural and semantic overlap with the query cue. The reconstructed historical subgraph is then deposited directly into an EpMem result buffer in working memory, allowing the deliberative rules of the agent to inspect past mistakes, identify environmental trajectories, and reason about historical contingencies.

7.2 Semantic Memory (SMem): Declarative Knowledge Integration

The second pillar of the Soar 9 memory expansion is Semantic Memory (SMem). While procedural memory encodes *how* to perform actions via condition-action rules, and episodic memory encodes *when* specific events transpired via temporal traces, semantic memory explicitly encodes general, associative, declarative facts about the world—representing *what* is true independently of autobiographical context. Structurally, SMem is realized as an expansive, persistent, directed semantic network composed of concepts, objects, and relational predicates.

A crucial theoretical innovation in SMem is the synthesis of discrete symbolic representations with continuous, subsymbolic activation dynamics heavily inspired by John R. Anderson’s ACT-R architecture. Every declarative node $i$ stored within SMem possesses a continuous, real-valued base-level activation $A_i$, which models the availability of that knowledge chunk in human memory. The activation level is mathematically governed by a power-law decay function reflecting the frequency and recency of prior retrievals:

$$A_i = \ln \left( \sum_{k=1}^{n} t_k^{-d} \right)$$

where $n$ is the total number of times node $i$ has been retrieved, $t_k$ is the elapsed time since the $k$-th retrieval, and $d$ is a standard architectural decay parameter (typically set to 0.5). SMem augments base-level activation with associative spreading activation, wherein energy propagates from nodes currently present in working memory across semantic relational links to connected declarative concepts.

Agents interact with semantic memory through deterministic and probabilistic retrieval commands mediated by working memory buffers. An agent can execute a cue-based query, directing SMem to locate a node possessing specific attributes and values. When multiple declarative nodes satisfy the structural query, the architecture breaks the tie by selecting the candidate exhibiting the highest subsymbolic activation. Furthermore, SMem supports continuous declarative learning: an agent can deliberately write new facts into SMem or augment existing nodes directly from working memory, establishing an expanding store of general knowledge that scales gracefully into millions of facts without degrading the real-time matching speed of procedural production rules.

7.3 Reinforcement Learning (RL) Integration

The third transformative component of Soar 9 is the intrinsic integration of Reinforcement Learning (RL). In classical Soar, the numeric values of indifferent preferences were either static or non-existent, leaving the system with no principled mechanism for acquiring optimal policies in stochastic, reward-driven environments. Soar 9 incorporates computational reinforcement learning directly into its symbolic architecture, grounding numeric indifferent preferences in the mathematical formalisms of temporal difference learning, specifically SARSA and Q-learning.

The architectural mechanics of Soar-RL establish an elegant bridge between discrete symbolic search and continuous value function approximation. In Soar-RL, individual procedural rules—known as *RL-rules*—propose candidate operators while simultaneously generating numeric indifferent preferences. The numeric value associated with the preference acts as the system’s estimate of the expected discounted future reward (the Q-value) of selecting that specific operator in the current symbolic state:

$$Q(s, o) long\leftrightarrow \text{Numeric Indifferent Preference Value of Rule } P_{s,o}$$

When the decision procedure selects an operator based on these numeric values (using an exploration policy such as $epsilon$-greedy or Boltzmann softmax), the architecture monitors the subsequent reward signals returned by the environment or internal reward-evaluation rules.

Upon receiving a reward, the architecture computes a temporal difference error $\delta$:

$$\delta_t = r_{t+1} + \gamma Q(s_{t+1}, o_{t+1}) – Q(s_t, o_t)$$

The architecture then modifies the numeric weight of the firing RL-rule’s RHS preference value via the standard update rule:

$$Q(s_t, o_t) \leftarrow Q(s_t, o_t) + \alpha \delta_t$$

Because the conditions of the RL-rule match symbolic, generalized patterns of working memory elements, this mechanism realizes symbolic value function approximation: the agent updates not merely a single tabular entry, but an entire class of functionally equivalent states captured by the generalized variables of the rule. This continuous adaptation enables Soar agents to optimize complex operational policies in non-stationary, noisy environments while maintaining complete symbolic transparency.

8. The Spatial-Visual System (SVS) and Embodied Perception

8.1 Bridging Continuous Geometry and Discrete Symbolism

A foundational challenge confronting any purely symbolic cognitive architecture is the Symbol Grounding Problem, formally articulated by Stevan Harnad. How can the discrete, amodal, arbitrary symbols manipulated by an engine like Soar correspond meaningfully to the continuous, multidimensional, noisy physical geometry of the real world? For decades, symbolic architectures attempted to evade this dilemma by relying on external transductors to convert perceptual data into discrete symbolic predicates (e.g., asserting ^block-A ^left-of block-B) prior to cognitive processing. However, this approach stripped the agent of quantitative metric information, severely impairing its ability to reason about subtle spatial affordances, trajectories, velocities, and physical occlusions.

To establish a principled, architectural solution to this challenge, Samuel Wintermute and John Laird developed the Spatial-Visual System (SVS), integrated natively into Soar. SVS constructs an architectural bridge between continuous spatial geometry and discrete symbolic reasoning by realizing a dual-representation perceptual pipeline. Rather than forcing continuous sensory inputs directly into amodal symbolic WMEs, SVS maintains an explicit, internal, quantitative 3D geometric scene representation alongside the symbolic working memory graph.

The architectural interface between SVS and working memory is bi-directional and strictly formalized:

• Continuous Sensory Input: Continuous 3D point clouds, polygonal meshes, bounding boxes, and joint angles from physical sensors or simulation engines stream directly into the SVS geometric environment.
• Spatial Extractors: Specialized algorithmic operators running within SVS continuously process the quantitative scene geometry, translating spatial metric relationships into qualitative symbolic predicates.
• Working Memory Injection: The extracted qualitative relations—such as ^intersects true, ^distance 4.2, or ^occluded false—are dynamically projected into dedicated perceptual buffers in symbolic working memory, where standard production rules can immediately match against them.

This dual-representation architecture allows Soar agents to preserve the continuous, metric fidelity of the physical world within its native geometric substrate, while simultaneously empowering the symbolic procedural engine to reason about those spatial configurations using discrete, high-level declarative logic.

8.2 Scene Graphs and Qualitative Spatial Reasoning

Within SVS, physical space is represented internally as a hierarchical, transformational scene graph, mirroring modern computational geometry and physics engines. Objects in the scene are modeled as discrete geometric nodes possessing explicit metric transformations (position, orientation, scale) and physical hull geometries (such as spheres, boxes, convex hulls, or detailed triangular meshes). The hierarchical structure of the scene graph allows SVS to represent articulated physical systems with high fidelity—such as a robotic manipulator consisting of a base, shoulder, elbow, and gripper—where child transformations are defined relative to parent reference frames.

The transformation of continuous geometry into symbolic knowledge is mediated by a sophisticated library of spatial extractors that perform Qualitative Spatial Reasoning (QSR). SVS does not burden the symbolic rule engine with calculating Euclidean distances or trigonometric transformations. Instead, procedural rules assert declarative extractor queries into the SVS working memory interface. These extractors compute properties such as:

• Topological Relations: Region connection calculi, calculating whether physical entities are disjoint, externally connected, overlapping, or fully contained within one another.
• Directional and Bearing Metrics: Qualitative compass bearings, egocentric orientations (e.g., ahead, behind, to the left of), and relative elevation angles.
• Proximity and Collision Vectors: Quantitative distance vectors and continuous line-of-sight ray tracing to ascertain perceptual occlusion and impending physical collision.

Furthermore, SVS incorporates dynamic forward projection capabilities. Under the direction of symbolic operator proposals, SVS can extrapolate the velocity vectors and physical dynamics of detected entities, projecting their trajectories forward in time. This enables an agent operating under partial observability and severe sensory noise to continuously track object permanency, anticipate where a temporarily occluded target will emerge, and reason about continuous environmental trends long before they manifest in discrete sensory feedback.

8.3 Mental Imagery and Internal Spatial Simulation

Beyond functioning as a passive perceptual filter, SVS serves as an active computational substrate for mental imagery, directly operationalizing Stephen Kosslyn’s psychological theories of human visual imagery within an artificial cognitive architecture. In Kosslyn’s paradigm, mental imagery is not a metaphorical, amodal symbolic process, but an active, depictive simulation that preserves metric spatial properties, allowing an agent to inspect affordances, mentally rotate objects, and run hypothetical physical simulations internally.

In Soar, mental imagery is orchestrated through universal subgoaling. When an agent encounters an impasse regarding how to manipulate a physical object—such as attempting to maneuver an irregularly shaped piece of furniture through an angled doorway—it spawns a substate dedicated to spatial simulation. Within this substate, symbolic operators issue direct manipulation commands to SVS. These commands do not actuate external physical motors; instead, they manipulate the internal 3D models within the SVS scene graph:

• Mental Rotation: The agent commands SVS to incrementally rotate the internal geometric model of the object along specified Euler axes.
• Spatial Clipping and Volumetric Slicing: The agent tests whether the bounding geometry of the rotated object collides with the doorway boundary.
• Visual Perspective-Taking: The agent shifts its internal camera viewpoint to simulate the visual perspective of an external collaborator or an adversarial agent.

This internal geometric simulation enables the agent to evaluate complex spatial hypotheses without risking costly physical errors in the real world. Once SVS projects that a specific rotational sequence achieves collision-free passage, a spatial extractor detects the success condition and asserts an operator preference into the parent context, resolving the impasse. The chunking mechanism then traces the dependencies of this resolution, compiling an immediate procedural rule that links the spatial configuration directly to the successful motor action. By balancing amodal symbolic inference with depictive spatial simulation, Soar bridges the historic chasm between pure logic and embodied physical reasoning.

9. Comparative Cognitive Architectures: Soar vs. Contemporary Frameworks

9.1 Soar Versus ACT-R: Rationality Versus Biological Plausibility

Within the cognitive science community, the most prominent comparative baseline for Soar is John R. Anderson’s ACT-R (Adaptive Control of Thought—Rational) architecture. While both systems trace their intellectual origins to the cognitive revolution of the late 20th century, share production system heritage, and seek a unified theory of cognition, they diverge fundamentally in their driving epistemological priorities, structural organizations, and validation methodologies.

Soar was conceived primarily as an engineering-oriented science of general intelligence. Its principal mandate, as formulated by Newell, is the realization of a universal computational engine capable of achieving autonomous, rational behavior across any task environment, bounded primarily by the principle of rationality. ACT-R, conversely, was engineered from its inception to model human empirical psychometric data with extreme mathematical fidelity. ACT-R is validated by its ability to replicate human reaction times down to the millisecond, account for human memory retrieval error distributions, and map its functional modules directly onto specific anatomical structures of the human brain (e.g., mapping the goal buffer to the anterior cingulate cortex and the declarative retrieval buffer to the ventrolateral prefrontal cortex).

This philosophical divergence is mirrored in their structural topologies:

• Architectural Organization: Classical Soar maintains a monolithic, single-cycle problem space architecture, where a unified working memory graph is processed symmetrically by a single Rete production network. ACT-R is modular and distributed, organizing cognition around specialized peripheral buffers (visual, motor, declarative, goal) coordinated by a central production system that can process only one production per cycle.
• Conflict Resolution: ACT-R relies intrinsically on subsymbolic utility equations to resolve conflicts among competing productions at every cycle, choosing a single rule based on expected gain and historical probability of success. Soar completely rejects production-level conflict resolution, executing all matched elaboration rules in parallel and reserving conflict arbitration entirely for the knowledge-directed operator decision phase.
• Learning Paradigms: Historically, Soar relied exclusively on top-down, deductive explanation-based learning (chunking), whereas ACT-R integrated bottom-up, Bayesian subsymbolic parameter tuning alongside declarative compilation. While Soar 9 has incorporated many subsymbolic activations and reinforcement learning primitives, it remains anchored to the Problem Space Hypothesis, prioritizing autonomous problem solving and functional scale over localized neurobiological fidelity.

9.2 Soar Versus Connectionist and Deep Learning Paradigms

The dramatic ascendancy of deep learning and connectionist models has established a stark computational contrast with Soar’s symbolic paradigm. Deep neural networks model intelligence as continuous, high-dimensional vector transformations, learning distributed latent representations through gradient-based optimization across massive empirical datasets. In contrast, Soar models intelligence as the deliberate manipulation of compositional, interpretable physical symbols organized into explicit problem spaces.

This fundamental distinction manifests in several critical operational trade-offs:

• Sample Efficiency and One-Shot Learning: Deep learning architectures exhibit extreme data hunger, requiring millions of training iterations and vast backpropagation updates to learn simple functional mappings. Soar, via explanation-based chunking, demonstrates genuine one-shot learning: a single resolved impasse instantly compiles a permanent, generalized procedural rule that completely eliminates subsequent problem-solving delays for that structural class.
• Interpretability and Formal Explainability: Deep neural networks are notoriously opaque black boxes whose internal decision boundaries are distributed across billions of continuous, non-linear floating-point weights. Soar’s internal operations are entirely transparent. Every state transition, operator proposal, comparative preference, and learned chunk is fully articulable as an explicit logical chain, enabling total causal traceability and verification in safety-critical domains.
• System 1 Versus System 2 Dynamics: Modern cognitive science often invokes Daniel Kahneman’s dual-process theory, bifurcating cognition into System 1 (fast, associative, intuitive, reactive) and System 2 (slow, deliberative, logical, analytical). Deep learning models map exceptionally well onto System 1 perceptual pattern recognition. Soar, while capable of System 1 reactivity via automatic production firing, was primarily engineered as a comprehensive realization of System 2 deliberative planning, causal projection, metacognition, and symbolic reasoning.
• Catastrophic Forgetting and Robustness: When a standard neural network is trained sequentially on distinct tasks, gradient updates on the new objective overwrite previously acquired weight topologies, triggering catastrophic forgetting. Soar’s procedural memory accumulates chunks monotonically, using explicit structural LHS conditions to prevent newly acquired rules from overwriting existing competencies. Furthermore, while deep networks are susceptible to adversarial perturbations—where unnoticeable input noise completely scrambles classification—Soar’s symbolic pattern matching is governed by relational logic, conferring immunity to high-frequency perceptual deception.

9.3 Hybrid Neuro-Symbolic Integrations Involving Soar

Recognizing the complementary strengths of deep statistical learning and classical symbolic architectures, contemporary artificial intelligence research has increasingly converged on Neuro-symbolic AI. Within this emerging landscape, Soar occupies a privileged position as a mature, battle-tested deliberative core that can be interfaced with modern neural and statistical models to construct robust, end-to-end cognitive systems.

One major paradigm of neuro-symbolic integration utilizes deep convolutional neural networks or vision transformers as the sensory front-end for Soar’s Spatial-Visual System. In these hybrid architectures, raw, continuous, high-dimensional video streams are processed by neural networks to detect, segment, and classify physical objects in real time. The resulting continuous 3D bounding boxes and class labels are piped directly into SVS, which converts them into topological scene graphs and symbolic WMEs. Soar then executes high-level executive deliberation, long-term planning, and ethical reasoning over these neural detections, resolving ambiguities that would paralyze a pure deep learning system.

A second, rapidly accelerating research frontier explores the bidirectional coupling of Soar with Large Language Models (LLMs). While LLMs excel at generating fluent natural language, synthesizing broad commonsense associations, and retrieving zero-shot domain summaries, they suffer from fatal hallucinations, lack persistent autobiographical grounding, and exhibit catastrophic failures in multi-step deductive planning. In hybrid Soar-LLM architectures, the LLM is deployed as an external declarative oracle or heuristic hypothesis generator. When a Soar agent encounters an open-ended impasse in a novel domain, it queries the LLM to propose potential sub-goals or domain constraints. Soar then internalizes these proposals into its formal problem space, using its decision cycle, preference logic, and physical simulation (via SVS) to rigorously verify the LLM’s suggestions before committing to physical action. In this framework, Soar serves as an architectural verification and symbolic safety constraint wrapper, guaranteeing that the probabilistic outputs of generative models adhere to formal operational constraints.

10. Real-World Applications, Large-Scale Systems, and Deployments

10.1 TacAir-Soar: Large-Scale Military Simulation

The most celebrated, historically significant, and computationally demanding deployment of the Soar cognitive architecture is TacAir-Soar. Developed in the 1990s by John Laird, Paul Rosenbloom, Randolph Jones, Frank Tambe, and their colleagues in collaboration with the Defense Advanced Research Projects Agency (DARPA) and the U.S. Department of Defense, TacAir-Soar was engineered to automate complete operational flight behaviors for tactical military aircraft participating in massive, real-time synthetic battlefield exercises.

The scale and complexity of TacAir-Soar remain a high-water mark for symbolic artificial intelligence. Prior to TacAir-Soar, distributed interactive simulations—such as the DARPA Synthetic Theater of War (STOW-97) exercise—required hundreds of human pilots operating individual flight simulators to generate realistic tactical behaviors for military training. TacAir-Soar completely replaced these human operators by deploying hundreds of autonomous, intelligent Soar agents capable of executing the full spectrum of modern tactical air combat missions, including close air support (CAS), combat air patrol (CAP), defensive counter-air, interception, and suppression of enemy air defenses (SEAD).

The engineering profile of TacAir-Soar demonstrated the unprecedented scalability of Soar’s rule engine:

• Knowledge Scale: The architecture incorporated over 8,000 highly complex, domain-specific production rules, encoding vast doctrines of military aviation, situational awareness, tactical geometries, radar operation, and multi-ship engagement rules.
• Real-Time Execution: Operating under rigorous distributed interactive simulation (DIS) protocols, individual TacAir-Soar agents were required to execute deterministic decision cycles within 50 milliseconds, processing high-frequency radar tracks, radio communications, and flight kinematics without latency spikes.
• Scalability and Rule Stability: In the STOW-97 exercise, hundreds of autonomous TacAir-Soar agents executed concurrently on synthetic battlefields alongside human pilots. Despite the extreme churn of dynamic combat data, the Rete match network operated with absolute stability: the system never crashed, rules fired with continuous determinism, and agents demonstrated complex tactical coordination, dynamically aborting missions, re-engaging adversaries, and managing sensor configurations strictly according to military doctrine.

10.2 Mobile Robotics and Autonomous Navigation

Beyond synthetic simulations, Soar has served as the executive cognitive substrate for a diverse array of physical mobile robots operating in dynamic, unconstrained real-world environments. Integrating a symbolic cognitive architecture with physical robotics poses severe challenges: the system must bridge the gap between low-level motor micro-controllers, high-bandwidth LIDAR and optical streams, and high-level deliberative task planning.

At the University of Michigan, Laird and his laboratory demonstrated the efficacy of Soar in autonomous ground and aerial vehicles. In these robotic deployments, the architecture is layered: low-level continuous control loops (such as PID motor controllers, simultaneous localization and mapping [SLAM] algorithms, and low-level obstacle avoidance) execute on dedicated peripheral hardware. These systems interface directly with Soar’s Spatial-Visual System, which continuously populates working memory with grounded scene graphs describing the environment. Soar assumes the role of the executive mind: it monitors mission objectives, manages situational awareness, selects operational routes, and coordinates complex behaviors.

A primary advantage of Soar in robotic navigation is its resilience during environmental failure. If a physical robot encounters an unmapped obstruction—such as a collapsed corridor or a locked security door—standard linear planners fail. In Soar, the inability of the navigation operator to progress triggers an immediate state no-change impasse. The agent automatically enters a substate, queries its episodic memory to identify when it last observed an alternative passageway, uses SVS to simulate whether its physical hull can traverse an adjacent opening, and derives a modified trajectory that cleanly bypasses the failure mode. Furthermore, through multi-agent symbolic communication protocols, teams of Soar-driven robots coordinate dynamically, sharing localized topological maps, negotiating search sectors, and synthesizing collaborative goal hierarchies in real time.

10.3 Interactive Agents, Game AI, and Virtual Humans

The pursuit of human-level artificial intelligence necessitates that computational agents interact naturally, coherently, and believably with human beings. Soar has been extensively utilized to construct advanced non-player characters (NPCs) in modern interactive video games, synthetic training simulations, and conversational virtual humans.

In interactive game environments—ranging from commercial first-person tactical engines (such as Unreal Tournament and Quake) to complex real-time strategy games—Soar-driven characters fundamentally outperform standard finite-state machines (FSMs) and behavior trees. Classical game AI is notoriously predictable and brittle, incapable of long-term strategic coherence. Soar agents within these environments maintain persistent goal hierarchies, execute anticipatory tactical planning via SVS mental imagery, and dynamically adapt to human player strategies. An adversarial Soar agent does not merely react to visual line-of-sight; it maintains an internal episodic model of the human player’s historical habits, actively infers the player’s overarching objective, and sets coordinated ambushes based on deductive tactical reasoning.

In the realm of virtual humans and natural language dialogue processing, Soar has been coupled with advanced semantic parsers to model human-like conversational pragmatics. When natural language text or speech is transcribed, the resulting syntactic parse trees are mapped directly into Soar’s problem spaces. The agent uses its internal declarative and episodic memories to execute plan recognition, intent attribution, and context-dependent disambiguation. In pedagogical and intelligent tutoring systems (ITS), Soar models not only the domain material being taught, but maintains an internal, reflective model of the student’s evolving cognitive state. By tracking the student’s errors through its own internal impasse mechanisms, the Soar tutor detects exactly which procedural chunks the human student is missing or misapplying, generating customized, pedagogically optimal instructional interventions.

11. Critical Analysis, Structural Limitations, and Unresolved Challenges

11.1 The Knowledge Engineering Bottleneck and Scalability Limits

Despite the immense expressive power and theoretical rigor of the Soar architecture, it is subject to severe pragmatic and computational constraints. Foremost among these is the notorious Knowledge Engineering Bottleneck. Constructing an advanced Soar agent for a complex, non-trivial domain is an undertaking of extraordinary difficulty, requiring specialized software engineering expertise that bridges theoretical computer science, cognitive psychology, and low-level rule programming.

Unlike modern deep learning paradigms, where an agent learns direct representations from raw data via backpropagation, classical Soar requires that human knowledge engineers meticulously formulate hundreds or thousands of production rules by hand. Authoring these rules is exceptionally fragile. Because Soar’s production memory operates via symmetric matching without explicit instruction pointers, rules interact in highly non-linear, non-deterministic ways. A single subtle error in variable binding or the accidental omission of a negative condition can cause rules to fire erroneously, asserting unintended preferences, triggering cascading impasses, and causing the entire cognitive architecture to deadlock. Debugging an agent comprising 10,000 interacting production rules matching across a dynamic, churning working memory graph requires specialized diagnostic tools and deep cognitive tracing, making large-scale deployment economically and logistically prohibitive for many commercial enterprises.

Furthermore, significant scalability barriers emerge when agents operate over long, lifelong operational horizons. While the Rete algorithm and sub-network unlinking dramatically accelerate pattern matching, the continuous accumulation of millions of learned chunks via explanation-based learning inevitably strains the Beta Network. As procedural memory expands, the structural complexity of inter-condition variable joins can cause worst-case memory inflation and subtle latency degradation during the elaboration phase, challenging Newell’s absolute guarantee of bounded 50-millisecond decision cycles in lifelong autonomous deployments.

11.2 The Symbol Grounding and Continual Sensorimotor Disconnect

While the integration of the Spatial-Visual System (SVS) represents a massive architectural leap forward, the foundational Symbol Grounding Problem remains an unresolved theoretical tension within core Soar. SVS provides continuous geometric representation, but the qualitative spatial extractors that convert continuous metric coordinates into discrete working memory elements are, in practice, hand-engineered algorithmic transductors. The architecture does not intrinsically *discover* or *ground* its own symbols; rather, human engineers write the software routines that decide an Euclidean distance below 2.0 meters shall be asserted as the discrete symbolic predicate ^near true.

This design leaves the architecture vulnerable to profound edge-case fragility when deployed in unstructured, highly continuous real-world environments characterized by extreme perceptual noise, sensory drift, and non-rigid physical dynamics. If an environmental situation arises that violates the assumptions hardcoded into the spatial transductors, the symbolic layer receives distorted or contradictory WMEs, leading to ungrounded reasoning loops. Moreover, core Soar lacks an intrinsic, low-level continuous motor coordination architecture. Soar operates natively at the level of discrete operator selection; it possesses no internal computational substrate for synthesizing smooth, continuous trajectory profiles, dynamical motor control, or non-linear force adaptations. Consequently, Soar cannot serve as a complete, self-contained model of biological sensorimotor integration without relying heavily on external, third-party robotic controllers.

11.3 Biological Realism and Cognitive Plausibility Debates

Although Allen Newell advanced Soar as a candidate Unified Theory of Cognition, cognitive neuroscientists and evolutionary biologists have repeatedly criticized the architecture for its lack of authentic biological plausibility. At the neuroanatomical level, Soar possesses virtually no direct correspondence to the structural organization of the human brain:

• Neuroanatomical Disconnect: The brain does not contain a centralized, globally matched Rete network, nor does it maintain an amodal, symbolic working memory graph composed of discrete identifier-attribute-value triples. Biological cortical networks are inherently distributed, continuous, stochastic, and parallel, whereas Soar’s classical decision cycle relies on centralized algorithmic arbitration and strictly serialized operator execution.
• The Learning Plausibility Problem: While explanation-based chunking is a mathematically brilliant formulation of deductive operationalization, it does not reflect the primary mechanisms of biological neuroplasticity. Human learning is overwhelmingly characterized by continuous Hebbian synaptic adaptation, statistical feature correlation, associative habit formation, and slow neocortical integration mediated by the hippocampus. Restricting cognitive compilation purely to deductive dependency tracing across substate proofs represents an idealization that diverges fundamentally from the biological realities of mammalian learning.
• The Absence of Affective and Somatic Appraisal: Biological cognition is deeply embodied and inextricably linked to emotional regulation, neurohormonal modulation, and somatic appraisals. In biological organisms, fear, curiosity, hunger, and fatigue act as continuous, visceral modulators that dynamically shift attentional focus, alter risk tolerance, and bias decision-making long before deliberate cognitive analysis occurs. Early and classical iterations of Soar completely omitted affective architectures, treating cognition as an emotionally sterile, purely rational computational search through problem spaces. While recent experimental extensions have explored the integration of synthetic appraisal models into Soar, these mechanisms remain peripheral augmentations rather than fundamental, intrinsic drivers of the core architecture.

12. The Future of Soar and Its Enduring Legacy in Artificial General Intelligence

12.1 Allen Newell’s Lasting Vision and Epistemological Heritage

Evaluating the ultimate success of the Soar cognitive architecture requires returning directly to the thirteen empirical criteria for human-level cognitive architectures that Allen Newell articulated in his William James Lectures. Newell mandated that a unified mind must exhibit flexible behavior, real-time operation, rich symbolic representation, vast knowledge integration, continuous learning from experience, language capability, self-awareness, and structural survivability under physical damage. In historical retrospect, Soar has achieved an astonishing proportion of these objectives: it demonstrated that a single, computationally realized symbolic architecture could indeed unify problem solving, execution, and lifelong learning without degenerating into an uncoordinated assemblage of task-specific code bases.

The epistemological legacy of Newell’s program revolutionized the methodology of artificial intelligence and cognitive science. Newell demonstrated that empirical psychological science could transcend the descriptive cataloging of isolated experimental phenomena by constructing cumulative, executable computational theories. By operationalizing the mind as a physical symbol system executing problem space search, Newell provided artificial intelligence with its most rigorous, unified foundational framework. His intellectual lineage—carried forward through the massive research programs at Carnegie Mellon University, the University of Michigan, and international research laboratories—permanently established cognitive architectures as an indispensable theoretical discipline in the quest for synthetic minds.

12.2 John Laird’s Ongoing Contributions and Future Architectural Roadmaps

Under the continuous, visionary leadership of John Laird at the University of Michigan Center for Cognitive Architecture, Soar has avoided obsolescence by perpetually absorbing modern computational breakthroughs while remaining rigorously committed to its foundational core. Laird’s contemporary research agenda targets several of the most pressing limitations that have historically bounded symbolic architectures.

Foremost among these initiatives is the development of Interactive Task Learning (ITL). ITL investigates how an autonomous Soar agent can acquire completely novel, complex tasks—including the goals, legal operators, heuristic preferences, and perceptual concepts of an unseen environment—in real time through natural language instruction and direct physical demonstration by human collaborators. Rather than requiring human engineers to manually write thousands of new production rules for every deployment, ITL agents utilize structured natural language dialogues to autonomously construct new problem spaces, dynamically generating and verifying new operators via universal subgoaling. Furthermore, Laird’s group is actively pioneering architectural frameworks for lifelong cumulative learning, engineering declarative and procedural indexing structures that prevent cognitive slowdown and eliminate the utility problem across continuous operational lifespans spanning months and years of continuous execution.

12.3 Soar’s Position in the Modern Artificial General Intelligence (AGI) Race

In the contemporary landscape of Artificial General Intelligence (AGI), dominated by the meteoric rise of generative transformer models and massive statistical scaling laws, the foundational principles of Soar are not merely relevant—they are deeply indispensable. Modern generative AI has illuminated the fundamental limitations of pure statistical pattern matching: large language models, despite their immense linguistic fluency, remain fundamentally ungrounded, incapable of reliable multi-step deductive reasoning, devoid of persistent intentionality, and acutely vulnerable to catastrophic hallucinations. They lack a world model, an active goal hierarchy, an autobiographical memory, and a mechanism for continuous, bounded self-reflection.

Soar provides the exact intellectual and architectural blueprint needed to overcome these systemic deficiencies. The future of robust, explainable, and verifiably safe AGI lies not in abandoning symbolic architectures, but in the principled synthesis of generative statistical perception with structured cognitive deliberation. In this unified frontier, deep generative networks will serve as the associative, intuitive perceptual substrate—translating the messy, continuous, probabilistic physical universe into grounded latent vectors—while a deliberative cognitive engine derived from the principles of Soar manages the goal hierarchies, enforces hard ethical and logical constraints, orchestrates multi-step causal lookahead, and executes continuous, one-shot procedural compilation.

By demonstrating how knowledge, perception, deliberation, and learning can cohere within a single, bounded, and self-reflective computational system, Allen Newell and John Laird did not merely design an artificial intelligence program. They constructed a timeless monument to the scientific understanding of the mind—a grand, unified computational architecture that continues to illuminate the path toward synthetic general intelligence.

Conclusion

The journey of the Soar cognitive architecture—from its theoretical inception in Allen Newell’s quest for Unified Theories of Cognition, through decades of rigorous systems engineering by John Laird and Paul Rosenbloom, to its modern realization as a multimodal, neuro-symbolic cognitive engine—exemplifies the enduring power of foundational ideas in computer science. By establishing that purposeful, intelligent behavior can be mathematically operationalized as search through discrete problem spaces, Soar bridged the historic chasm between human cognitive psychology and computational machine execution. Its profound architectural mechanisms—the non-sequential Rete-driven elaboration phase, declarative preference semantics, universal subgoaling upon impasse detection, explanation-based chunking, and the native integration of episodic, semantic, and spatial memory systems—stand as benchmarks of structural elegance and computational efficiency.

As the contemporary artificial intelligence community confronts the inherent boundaries of pure statistical learning, the foundational tenets of Soar offer an indispensable compass. The realization of true Artificial General Intelligence will ultimately require systems that are not merely capable of predicting the next token in a sequence, but that possess persistent identity, maintain deliberative intentionality, explain their own internal reasoning, and compile lifelong expertise through continuous, autonomous reflection. In the final analysis, Soar is more than a computational framework; it is an enduring intellectual blueprint for the architecture of reason, providing an indelible foundation upon which the autonomous minds of the future will inevitably be built.

References

• Anderson, J. R. (1993). Rules of the Mind. Lawrence Erlbaum Associates.
• Anderson, J. R., Bothell, D., Byrne, M. D., Douglass, S., Lebiere, C., & Qin, Y. (2004). An integrated theory of the mind. Psychological Review, 111(4), 1036–1060. https://doi.org/10.1037/0033-295X.111.4.1036
• Doorenbos, R. B. (1995). Production Matching for Large Learning Systems (Doctoral dissertation, Carnegie Mellon University). Computer Science Department. Paper 183.
• Forgy, C. L. (1982). Rete: A fast algorithm for the many pattern/many object pattern match problem. Artificial Intelligence, 19(1), 17–37. https://doi.org/10.1016/0004-3702(82)90020-0
• Harnad, S. (1990). The symbol grounding problem. Physica D: Nonlinear Phenomena, 42(1–3), 335–346. https://doi.org/10.1016/0167-2789(90)90087-6
• Jones, R. M., Laird, J. E., Nielsen, P. E., Coulter, K. J., Kenny, P., & Koss, F. V. (1999). Automated intelligent pilots for combat flight simulation. AI Magazine, 20(1), 27–42. https://doi.org/10.1609/aimag.v20i1.1438
• Kosslyn, S. M. (1994). Image and Brain: The Resolution of the Imagery Debate. MIT Press.
• Laird, J. E. (2012). The Soar Cognitive Architecture. MIT Press.
• Laird, J. E., Newell, A., & Rosenbloom, P. S. (1987). Soar: An architecture for general intelligence. Artificial Intelligence, 33(1), 1–64. https://doi.org/10.1016/0004-3702(87)90050-6
• Laird, J. E., & Rosenbloom, P. S. (1996). The evolution of the Soar cognitive architecture. In T. Mitchell (Ed.), Mind Matters: A Tribute to Allen Newell (pp. 1–50). Lawrence Erlbaum Associates.
• Newell, A. (1973). You can’t play 20 questions with nature and win: Projective comments on the papers of this symposium. In W. G. Chase (Ed.), Visual Information Processing (pp. 283–308). Academic Press.
• Newell, A. (1990). Unified Theories of Cognition. Harvard University Press.
• Newell, A., & Simon, H. A. (1976). Computer science as empirical inquiry: Symbols and search. Communications of the ACM, 19(3), 113–126. https://doi.org/10.1145/360018.360022
• Rosenbloom, P. S., & Newell, A. (1986). The chunking of goal hierarchies: A generalized model of practice. In R. S. Michalski, J. G. Carbonell, & T. M. Mitchell (Eds.), Machine Learning: An Artificial Intelligence Approach (Vol. 2, pp. 247–288). Morgan Kaufmann.
• Tambe, M., Newell, A., & Rosenbloom, P. S. (1990). The problem of expensive chunks and its solution by restricting expressiveness. Machine Learning, 5(3), 299–348. https://doi.org/10.1007/BF00117107
• Wintermute, S., & Laird, J. E. (2012). Bimodal spatial reasoning with a unified cognitive architecture. Artificial Intelligence, 176(1), 2262–2292. https://doi.org/10.1016/j.artint.2011.09.004