Building Minds from Unified Theories: Nate Derbinsky on Cognitive Architectures, Soar, and the Case for Forgetting

Nate Derbinsky, a professor at Northeastern University who works on computational agents with human-level intelligence, opens his lecture for MIT's AGI course by placing cognitive architecture inside the larger AGI picture. It is a research field that crosses neuroscience, psychology, cognitive science and AI. He promises a historical overview, a tour of existing systems, and a deeper look at one of them, Soar, told as a story of how a research question became a working capability.

His working definition of AGI stresses systems that persist for a long time, stay robust across conditions, keep learning, and work on tasks they were never told about in advance. He admits his motivation came from watching too much television, and contrasts the AI characters of his youth with a smart speaker that answers "sorry, I don't know that one". What he wants it to say instead is whether you have time to teach it, and a system called Rosie, shown later, moves in that direction.

People in the field fall into three camps: the curious, the cognitive modelers, and the systems builders. Modelers try to understand and predict how humans think, such as which errors a person will make or how long a task takes, which matters for medicine, interface design, simulation and defense. Derbinsky counts himself among the builders, who want systems for tasks that current machine learning cannot handle.

He frames the choices with the classic quadrants of AI. You can aim to act humanly, as in the Turing test, think humanly, which is the cognitive modeler's goal, think rationally as a logician would, or act rationally against an optimal bound. Whichever you choose, the common outcome is a pile of individual results that are hard to combine into a single system.

Derbinsky illustrates the problem with three well-established findings. Fitts's law predicts how hard it is to point at a target from distance and target size, the power law of practice says reaction time falls predictably as you repeat a task, and temporal-difference learning, with evidence from the brain's dopamine system, updates expectations of future reward. Each holds across many people and tasks, yet there is no clear way to smash them together and answer how humans play chess or how long it takes them.

Allen Newell, one of the founders of AI, made this argument to psychologists in his 1987 Harvard lectures, later published as *Unified Theories of Cognition*. His proposal was to commit to fixed mechanisms and processes, namely representations, learning mechanisms and memory systems, and to implement them once and use them across tasks. The interconnections would add constraints that gradually narrow what is necessary and possible in an intelligent system.

That raises a question of scientific method: when your theory is a piece of software with many configurations, how do you know you are making progress? Derbinsky points to Lakatos's picture of science, with a core of beliefs surrounded by ephemeral hypotheses. An assumption that survives long enough joins the core, so the core grows with every task and the constraints accumulate.

One core assumption comes from Newell's time scales of human action. Regularities are expected at each scale: neurons at the bottom, deliberate acts and tasks around the seconds-to-hours range, and interactions between agents above that. Most cognitive architectures sit at the deliberate-act level, taking knowledge of a situation, making one decision, and chaining decisions into tasks, though Derbinsky notes some systems operate a level below.

A second assumption is Herb Simon's bounded rationality, for which he won the Nobel Prize in Economics. Humans are constrained by problem complexity, memory, speed and available time, so decision-makers "satisfice", either solving a simplified world optimally or finding satisfactory answers in the realistic one. Neither approach dominates, and architectures reflect this by optimizing sub-problems while accepting good-enough answers for general ones.

The third is the physical symbol system hypothesis, which Derbinsky reads at different strengths. The weak form says only that intelligence need not depend on carbon neurons and could run on silicon. The older strong form held that logic and symbol manipulation alone were enough, whereas most researchers now agree that logic is necessary but that perception and statistical methods also need non-symbolic representations.

Derbinsky sorts architectures by research focus. At the lowest level, biological models such as Spaun reproduce neuron parameters, firing rates and connectivity, and he recommends the Spaun group's book *How to Build a Brain* and its toolkit. One level up, psychological models like ACT-R try to stay true to brain areas and predict errors and timing. At the top are functional architectures that mainly want to solve interesting problems, including Soar and the newer Sigma.

He then describes the prototypical architecture: perception feeds a short-term memory, procedural knowledge says what to do and when, a selection mechanism picks an action, and declarative memory holds facts and episodic experience. A repeating cycle of perception, knowledge, action selection and execution keeps the agent reactive, as when a lion appears and calculus homework should wait, while chains of cycles produce complex long-term behavior. An agent is the fixed architecture plus task-specific or general knowledge such as Wikipedia facts.

ACT-R, developed by John Anderson at Carnegie Mellon, encodes procedures as if-then production rules and predicts timing, errors, learning probabilities and even which brain regions will light up in MRI scans. Derbinsky notes more than 1,100 papers, eye-movement prediction, and Bonnie John's work predicting how users interact with software interfaces, which IBM wanted so designers could test an interface and receive time predictions. Sigma, from Paul Rosenbloom, re-implements Soar's core functionality with factor graphs and message passing, which makes it easy to integrate modern machine-learning components.

Soar began with Allen Newell; John Laird, Derbinsky's advisor, wrote his thesis on its chunking mechanism, which learns new rules from sub-goal reasoning, and still works on it. What sets Soar apart, Derbinsky says, is efficiency: its developers want it to run on almost anything, down to real-time processors. The guiding number is 50 milliseconds, the point at which humans notice a delay and a robot might fall off a curb, though most agents finish well under one millisecond.

The system has a public distribution across operating systems with bindings generated through SWIG, a pure-Java port, and an annual free workshop in Ann Arbor. Past applications include R1-Soar for configuring computers, natural language processing, the virtual humans project, HCI tasks, TacAir-Soar with tens of thousands of rules in a large defense simulation, and mobile robots. Derbinsky also built a free iOS game called Michigan Liar's Dice, where Soar plays against you and often beats him.

