AI Glossary / Deep learning / Advanced

Three-layer architecture

Definition

In robotics, a three-layer architecture organizes control into reactive control, sequencing and deliberation. The controller handles immediate feedback, the sequencer manages ongoing activities and their outcomes, and the deliberator performs longer-running reasoning such as planning. This is a hybrid robot-control architecture, not a neural network with three layers or a website divided into presentation, application and database tiers.

What it means

A robot must respond to what is happening while pursuing a larger task. It cannot assume that every planned action succeeds, nor should an expensive planning computation prevent timely control.
The architecture separates these responsibilities. Fast feedback keeps an active behavior responsive; sequencing decides which behavior should run next; deliberation considers alternatives requiring more computation. Different implementations use different names and interfaces, so the responsibilities matter more than the labels.
The supplied glossary category is Deep learning, but this concept belongs more broadly to robotics and intelligent-system architecture. Neural components may participate in an implementation without defining the architecture itself.

How it works

The controller couples sensor information to actuator commands through behaviors such as following a wall or approaching a target. The sequencer activates behaviors, supplies parameters and responds to completion or failure. The deliberator computes plans or answers reasoning requests.
These activities need not form a blocking pipeline. Control can continue while deliberation runs. In Gat's account, ATLANTIS emphasizes the sequencer requesting deliberative results, whereas 3T can supply plans for execution. The architecture therefore does not require one universal direction of command.
Interfaces must identify what a result means and when it remains applicable. A route computed for an earlier situation may need checking before execution. Separating components does not automatically resolve stale information, missed deadlines or conflicting commands.

Three practical examples

• A demonstration robot follows a corridor through feedback control. Its sequencer recognizes arrival at a doorway and starts a crossing behavior, while deliberation selects the sequence of rooms to visit.
• A tabletop robot attempts to move a block. The sequencer handles a failed pickup rather than blindly proceeding as though the block were held. A planner can reconsider the remaining task after the failure.
• A simulated inspection rover compares alternative routes while its active behavior maintains a designated waiting position. The simulation tests whether planning delays interfere with the ongoing controller.

Think of it this way

Imagine a production crew with three responsibilities: carrying out the current movement, coordinating the next activity and working out the broader schedule. The coordinator must notice when an activity fails; simply reading the schedule aloud is insufficient.
This analogy explains the division of work, not a requirement for three people or three computers. The software can share hardware, provided its execution and communication arrangements preserve the intended behavior.

Worked example

Consider an original timing exercise for a simulated robot. Its controller is scheduled every 20 milliseconds, its sequencer checks task events every 100 milliseconds, and a route computation takes 600 milliseconds.
The controller frequency is 1/0.020 = 50 updates per second. During the 600-millisecond planning interval, an ideal schedule contains 600/20 = 30 controller periods and 600/100 = six sequencer periods. This illustrates why a long planning operation should not block shorter-period responsibilities.
If the system instead suspends control until planning finishes, it creates a 600-millisecond gap, equivalent to 30 nominal controller periods. These figures describe a hypothetical schedule, not measured guarantees: actual execution also depends on computation time, scheduling delays and communication.
Now suppose the sequencer receives a completed route after the destination has changed. Having the route available does not make it appropriate. A request identifier or equivalent context check can establish whether the result still answers the active request. Timing and relevance are separate checks; passing one does not imply passing the other.

Illustrative case study

Fictional Alder Robotics builds a classroom delivery robot in simulation. Its first version calls a route planner directly from the activity-management loop. When the simulated corridor becomes crowded, planning takes longer and the robot's task responses become erratic.
The team separates the route calculation from the controller and sequencer. It records controller timing, behavior transitions and the request associated with each planning result. A second test reveals that an old route can arrive after the requested destination changes.
The developers reject that outdated result and request a new one. They also test a failed doorway-crossing behavior to ensure the sequencer does not declare arrival without confirmation. The lesson is that dividing responsibilities helps expose specific problems, but successful integration still requires explicit timing, outcome and communication rules.

Common misconceptions and mistakes

Three layers do not necessarily mean three processors. Logical organization and hardware deployment are separate decisions.
The middle layer is not merely a list of commands. It must account for actual outcomes and changing circumstances.
A fast controller is not automatically a reliable controller. Incorrect sensing, unsuitable behavior logic or delayed messages can still produce failure.
Planning is not inherently superior to reaction, and reaction is not a substitute for every form of planning. Their usefulness depends on the task and timescale. The architecture coordinates these capabilities rather than ranking them by intelligence.

Business use

For a robotics project, use the architecture to make responsibilities reviewable. Identify who owns immediate control, task execution and longer-running reasoning, then specify the information exchanged between them.
A useful acceptance exercise introduces a delayed plan, a failed action and a changed goal. Observe whether the system detects each condition and responds as intended. A diagram with three boxes is weak evidence compared with these recorded behaviors.
Maintenance also benefits from clear boundaries: changing the route planner should not silently alter the meaning of a controller completion message. Document those contracts alongside performance measurements.

People also ask

Is this the same as sense - plan - act?

No. A simple sequential sense - plan - act pipeline differs from coordinating reactive control, execution management and deliberation concurrently.

Does it require machine learning?

No. The architectural division does not require learned components.

Are all three-layer implementations identical?

No. Names, interfaces and the allocation of specific computations can differ.

Check your understanding

Which responsibility handles a failed pickup?

Answer: The sequencer manages the outcome and chooses the next activity.

How many 20-millisecond periods fit into 600 milliseconds?

Answer: Thirty.

Why check a returned plan's context?

Answer: It may answer an earlier request that is no longer applicable.

Related terms

• Reactive control
• Hybrid architecture
• Feedback loop
• deliberative planning
• sequencer
• ATLANTIS
• 3T
• robot control

Learn next

Sketch one task with successful and failed action outcomes. Assign each decision to a responsibility, then trace what happens if deliberation is delayed or its result arrives after the task changes.

More in Deep learning

• Tanh - Tanh, short for hyperbolic tangent, is a mathematical function commonly used as a neural-network activation.
• Tensor product network - A tensor product network is a connectionist model that uses tensor products to represent bindings between roles and their fillers.
• Text-to-image personalization - Text-to-image personalization adapts image generation to a particular subject or concept, such as a specific toy, product or visual style.
• Threshold Autoregressive - A threshold autoregressive, or TAR, model is a time-series model whose autoregressive rule changes according to a threshold variable.
• Time-aware long short-term memory - Time-aware long short-term memory is an LSTM-based approach that explicitly uses elapsed time between observations when updating its memory.
• Topological deep learning - Topological deep learning develops neural models that use structured relationships described by topological or higher-order mathematical objects.

Sources

Erann Gat, On Three-Layer Architectures, original account of control, sequencing and deliberation. https://flownet.com/ron/papers/tla.pdf David S. Touretzky and Ethan Tira-Thompson, Architectures for Robot Control, Carnegie Mellon cognitive robotics teaching material. https://www.cs.cmu.edu/afs/cs/academic/class/15494-s11/lectures/architectures.pdf The timing exercise and fictional integration case are original teaching illustrations.

Previous: Three-factor learning Next: Three-schema approach