Speed of Response:

Architectures that respond quickly are necessary for dynamic environments because the survival of the agent may depend on it reacting in a timely manner to events in the environment that happen without its control (e.g. getting out of the way of cars). This is especially important in unpredictable, dynamic environments.

To ensure a fast response speed the agent should constantly monitor its sensors to update its world-view (have an eager sensing policy). This policy affects the rest of the architecture. For example, many architectures which operate in think/execute cycles have slow response speeds because the thinking portion may not be guaranteed to finish before the world changes too much.

A problem with forcing all reactions to be quick is that the architecture may not have time to compute some long (but useful) steps, so its behavior might be to limited. This is a common argument against the very-reactive Subsumption Architecture.

A common solution to the speed/flexibility delemma is found in some modular architectures: have quick modules that may recognize and react to important environmental conditions, and have slower, more deliberative modules that are more precise, correct and/or general. Sometimes the slower modules control the reactive ones with a layered architecture (e.g. Atlantis). Another alternative is to run the modules in parallel (e.g. RALPH).


Examples of (potentially) quick-responding architectures are:

  • Atlantis by E. Gat. The low level control layer modulates sensor input to effector output in a manner inspired by Subsumption Architecture.
  • Behavior-Based Programming by R. Brooks. Similiar to Subsumption Architecture.
  • Dynamic Control Architecture by B. Hayes-Roth. A Communications Interface is placed between the environment and the agent that may do reactive tasks.
  • ERE by Drummond et al. The reactor is freed from the responsibility of generating instructions: all it has to do is follow reactive ones as quickly as possible.
  • Homer by Vere and Bickmore. The plan interpreter is freed from the responsibility of generating instructions: all it has to do is follow reactive ones as quickly as possible.
  • Icarus by Langley. Meander is freed from the responsibility of generating instructions: all it has to do is follow reactive ones as quickly as possible.
  • MAX by D. Kuokka. Monitors give this architecture the ability to run arbitrary code when a condition is detected.
  • RALPH by Ogasawara and Russell. The condition-action execution architecture may quickly and reactively map known environments to the appropriate action.
  • SOAR by A. Newell et al. Productions could be made to match environmental condtions very quickly.
  • Subsumption Architecture by R. Brooks. Subsumption's philosophy is to react quickly by avoiding the intermediate symbolic translation and manipulation done by most systems.
  • Theo by T. Mitchell et al. Theo-Agent could response quickly due to stimulus-response rules.

  • Examples of slower-responding architectures are:

  • Prodigy by Carbonell et al

  • Other Properties.

    Back to the Title Page.