Two applications show the range. In a Georgia Tech interactive installation, a virtual dancer learns from a human partner's movements and uses a movement-analysis theory to mimic, transform or recall movements, as part of research on co-creative AI. The Rosie project at Michigan, using a Kinect camera and a 3D-printed arm, learns tasks through restricted English and pointing, asking what "blue" or "move" mean, then reuses the learned procedure for new colors and locations.

Derbinsky describes how his group works: improve the architecture, build agents that stress it, find what is missing, and repeat, always requiring that new mechanisms be task-independent, efficient and useful to many agents. In Soar, working memory is a directed graph, with perception and action as subsets of it. Production rules fire in parallel, a simple decision procedure picks one operator, and semantic and episodic memory store facts and every experience the agent has had.

The story starts with a task-independent question: when a cue matches many memories, which should be returned? John Anderson's rational analysis of memory showed that in human language, recently and frequently used words are more likely to be needed again, modeled as a sum of exponentially decaying usages. Tested on word-sense disambiguation corpora, simply using past answers with this recency and frequency signal performed well, which suggested it was a sensible general mechanism.

Naively, the calculation updates every memory at every time step, which does not scale. Derbinsky's group used an approximation for old accesses and recomputed only when a new value arrived. Query times stayed well under 50 ms, accuracy was nearly unchanged and sometimes slightly better, and at least 90 percent of individual decisions matched the full calculation.

Two seemingly unrelated problems then appeared. A mobile robot roaming the third floor of Michigan's computer science building kept building a bigger map in short-term memory, which made it slower, and a reinforcement-learning agent for Liar's Dice had a value function too large to store. The hypothesis was that forgetting memories with low base-level activation, ones not recently or frequently used and that could probably be reconstructed, would help.

For the robot, doing no forgetting pushed cycle times past the 50 ms threshold within about an hour. Hand-written, task-specific cleanup rules fixed that but are hard to get right, and the general forgetting mechanism at a suitable decay level actually beat them. An efficient implementation that predicts when a memory will cross the threshold was 15 to 20 times faster than an exact search.

In Liar's Dice, 40,000 games without forgetting needed about 2 GB, too much for an iPhone, and earlier forgetting work cut that to 400 or 500 MB but played worse. Derbinsky's variant forgot only estimates that could probably be recomputed, used less memory, and still played at the level of the agent that forgot nothing. The lesson he draws is that a human-inspired idea became a reusable architecture feature across unrelated tasks.

Derbinsky lists the field's open issues: integrating work across architectures and over time, transfer learning, multimodal memory and processing that includes vision and hearing, and metacognition, where an agent assesses its own state. He also raises what happens if human-level AI succeeds, recommending the BBC show *Humans*, about servant robots called synths.

On deep learning, he says comparing the two is rarely fruitful because they address different problems. To find objects in a scene he would reach for TensorFlow, not Soar, but where you know exactly how a system should behave in different situations, a rule-based system is the right tool. The two combine well, as in Rosie's vision subsystem using learned perception and the dice game using TD learning, so why avoid either.

For further study he recommends Newell's *Unified Theories of Cognition*, his own co-authored MIT Press book *The Soar Cognitive Architecture*, whose proceeds he donated to Michigan, and *How to Build a Brain*. He also points to the ACT-R book on how the mind can occur in the physical universe, a 2008 survey of architectures, an issue of AI Magazine on cognitive systems, and venues such as ICCM, Advances in Cognitive Systems, AGI and BICA.

Asked about heuristics, Derbinsky names an architectural one: process only changes. That is why Soar can be loaded with billions of rules and still respond in under a millisecond. Task heuristics are specific to each agent, and in Liar's Dice the difficulty setting selects which heuristics are active, from "lots of sixes means likely many sixes" to probabilistic reasoning and models of opponents' history.

On how Soar generates new rules, he explains chunking: if solving a problem required a sub-goal and extra work, the system memorizes the result, encoding the original situation as conditions and the outcome as the action. Asked about plugging in deep learning, he says an API lets any tool talk to Soar, and the architecture could treat function approximation as a module. What makes deeper integration hard is symbol grounding, going from pixels to stable discrete symbols, where Spaun's distributed representations and word2vec-style vectors are promising bridges.

Asked how forgetting can be safe, Derbinsky explains that the robot's full map lives in semantic memory while only short-term memory is pruned and rebuilt as needed, so the connectivity survived. In the dice agent, the initial value estimates came from simple counting heuristics and could be recomputed, and under 1 percent of estimates were ever updated. He adds that the closest work on learned forgetting is a decade-old metacognition project in which Soar learned to override harmful knowledge rather than erase it.

On whether forgetting matters for AGI, he says a system that interacts with people at least has to model that humans forget. On action selection, the decision procedure is deliberately simple, using a fixed language of preferences, and the hard planning is pushed up into agent knowledge, with guarantees only in special cases such as an A* search over a finite space. This follows from bounded rationality, since the architecture solves sub-problems optimally and otherwise tries its best.

On the strengths of the approach, he cites persistence in keeping the general human-level goal alive, whereas weaknesses are that real-world home runs, like Bonnie John's interface-prediction work, are rare and that the research tends to end up on small problems like blocks world. Unlike deep learning, which can scale by adding data and compute, Soar needs a lot of software engineering to integrate new capabilities, which is why more flexible systems like Sigma are attractive. He closes by saying Soar offers no special mechanisms for multi-agent fusion: agents can talk through ordinary protocols, but nothing in the architecture helps them reconcile knowledge.