Bridging the Planning Execution Gap in Embodied AI

131 concepts129 papers2 proposals

Embodied AI agents face a fundamental tension between thinking and doing. High-level strategic planning requires abstract, long-horizon reasoning—the kind of symbolic logic handled well by Large Language Models (LLMs) or discrete task planners. Conversely, low-level execution requires continuous, high-frequency motor control to navigate the messy physics of the real world.

This tension creates what researchers call the planning-execution gap (or the discrete-continuous control gap). High-level plans are often too abstract to be physically executable, while low-level motor commands are too granular to facilitate long-term reasoning. If a robot decouples these layers entirely, it becomes brittle: the high-level planner might command actions that violate physical joint limits, while the low-level controller cannot adapt when a complex, contact-rich manipulation task deviates slightly from the script.

To build truly autonomous agents, modern research focuses on architectures that integrate these layers. The goal is to ensure that abstract strategic intent translates smoothly into precise physical action.


The Anatomy of the Gap

Why can't we simply pass the output of a high-level planner directly to a motor controller? The failure modes of a purely decoupled system reveal the depth of the gap.

As shown in open-ended benchmarks like SimWorld, requiring a reasoning model to manage granular execution details (such as individual joint movements or precise pathfinding) causes operational failure because the model loses track of the broader strategic goal. Yet, when models attempt to delegate entirely to low-level controllers, they frequently fail to bridge the transition from abstract reasoning to atomic actions. Sijie Cheng et al. demonstrate that even frontier multi-modal models struggle to decompose high-level goals into valid low-level executable function calls.

The core issue is a lack of bidirectional alignment. A high-level planner operates under the assumption that physical primitives (like grasping or moving) are executed perfectly. However, as Jie Tan et al. observe in mobile manipulation, if the high-level policy is unaware of the robot's physical reach limits or joint constraints, it cannot intelligently adjust its base position to keep targets within the reachable workspace. Without feedback from the physical layer, the planner operates in a vacuum, generating physically impossible commands.


Mechanism 1: Code and Formalisms as Intermediate Bridges

One prominent strategy for closing this gap is to shift the output of high-level planners away from natural language or abstract symbols toward executable code and structured formalisms. Code serves as a precise intermediate representation that binds semantic intent to deterministic execution.

[ High-Level Intent ] -> "Turn the steering wheel 90 degrees"
         ↓
[ Intermediate Code ] -> Task Frame Formalism / API Calls
         ↓
[ Low-Level Control ] -> Position & Force Set-Points (e.g., 5 Nm, 120 Hz)

For example, Jingkang Yang et al. introduced Octopus, an embodied vision-language model that bypasses text generation entirely to output executable code based on environmental feedback. By generating code, the model creates a direct pipeline to the simulator's APIs. Similarly, Qi Guo developed CoPiC, a framework where LLMs generate "planning programs" (Python code) combined with a reinforcement-learning-tuned selector to choose the best execution path, significantly lowering token costs while improving success rates.

For physical hardware, this code must map directly to mechanical properties. Yue Cao demonstrated that prompting LLMs using a specialized Python-like Task Frame Formalism allows models to translate abstract natural language tasks (e.g., "wipe the table") into specific position and force set-points that a robotic arm can execute. This grounds the abstract reasoning of the model directly into the physical forces required for contact-rich manipulation.


Mechanism 2: Reusable Behavioral Primitives

A second approach relies on structuring the action space into a library of discrete, predictable macro-actions, often called behavioral primitives. Instead of planning at the level of raw motor torques, the high-level planner selects from a menu of learned skills, which themselves handle the low-level continuous control.

This concept builds on foundational hierarchical paradigms. Peter Stone et al. pioneered Layered Learning, breaking down complex multi-agent behaviors into a bottom-up sequence of learned skills. In continuous robotic domains, George Konidaris et al. developed the Continuous Skill Trees (CST) algorithm, which automatically segments successful trial-and-error trajectories into portable macro-actions.

Modern iterations refine these primitives so planners can treat them like deterministic moves on a chessboard. Jan Achterhold et al. introduced SEADS (Symbolic Effect-Aware Diverse Skills), a framework that maps continuous control sequences into discrete, symbolic actions with predictable effects.

To handle scenarios where pre-defined skills fall short, Soroush Nasiriany et al. developed MAPLE. This architecture allows a reinforcement learning agent to dynamically switch between executing high-level behavior primitives (like pushing or grasping) and falling back to raw, fine-grained motor control when navigating complex, contact-rich transitions.


Mechanism 3: Closed-Loop Feedback and Multi-Scale Alignment

The most robust solutions enforce strict mathematical or geometric consistency between the planning and execution layers, creating a closed loop where low-level physical realities continuously inform high-level decisions.

Mathematical Consistency

In traditional hierarchical control, coarse plans often fail to align with fine-grained executions, leading to "hallucinated" movements where the motor commands fail to fulfill the strategic intent. To solve this, Zhixuan Lin et al. proposed MSP (Probabilistically Consistent Multi-Scale Action Generation). MSP utilizes a continuous latent space and a generative model to ensure that action sequences generated at different temporal scales remain mathematically consistent with one another.

Geometric Primitives

Another way to unify the hierarchy is to use a single geometric representation that satisfies both high-level pathfinding and low-level safety constraints. Aaron Ray et al. achieved this by representing free space as a graph of intersecting, obstacle-free ellipsoids. A high-level discrete planner uses this graph to find a global path, while a low-level Model Predictive Control (MPC) loop uses the exact same ellipsoids to calculate continuous, collision-free trajectories in real time.

Real-Time Replanning

Finally, closing the loop requires the ability to abandon a failing plan instantly based on environmental feedback. Rather than getting bogged down in incremental search trees when an execution error occurs, the Boomerang framework by Wayne Chen et al. utilizes a generative planner that replans entire action sequences from scratch the moment feedback indicates a mismatch between the expected and actual state of the world. This tight integration allows agents to recover fluidly from physical disruptions, effectively erasing the boundary between planning and execution.

History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_hierarchical_control_integration_03e9fc9c,
  title = {hierarchical control integration},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/hierarchical-control-integration/rdr_03e9fc9c59ce4af5a0f4b2571ef43ebe},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-20},
}

This exact version (version 1, frozen text):

@misc{lacuna_hierarchical_control_integration_03e9fc9c_v1,
  title = {hierarchical control integration},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/hierarchical-control-integration/rdr_03e9fc9c59ce4af5a0f4b2571ef43ebe/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-20},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake