Must reactive behavior be a simple reflex?

No. A responsive skill can involve substantial computation; its role and timing matter.

Must the planner use symbolic AI?

No. Different planning methods can occupy the deliberative role if their interfaces and assumptions fit.

Does hybrid architecture automatically require multiple processors?

No. Logical responsibilities and physical deployment are separate choices.

Can a plan be interrupted?

Yes, if the architecture defines how interruption affects active skills and subsequent decisions.

AI Glossary / Graphs and symbolic AI / Advanced

Hybrid architecture

Definition

A hybrid architecture is an agent design that combines different approaches to control, typically reactive behavior and deliberative planning. A common arrangement adds an executive that coordinates their work.

What it means

Reactive control responds to current conditions without waiting for a fresh long-range plan. Deliberative control reasons about possible actions and their consequences. The executive connects plans to concrete skills, tracks progress, and handles changes in execution.
This entry follows the supplied agent-control meaning. Even within robotics, hybrid systems need not share one exact hierarchy. For example, the LAAIR research architecture gives a top-level reactive controller authority to invoke planning or directly coordinate skills.

How it works

A typical system separates planning, execution coordination, and responsive skills. The planner supplies goals or proposed action sequences. The executive starts appropriate skills and interprets completion, failure, or interruption reports. Skills interact with observations and the environment at the timescale their tasks require.
Interfaces specify what a command means and how its result is reported. A useful design also specifies who may cancel an action, which component owns a resource, and when a new plan may replace an old one. Otherwise, independently sensible modules can issue conflicting commands.
Planning can run asynchronously while execution continues under defined rules. Its answer must still be checked against the current situation. A plan computed from an earlier snapshot may refer to a route that is now blocked or a task that has already completed. Coordination, rather than simply adding multiple algorithms, makes the combined architecture useful.

Three practical examples

Mobile delivery: A robot follows a route planned toward a destination while local control responds to newly observed obstacles. The executive decides whether to wait, cancel the current movement, or request a replacement route.
Interactive assistance: A service robot can pause a multi-step task when a person addresses it. A coordinating component manages the interruption and determines what must be rechecked before resuming the earlier task.
Laboratory automation: A system plans a sequence of operations while individual device controllers execute bounded actions and report status. The executive tracks which steps actually finished, preventing an outdated plan from treating an interrupted operation as complete.

Think of it this way

Think of a production team with a planner, a floor coordinator, and equipment operators. The planner considers the larger sequence; operators respond to immediate conditions; the coordinator keeps their actions aligned. The arrangement works only if everyone knows which instructions are current and how changes are communicated.

Worked example

Consider an illustrative robot with three software activities. A reactive check is scheduled every 20 milliseconds, an executive check every 100 milliseconds, and a planner update every 2,000 milliseconds. These are hypothetical schedules, not measured performance guarantees. Assume all checks occur exactly on schedule and that observations are instantly available.
A new obstacle appears at time 7 milliseconds. The next reactive check is at time 20, so it can detect the condition after 13 milliseconds. If the system instead waited for the next planner update at time 2,000, the delay would be 1,993 milliseconds.
Suppose the reactive component requests a stop at time 20 and reports the blocked route. The executive reads the report at time 100, changes the task state to blocked, and requests a new plan. These times do not establish when the robot physically stops: sensing, communication, actuator behavior, and motion dynamics would require separate analysis.
The planner proposes an alternate route at time 2,000 using a snapshot taken at time 100. Meanwhile, an operator has canceled the delivery at time 600. A task-version check lets the executive reject the obsolete route rather than restarting a canceled mission.
Without that coordination rule, the fast controller could respond correctly at time 20 while the later planning result still causes an incorrect restart. Responsiveness and consistency are separate requirements. The architecture must address both, and actual timing claims require evidence beyond the nominal update periods.

Illustrative case study

Fictional Cedar Robotics combines a route planner with responsive navigation skills. Early tests show that each module performs its own task, yet the robot sometimes resumes an old route after the operator changes its destination.
The team discovers that plans have no associated task version and cancellation acknowledgments are not tracked. It adds explicit command ownership, versioned goals, and outcome messages that distinguish success, failure, and cancellation. The executive checks these records before accepting a planning result or starting another movement skill.
The team then tests delayed messages, canceled tasks, and planning failures. The improvement comes from well-defined coordination between components, not merely from labeling the system hybrid or increasing the number of layers.

Common misconceptions and mistakes

“Hybrid means exactly three layers.” Three-layer designs are common examples, not the only possible organization.
“A fast reactive loop guarantees a safe response.” End-to-end behavior also depends on observations, execution, timing, and the operating environment.
“The planner must control every moment.” Hybrid designs can delegate immediate behavior and execution decisions.
“Adding a planner to a reactive controller is sufficient.” Their command and feedback relationships must be defined.
“A valid plan stays valid until used.” Changes in the task or environment can invalidate it.

Business use

Choose this approach when the application needs both responsive behavior and multi-step goal management. Identify which decisions need rapid handling, which benefit from planning, and which require coordination across activities.
Specify interfaces, resource ownership, interruption behavior, and recovery rules before integration. Evaluate complete scenarios as well as individual modules. Include cases where the planner is slow, a skill fails, messages arrive late, and a human changes the goal.

Check your understanding

Why does the example detect the obstacle after 13 milliseconds?

Answer: The next scheduled reactive check follows its appearance at time 7.

Why is the route returned at time 2,000 rejected?

Answer: The delivery was canceled after the planner's snapshot.

What does the example not establish?

Answer: Actual stopping time or a general safety guarantee.

Related terms

Three-layer architecture
Reactive agent
deliberative planning
executive control
skill
asynchronous execution
task monitoring
goal management

Learn next

Draw the command and feedback paths for a small agent. Add one task cancellation and one delayed planning result, then specify exactly which component decides whether execution may resume.

Sources

AIMA glossary, hybrid architecture: https://github.com/aimacode/aima-glossary/blob/master/glossary.md Jiang and colleagues, LAAIR: A Layered Architecture for Autonomous Interactive Robots: https://users.cs.utah.edu/~dsbrown/pubs/Jian_AAAIFS2018.pdf

Previous: Hybrid agent Next: Hybrid Bayesian network