Becoming Increasingly Reactive

Tom M. MitchellAAAI 1990

Abstract: This paper explores the fundamental tension in robotics between slow, deliberate planning and fast, reflexive action. It introduces the Theo-Agent, an architecture designed to bridge this gap. By utilizing Explanation-Based Learning (EBL), the agent "compiles" its slow reasoning processes into fast reactive rules, allowing it to transition from multi-second planning delays to sub-second reaction times as it gains experience.

Introduction

In the late 1980s, the robotics community faced a dichotomy. Search-based planners offered flexibility for novel goals but were computationally expensive and slow. Conversely, reactive architectures (such as Rodney Brooks’ Subsumption Architecture) provided robust, high-speed performance but lacked the intelligence to handle complex, multi-step goals without explicit pre-programming.

Tom Mitchell proposed a system that "reacts when it can, plans when it must, and learns whenever it is forced to plan." The goal was to create a robot with the broad competence of a planner and the lightning-fast reflexes of a reactive system.

The Theo-Agent Architecture

The Theo-Agent uses a frame-based architecture to manage beliefs and actions through a hybrid control loop. When presented with a situation, the agent first scans its library of stimulus-response rules. If a rule matches current sensor data, the action is executed immediately. If no rule applies, the system falls back to a search-based planner.

The Theo-Agent architecture illustrating the dual paths from sensors to effectors: a slow planning route and a fast reactive shortcut.

Learning as Compilation

The "secret sauce" of this architecture is Explanation-Based Learning (EBL). When the planner successfully identifies a path to a goal, the agent uses Explanation-Based Generalization (EBG) to analyze why that specific action was correct. It then generates a new reactive rule mapping the specific sensor conditions directly to that action. This effectively treats learning as a demand-driven compiler that turns high-level goals into low-level reflexes.

To optimize performance, the agent also employs:

  • Caching and Dependency Maintenance: Beliefs are cached and maintained via a truth maintenance system, only being deleted when underlying sensor data changes.
  • Eager vs. Lazy Sensing: Sensors are categorized into "eager" (updated every cycle, like sonar) and "lazy" (checked only when required by specific reasoning), avoiding unnecessary computational overhead.

Experimental Evaluation

The architecture was evaluated using a Hero 2000 mobile robot in a laboratory environment. The robot's task was to search the lab to locate and identify garbage cans using ultrasonic sonar and battery voltage sensors. Actions included basic movements like Forward.10 and Measure.The.Object.

Key Results

The results demonstrated a massive leap in efficiency as the robot "became reactive." On the first encounter with a task, the decision-making process required over 34 seconds. However, once a stimulus-response rule was learned, decision time plummeted to a fraction of a second.

Performance metrics showing the dramatic reduction in decision and reaction times after learning reactive rules.

As shown in the data, the decision time for applying learned rules was approximately 0.2 seconds, compared to the initial 34.3 seconds for planning. The authors noted that matching a learned rule takes roughly 10 milliseconds, suggesting the architecture could scale to dozens of rules before the reactive path would see significant slowdown.

Discussion and Limitations

While the Theo-Agent successfully demonstrates the transition from planning to reacting, several limitations remain:

  • Model Dependency: Learned rules are only as accurate as the underlying planner. Incorrect internal models lead to "fast but wrong" reflexes.
  • Sensing Costs: The planner does not currently account for the "cost" of a sensor reading; it might learn a rule requiring an expensive sonar sweep when a simpler check would suffice.
  • Rule Explosion: Scaling to thousands of rules would require advanced indexing (like Rete matching) to maintain sub-second response times.
  • Static Knowledge: The agent becomes faster but not necessarily "smarter"; it optimizes the execution of existing knowledge rather than discovering entirely new interaction paradigms.

Summary updated

BibTeX
@inproceedings{mitchell1990becoming,
  author = {Tom M. Mitchell},
  title = {{Becoming Increasingly Reactive}},
  booktitle = {AAAI Conference on Artificial Intelligence},
  year = {1990},
}
Figure