TL;DR for operators
A robot’s learned model may generate an appropriate action while the surrounding system executes it too late, uses outdated context, or fails to interrupt it. One paper formally explains why model outputs and executable policies are different objects. Another demonstrates that spatial tools, concurrent execution, and motion-permission controls can materially change navigation outcomes.
For organizations developing or evaluating embodied AI, model quality, action realization, and execution authorization require separate scrutiny. The strongest physical evidence comes from controlled tests on one robot platform, not a general demonstration of safety.
The Model Was the Same. The Robot Behaved Differently.
A robot can interpret a navigation instruction and predict where to move next. Whether it completes the route also depends on when that prediction is executed, what the system has observed since it was generated, and whether movement remains permitted. These decisions occur outside the model’s immediate prediction.
In matched tests on a Unitree Go2 robot, changing execution coordination and event handling produced markedly different outcomes. A configuration that overlapped reasoning with execution and prioritized protective events achieved 83.3% route-revision success, compared with 73.3% under sequential execution with queued event handling. Its 95th-percentile physical halt latency was 180 milliseconds rather than 1,840 milliseconds. The underlying model checkpoint, sensors, routes, and relevant control settings were held fixed within the comparison.
These results come from Zhou and colleagues’ NavGPT-3: Harnessing Context in a Hierarchical Navigation Runtime.1 The endpoint comparison changes two runtime dimensions together; the study’s additional comparisons help distinguish their contributions.
The difference matters when organizations decide whether to invest in another model, improve the interfaces around an existing one, or approve a robot for a particular operating environment. A model benchmark cannot, by itself, establish whether the deployed system handles interrupted commands, unexpected obstacles, or stale instructions correctly.
What Turns a Prediction Into an Action?
Hong and Ren’s Unifying Embodied Foundation Models via a Model-to-Policy Formulation2 provides a mathematical account of the missing boundary.
An embodied foundation model need not output a command that a robot can execute directly. Depending on its architecture, it might generate discrete action tokens, a sequence of future actions, a compressed action representation, or predicted video frames associated with movements.
Those outputs must pass through procedures that determine what the robot actually does.
Hong and Ren distinguish two components:
- Model-output distribution: Given the task and interaction history, what intermediate outputs might the model generate?
- Action-realization mechanism: Given those outputs and the available context, which executable action is selected, decoded, or scheduled?
The second component is represented by an action-realization stochastic kernel: a probabilistic description of how generated content becomes robot commands.
Their central formulation is:
Here, $f_\theta$ describes possible model outputs, $q_\theta$ describes how each output is realized as an action, and $\pi_\theta$ is the resulting robot policy. The expression gives the probability of executing an action in set $B$, conditional on the interaction history and task.
The operational insight is that an executable policy depends on both generation and realization.
The authors demonstrate this distinction through two previously published systems.
OpenVLA predicts seven discrete action tokens, then greedily decodes and converts them into a seven-dimensional continuous command. DreamZero instead generates joint video-action representations and selects executable actions from asynchronously generated chunks.
Both fit the same mathematical description despite using different training losses, output formats, and execution procedures.
This is a formal result, not a performance experiment. Hong and Ren introduce neither a newly trained robot model nor independent evidence that their formulation improves task success, generalization, or physical reliability.
Its value is analytical: it identifies what a model-only evaluation leaves unspecified.
The Runtime Determines Which Actions Can Happen
NavGPT-3 makes several of those unspecified mechanisms explicit in a working navigation system.
Its architecture separates a reasoning Planner from a vision-language-action model (VLA), which uses visual observations and task instructions to predict movement trajectories.
The Planner interprets navigation goals, examines spatial evidence, revises routes, and decides when the task has finished. The VLA generates more frequent movement predictions.
Between them sits a navigation harness that constructs context, provides tools, maintains recorded route information, and returns execution results. Above the execution interface, an OS-like runtime coordinates independently progressing planning, execution, and monitoring activities.
This arrangement addresses three dependencies.
First, spatial context must survive individual model calls. The Planner needs access to previously observed locations, recorded waypoints, and the actual outcome of movement commands. NavGPT-3 provides observed-map and backtracking tools without assuming unobserved areas are known.
Second, reasoning and movement operate at different speeds. Waiting for a language-model decision before every movement limits action frequency. Letting the VLA continue while reasoning proceeds creates opportunities for faster execution, but also introduces the possibility that commands were generated using outdated state.
Third, concurrent computation requires explicit movement authority. NavGPT-3 allows multiple activities to progress but permits only one authorized physical operation to command task movement at a time.
The runtime associates commands with permission versions. When authority is revoked or transferred, older commands cannot automatically regain permission merely because their model inference has finished.
Protective events can also interrupt movement without waiting for the Planner. A separate command filter considers fresh physical observations and can issue a protective stop.
These mechanisms distinguish a model’s proposed movement from the runtime’s decision to allow that movement. They do not independently guarantee that sensors will detect every hazard or that the robot can physically stop in time.
Better Context Can Matter More Than Faster Delegation
NavGPT-3 tests whether the surrounding system changes navigation performance, rather than relying exclusively on architectural arguments.
Its principal harness ablations use a fixed 100-episode subset of R2R-CE, a continuous-environment vision-and-language navigation benchmark. The results distinguish spatial tools, learned execution, and Planner oversight.
| System choice | Reported result | Interpretation boundary |
|---|---|---|
| Add Map and Backtrack tools | GPT-6 Astra success increases from 72% to 83%; average token use falls from 325.0k to 190.8k per episode | Matched harness configurations on 100 episodes |
| Add VLA delegation while retaining Map and Backtrack | Astra success changes from 83% to 82%; Opus 5 changes from 73% to 79% | Effects depend on the Planner and its surrounding interface |
| Check VLA execution every 16 steps rather than never checking periodically | Success increases from 77% to 83%; tokens rise from 179.2k to 2,319.5k per episode | Fixed Astra configuration on the same subset |
The first comparison shows that persistent spatial evidence and recovery tools can improve navigation without changing the learned navigation model.
The second demonstrates a more conditional relationship. The VLA provides frequent action updates—approximately 0.78 seconds per executed step in the reported ablations, versus roughly 3–19 seconds between Planner decisions without delegation. Yet faster action generation does not consistently raise navigation success.
The third identifies an economic trade-off. Frequent Planner intervention can improve route completion, but checking every 16 steps consumes nearly thirteen times as many reasoning tokens as no periodic checks in this experiment.
This makes oversight frequency a resource-allocation decision, not merely a question of maximizing intervention.
The full navigation benchmarks provide broader evidence that the integrated system can outperform its standalone VLA. On R2R-CE Val-Unseen, the complete Astra-based system achieves 81.51% success versus 76.94% for the standalone 8B VLA. On RxR-CE, the corresponding results are 90.43% and 82.39%.
The advantage is not uniform across metrics. R2R-CE success weighted by path length is 70.42 for the complete system and 70.61 for the standalone VLA.
Nor does the full-system comparison isolate one component’s contribution. The complete system adds reasoning, tools, context management, and execution coordination.
Interruption Is a Separate Performance Dimension
The Unitree Go2 experiments offer a more direct test of runtime behavior.
The researchers compare sequential versus overlapping execution and queued versus priority event handling. Each condition uses 30 trials per scenario, with matched routes and event timings.
The comparisons separate two effects.
Allowing reasoning and execution to overlap reduces mean authorized route-repair time. Under queued monitoring, repair time falls from 12.8 to 9.6 seconds. Under priority monitoring, it falls from 11.5 to 7.9 seconds.
Prioritizing protective events has a different effect. With overlapping execution, switching from queued to priority handling reduces 95th-percentile physical halt latency from 1,310 to 180 milliseconds, while missed protective stops decline from five of 30 trials to zero of 30.
These measurements are not interchangeable with the VLA’s 0.78-second inference interval. One concerns the frequency of predicted movement updates; the other measures how quickly physical movement halts after a protective event.
The strongest tested runtime also records one accepted stale-command trial among 30 recovery trials. That residual failure is consequential: versioned permissions and priority stopping improved measured behavior, but did not eliminate every observed execution problem.
The evidence is therefore specific to the tested Go2 configurations, sensing arrangement, routes, and scenarios. It does not establish reliable stopping under every obstacle, sensor failure, communication delay, or physical operating condition.
What an Embodied AI Evaluation Should Inspect
The combined research suggests an evaluation framework for robotics developers, technical buyers, and organizations responsible for deployment approval.
First, establish what the model generates. Record its inputs, output representation, training conditions, and standalone performance. A token-generating model and a chunk-generating model may have similar task-level interfaces while requiring substantially different execution procedures.
Second, establish how predictions become actions. Examine decoding, action selection, scheduling, observation updates, and recovery behavior. Test the complete system on matched tasks and report both completion and path-efficiency metrics. NavGPT-3 shows why improvements in one metric should not be assumed to extend to others.
Third, establish who may authorize movement and under what conditions. Evaluate interruption priority, permission revocation, stale-command rejection, physical halt latency, and resumption after interruption. These measurements should come from the intended robot and operating environment, not be inferred from model inference speed.
This three-part framework is a Cognaptus interpretation of the papers, rather than a validated certification protocol.
For a warehouse-navigation developer, for example, the resulting engineering decision is whether a candidate system can execute, interrupt, and resume route-following tasks within the warehouse’s defined conditions. Model accuracy informs that decision, but runtime-event records and robot-specific physical tests are also required. Performance observed on simulated navigation benchmarks or a different robot platform cannot establish the necessary operating limits.
The same distinction matters for procurement. A vendor’s standalone model success rate cannot substitute for evidence about the deployed controller, its action permissions, and its failure recovery.
The Boundary That Still Needs Testing
Hong and Ren establish a general mathematical relationship between generated outputs and executable policies. NavGPT-3 demonstrates that particular context-management and runtime mechanisms can change navigation outcomes under measured conditions.
These contributions are complementary, but NavGPT-3 does not experimentally validate the general stochastic-kernel framework. The formalism explains how action realization enters a policy; the system experiments measure what happens when particular interfaces and execution rules are changed.
Neither paper establishes general robotic safety. The first supplies no original physical experiments. The second provides controlled physical evidence from one platform and a limited set of scenarios, alongside broader simulated navigation benchmarks.
The resulting lesson for embodied AI development is precise: a capable model is one component of a deployed robot policy, not sufficient evidence of the behavior that will be executed.
Organizations can evaluate that distinction by tracing predictions into commands, commands into authorized movement, and interruptions into measured physical responses. The final judgment remains specific to the robot, task, and conditions in which it must operate.
References
Cognaptus: Automate the Present, Incubate the Future.
-
Gengze Zhou and Yicong Hong and Jiazhao Zhang and Xunyi Zhao and Jian Zhou and Zixing Lei and Zun Wang and Chongyang Zhao and Xionghui Chen and Stephen Gould and Anton van den Hengel and Qi Wu (2026). NavGPT-3: Harnessing Context in a Hierarchical Navigation Runtime. arXiv:2610.10787. https://arxiv.org/abs/2610.10787 ↩︎
-
Xinyi Hong and Mingyang Ren (2026). Unifying Embodied Foundation Models via a Model-to-Policy Formulation. arXiv:2610.23053. https://arxiv.org/abs/2610.23053 ↩︎