Should Robots Learn More,
or Think More?

1. How Does CorrectNav Know That It Is Wrong?

First, let us operationally define online self-awareness as follows.

The ability of the robot to estimate the possibility that the current policy is failing using its own observation and action history during execution, and to actively select one of the following modes: stop, re-observe, re-plan, retreat, question, and recover.

This definition requires at least three elements:

1. Online failure or uncertainty estimation
2. Runtime policy conversion according to estimation results
3. Choose a recovery strategy appropriate for the cause of the error and the situation

The procedure CorrectNav performs is different.

CorrectNav first reruns the current model for the instruction-oracle trajectory pair of the training data to collect failure trajectories. Afterwards, the distance between the model trajectory and the oracle trajectory is calculated, and the point when this distance first exceeds the preset threshold is determined as the deviation point. Then, the external trajectory planner creates a recovery trajectory starting from the departure point and returning to the destination through oracle reference points. [1]

CorrectNav is fine-tuned again using visual descriptions of externally discovered failure points, recovery trajectories, and surrounding keyframes as supervision. The paper also presents the advantage of internalizing recovery behavior into model parameters without an additional runtime correction module or long chain-of-thought.[1]

Therefore, CorrectNav's self-correction refers to implicit recovery behavior that appears in the final action, rather than mechanism-level self-recognition.

Rather than being a system that explicitly diagnoses the fact that it has failed during execution, CorrectNav is a system that has been trained to reproduce appropriate recovery behavior in situations similar to the failure conditions discovered in the previous learning process.

This is not an assessment that lowers the value of CorrectNav. Converting failure trajectories into high-quality correction data without discarding them is a practical and important contribution. However, failure recovery and failure awareness must be clearly distinguished. What CorrectNav directly enhances is closer to the former.

• Failure recovery: Ability to perform recovery actions in failure situations.
• Failure awareness: The ability to determine that you are currently failing.

2. Returning to the Original Route Is Not the Same as Finding a New One

CorrectNav’s recovery trajectory starts from the deviation point. It is created to re-pass subsequent reference points of the existing oracle trajectory.[1]

Therefore, what the paper directly proves is generally the following abilities.

• Ability to modify behavior from failure patterns discovered during learning
• Ability to re-enter the existing correct path from a stray location
• Ability to use failure trajectories as additional supervision
• Ability to retract previous decisions when familiar visual cues reappear

On the other hand, it is difficult to say that the following abilities have been sufficiently proven.

• Ability to discover new detours when the existing correct path is physically blocked
• Ability to create alternative paths when the connectivity or topology of the environment changes.
• Ability to withhold judgment when goals are ambiguous or observations are insufficient.
• Ability to diagnose the cause of a failure mode that has never been learned
• Ability to generate multiple alternative plans and compare risks and costs.

CorrectNav's qualitative example shows behavior such as entering through the wrong door, then coming back out and entering through the side door when the stairs cannot be found. However, it is difficult to tell from this alone whether the model formed an explicit belief that “the current path is wrong” or changed direction based on learned observation-behavior patterns.[1]

In the actual robot experiment, the robot transmitted RGB images to a remote NVIDIA A100 server, and the server's CorrectNav operated in a way that returned an action chunk consisting of four actions. [1] In other words, the system demonstrated the real-world recoverability of a learning-based navigation policy using remote inference, rather than complete onboard failure-aware autonomy.

The task-specific calculation amount directly disclosed by the CorrectNav paper is navigation fine-tuning performed on eight NVIDIA A100s for approximately 80 hours. [1] However, this figure is not the pretraining compute of the base model. CorrectNav does not pre-train a multimodal-based model from scratch, but is initialized in LLaVA-Video-7B, and this model also inherits the learning results accumulated by the SigLIP vision encoder, Qwen2-7B, and single-image checkpoint of LLaVA-OneVision. The LLaVA-Video paper reveals that 128 NVIDIA H100s were used for video instruction tuning, but did not disclose the training time and total FLOPs. Therefore, the entire upstream pre-training compute inherited by CorrectNav cannot be converted into one exact number.[21]

Nevertheless, this scale is still limited compared to the computational expansion that frontier LLM has undergone. AlexNet was trained on two GTX 580s in 5–6 days in 2012, but[22] OpenAI's analysis shows that the computational volume of the largest AI training run had already increased by more than 300,000 times since AlexNet by 2017.[23] 175B The training volume of GPT-3 was reported to be 3,640 petaFLOP/s-days.[24]

Therefore, the claim that CorrectNav improves “the ability to return to the original path after a wrong turn” is valid. However, the claims of “understanding a blocked path and finding a new path” or “realizing online that one is failing” require separate evaluation.

3. IL vs. Harnessing: The DeepSeek Moment Moved Where Compute Happens

From a traditional robot learning perspective, the following priorities have been implicitly accepted:

If there are sufficient demonstration and computational resources, it is best to further train the model through imitation learning. External harnessing, such as memory, planner, verifier, and recovery logic, is a suboptimal solution used when the model has not yet been sufficiently trained.

In this view, intelligence was basically stored in model parameters. As more data and GPUs are put into pre-training or fine-tuning, more power is packed into the weight. After learning, inference was considered a relatively simple process of using already created intelligence once.

Even in robots, when a model fails, it is standard practice to re-collect the failure trajectory, label the correct action, and add a demonstration to relearn the policy. Runtime memory, search, reflection, and verification seemed like temporary scaffolding that compensated for model imperfections.

After o1 and DeepSeek-R1, inference became a stage of ‘creating’ intelligence rather than ‘using’ it.

In 2024, OpenAI o1 reported that even with the same model, performance improves as not only the train-time compute used in reinforcement learning but also the test-time thinking compute used before the answer increases.[3] This may be a process where inference is not just a process of consuming created intelligence, but a process of additionally constructing practical problem-solving ability at the moment a problem is encountered. showed that there is

In 2025, DeepSeek-R1 demonstrated this change even more dramatically and with an open learning recipe. DeepSeek-R1-Zero exhibited behaviors such as longer solutions, self-verification, reflection, and alternative search through rule-based rewards and large-scale reinforcement learning without the need for SFT to first imitate the reasoning trace. [5]

In the initial arXiv release, AIME 2024 pass@1 increased from 15.6% → 71.0% during the RL process, and using majority voting, 86.7% reached. A follow-up Nature paper reports the final average pass@1 as 77.9%.[5]

What is important here is not just that the benchmark score has increased. RL not only taught the model the correct answer, but also taught how to use computational resources during inference .

• Decompose the problem into several steps.
• Check whether intermediate results are contradictory.
• Retract the wrong approach.
• Explore other solutions and candidates.
• For difficult problems, more tokens and time are used.

If OpenAI o1 imprinted on the world the possibility that “thinking before answering changes your ability level,” DeepSeek-R1 showed that it is not a special secret of a closed super-large model, but a new scaling paradigm that can be reproduced with RL and reward design. The DeepSeek moment referred to in this article refers to this paradigm shift.

In a study by Snell et al., distributing test-time compute according to problem difficulty could increase computational efficiency by more than 4 times compared to simple best-of-N, and under some conditions where FLOPs were adjusted, a small model using test-time compute outperformed a 14 times larger model. [4]

The central question in the AI ​​industry has moved from “How big a model should I train?” to “How effectively will the trained model compute when it encounters problems?”

What changes if we apply this transition to robots?

Many current VLA studies still handle failure in a similar way to LLM before the DeepSeek moment. Collect failure trajectories, relabel the correct actions, and further train the model with IL. CorrectNav's self-correction flywheel basically belongs to this family.[1]

However, all long-tail failures in the real environment cannot be collected in advance. Obstacles seen for the first time, paths suddenly blocked, contradictions between instructions and observations, and multiple similar target locations keep appearing. What is needed at this time may not be just a single reflexive action stored during learning.

• Re-search past observations.
• Maintain multiple hypotheses about the current location.
• Generate and compare multiple candidate paths.
• Check the goal-arrival condition with a separate verifier.
• Cancel the wrong plan and return to the previous junction.
• If information is insufficient, request additional observations or clarification.

In other words, the harnessing of the robot can be seen as extending the search·reflection·verification performed by DeepSeek-R1 on the internal reasoning trace to the level of the embodied system.

IL precompiles intelligence, harnessing configures intelligence in the field.

Before the DeepSeek moment, runtime computation seemed like a detour used because there were not enough models. Afterwards, you can actually see it the other way around.

Models that do not use runtime computation may be fast models, but they are likely to be stuck in certain performance upper bounds on problems that require deep thinking.

So the question is no longer “Should we train the model further, or should we just temporarily harness it?”

Which capabilities should be compiled into weights at training time, and which capabilities should be configured through memory·search·planning·verification at test time?

If DeepSeek-R1 has elevated test-time computing to the core scaling axis of intelligence in LLM, the task of the next generation VLA is to extend this to the physical world.

4. Is ‘VLM + Action Expert’ Enough for a VLA?

Many modern VLAs can be conceptually understood as follows:

The VLM backbone understands the meaning of scenes and language instructions, and the Action Expert generates the robot's sequential actions. π₀ is a representative structure that combines a flow-matching-based action generation module on a pre-trained VLM. [9]

However, long-horizon navigation and manipulation may require a separate layer of deliberation between semantic understanding and low-level action generation. In this article, we will call it Deliberation/Planning Expert.

Planning Expert is clearly meant to generate a path, subgoal, and action sequence, but the actual functions required are broader than simple plan generation. You need to analyze state uncertainty, generate candidate hypotheses, determine the need for additional observations, and compare plans. Therefore, Deliberation/Planning Expert is more appropriate as a general name.

In manipulation, the name TAMP Expert may be more specific. This is because Task and Motion Planning deals with both symbolic task sequence and geometric motion feasibility. On the other hand, in VLN and autonomous driving, route hypothesis, scene interpretation, risk estimation, and alternative planning are central, so Deliberation/Planning Expert is applied more broadly.

5. Why Today’s VLN Systems Cannot Say ‘I Don’t Know’

Currently, many VLN systems must output one of the following: forward, left turn, right turn, stop, or goal arrival at every step. A choice must be made even when observations are insufficient, and there is often no interface to express the uncertainty itself as a separate system state or to suspend judgment and take information-gathering action.

As a result, the following failure occurs:

• Even if you see a wall or a blocked passage, keep going straight.
• Of the two corridors, one with weak evidence is randomly selected.
• Similar furniture or doorways are mistaken for target landmarks.
• Declare goal arrived even though it is not the destination.
• Maintain the existing plan even if previous judgments and current observations are contradictory.

This is not necessarily a problem that occurs simply because the VLM does not understand visual information at all. This may be because there is no next option in the system's action space.

• We're not sure yet, so we stop.
• Rotate your field of view and observe again.
• Search for images of previous junctions.
• Contrast instruction and landmark again.
• Each of the two candidate paths is briefly explored.
• Return to the previous clear position.
• The target arrival conditions are checked with a separate verifier.
• Request clarification from the user.

AdaNav uses action entropy as an uncertainty signal to invoke reasoning only when necessary. Rather than reasoning equally at all steps, additional calculations are performed only in difficult situations.[12]

True online self-awareness may be an interface design issue between Monitor → Router → Deliberation/Planning Expert → Verifier → Action Expert, rather than a mysterious ability naturally acquired by a large VLM.

6. Reading VLA Progress as a Shift in Computational Structure

The following division is not an official historical division, but an interpretation centered on where representative studies placed their calculations and model capacity.

2023: Single system VLA

RT-2 combined web-scale vision-language pre-training and robot trajectory learning, and output robot behavior in the same format as language tokens.[8] It showed the possibility of integrating semantic understanding and action generation into a single autoregressive model.

2024: Semantic backbone and Action Expert separation

π₀ combines the semantic knowledge of pre-trained VLM and flow matching-based action generation. [9] The slow but general-purpose semantic backbone and the Action Expert, which must generate fast and precise continuous actions, have begun to be functionally separated.

2025: History, context, data curation

π_0.5 performed long-term manipulation in a new home environment by combining heterogeneous co-training, semantic subtask prediction, web data, and various robot data. [10] StreamVLN combines fast-streaming context and slow-updating memory, and uses sliding window and 3D-aware token pruning. We attempted to maintain long-term history within a limited delay time.[11]

2026: Reasoning and closed-loop alignment

VLA-Thinker treats visual re-observation as part of the reasoning action, and aligns the reasoning-action sequence with task success with trajectory-level GRPO after SFT cold start. [13]

Alpamayo-R1 combines causal reasoning trace and trajectory planning, and uses RL after SFT to improve reasoning quality and reasoning-action consistency. The paper reports a total latency of 99ms, including 40 reasoning tokens and flow-matching trajectory decoding, in the optimized Blackwell system. [14]

The likely direction in 2027 is not “VLA that generates longer text CoT,” but is likely to be efficient onboard reasoning VLA that usually acts quickly and calls latent reasoning, action-space deliberation, memory retrieval, search and verification only in uncertain moments.

7. Can More Demonstrations Alone Produce Reasoning?

The development of reasoning LLM after 2025 is difficult to explain through simple instruction imitation. DeepSeek-R1-Zero showed that reasoning behavior can appear through large-scale RL without prior SFT, and DeepSeek-R1 combined cold-start data and multi-stage RL·SFT. The key algorithm used in this process is GRPO.[5]

Not all modern LLMs use GRPO, and RL is not a replacement for robust pre-training, data quality, and model structure. A more accurate expression is:

In frontier reasoning models after 2025, RL-based post-training after supervised imitation has emerged as a key axis to rapidly increase performance.

The same question arises in VLA. IL is strong at learning the correct action, “Do this action for this observation.” However, the following abilities are difficult to learn through simple step-wise imitation.

• Take back your wrong judgment
• Withholding action when information is lacking
• Compare long-term outcomes of multiple candidate plans
• Reduce errors accumulated during execution
• Distinguish between risky and safe success
• Optimizing recovery costs and mission success together
• Compare information gain with time required for additional observations

Therefore, a realistic learning recipe is likely to be a combination of the following three steps.

1. 1 IL Secure basic perception-action skills.
2. 2 RL Optimize long-term outcome, recovery, safety and deliberation policy.
3. 3 Runtime harnessing Adapt to situations outside the learning distribution.

If the VLM backbone already has strong semantic representation through internet-scale multimodal pre-training, it is unclear whether the reasoning ability of the VLM part will continue to increase proportionally by adding robot demonstration. Additional robot data is directly beneficial in strengthening the Action Expert, but continuously updating the entire semantic VLM with IL may result in forgetting of general visual and language abilities or overfitting to narrow action distributions.

8. Why Is Reasoning Expensive Today?

Current reasoning models are expensive because they may generate far more internal reasoning tokens than are visible in the final answer.

According to OpenAI’s official API documentation, reasoning tokens are not shown directly to the user, but It occupies the context window and is charged at the same rate as the output token. Depending on the complexity of the problem, hundreds to tens of thousands can be generated.[6]

An example call from the official documentation shows the following usage:

• Input: 75 tokens
• Total output: 1,186 tokens
• Among them, reasoning: 1,024 tokens
• Remaining output delivered to user: approximately 162 tokens

That is, in this case, about 86% of the output tokens were used for reasoning that was not visible to the user.[6]

Specific cost example of robot reasoning call

Let's say the robot determines whether the path matches, goal arrival, candidate corridor selection, backtracking, and the need for additional observations based on the current image and compressed navigation history. Assume that the following token is used in one call.

• Input context: 2,000 tokens
• Decisions and explanations visible to the user: 400 tokens
• Internal reasoning: 8,000 tokens

In the OpenAI public price list confirmed on July 11, 2026, the standard rate for gpt-5.5 is $5 per million input tokens and $30 per million output tokens. [7] Using this as an example unit price, the cost per call is as follows.

In other words, “reasoning costs rise up to 90%” is a very possible scenario. However, the exact expression is as follows:

In complex reasoning calls, hidden reasoning tokens can account for more than 90% of the token cost of the API call.

If internal reasoning increases to 16,000 tokens, the reasoning cost becomes $0.48, the total cost becomes about $0.502, and the reasoning ratio is about 95.6%.

When converted to operating time,

If the above 8,000-token reasoning call is performed once every 5 seconds, it is called 720 times per hour.

• Cost per call: approximately $0.262
• Cost per hour: approximately $188.64
• Among them, the reasoning cost: about $172.80

If only a 400-token decision is output from the same input without hidden reasoning, the cost per call is about $0.022, or about $15.84 per hour. In this virtual system, adding reasoning increases the token cost per hour by approximately 12 times .

If 10 robots are operated for 8 hours a day, the scale is as follows.

• Including Reasoning: Approximately $15,091/day
• Excluding Reasoning: Approximately $1,267/day

This calculation is an illustrative scenario excluding image token, caching, batch processing, model-specific discounts, network, and other system costs. Actual costs vary greatly depending on model, call cycle, context compression, and reasoning effort.

9. Moving Reasoning Onboard Is a Requirement of Cost and Safety, Not a Choice

It is true that current reasoning is slow and expensive. However, this is not a reason to give up reasoning in embodied AI, but rather reasoning should be performed much more efficiently onboard. The robot is not a chatbot that answers once and ends, but continues to observe and make judgments over a long period of operation. If the cloud planner·critic·verifier is called for each exception situation, the token cost accumulates almost linearly as the number of robots and operating time increases. Even if cloud inference becomes faster, this recurring cost structure does not disappear.

It's not just a matter of cost. Relying on remote servers for failure detection, local planning, and emergency verification leads to network latency, dead zones, and disconnections that lead to action delays and safety gaps. For a large robot fleet to perform minimal judgment and recovery without constant cloud reasoning, core deliberation must eventually move inside the robot.

At the same time, there is no reason to believe that this cost barrier is fixed at its current level. By advancing model compression, decoding algorithms and edge hardware together, the same reasoning ability can be executed with fewer tokens, in less time and at lower power. In other words, cost and safety require onboard conversion, and technological advancements are making that conversion a realistic option in the near future.

The following technologies are developing simultaneously:

• speculative decoding[25]
• KV-cache optimization and compression[26]
• quantization and mixture-of-experts routing[27][28]
• distillation[29]
• latent reasoning and action-space reasoning[30][13]
• diffusion language model[15][16]
• Edge accelerator targeting generative AI·reasoning[19]
• uncertainty-triggered adaptive computation[12]

In particular, the diffusion language model can refine multiple token positions in parallel, unlike autoregressive decoding, which generates tokens one by one from left to right. Mercury Coder Mini reported 1,109 tokens/s on H100 and 737 tokens/s on Small,[15] Seed Diffusion Preview reported 2,146 tokens/s based on code generation on H20.[16]

This figure cannot be directly applied to the general-purpose multimodal reasoning VLA. What is important is not the specific number, but the direction in which generation latency can change by order within a short period of time due to algorithm and hardware development.

On the data center side, NVIDIA also proposed Vera Rubin's goal of lowering the inference token cost by up to one-tenth compared to Blackwell and increasing inference throughput per watt by up to 10 times.[20]

Speed ​​improvements enable onboard switching, but cost and safety force onboard switching. Whether reasoning is currently fast or slow, if robots are to be deployed on a large scale, they must have local intelligence that is not unrestrictedly dependent on the cloud.

There is no need for future onboard VLAs to generate long natural language CoTs.

• You can reason within the latent state.
• Trajectory candidates can be compared directly in action space.
• The slow path can be activated only at moments of high uncertainty.
• The reasoning behavior of a large teacher can be distilled into a small runtime model.
• The verifier and planning module can be run at different cycles.

The goal of onboard reasoning is not to have the robot talk to itself thousands of words every moment. Deliberation of the necessary type is carried out only at the moment of need, within limited time and power.

There is another strong limitation to this transition. Robots cannot carry data center-grade power and cooling. Reasoning must be done within battery life, thermal design and real-time control budgets, so onboard means lower power. Distillation, quantization, sparse routing, adaptive invocation, and dedicated accelerator are not simple optimization techniques but conditions that establish this architecture.

Therefore, a hybrid structure in which large-scale teacher learning, fleet-level data processing, simulation and policy update remain in the data center, and the compressed runtime model and safety harness are deployed onboard is a realistic endpoint. The Thor-Alpamayo stack, which we will look at later, is the industrial answer to this need. This is because the structure seeks to distill the capabilities of a huge reasoning teacher into a small runtime model and execute it on a low-power, high-throughput automotive compute. [18][19]

10. Reframing the Debate: What Was the Best Option, and What Was Second-Best?

The original traditional assumption was as follows.

Traditional assumption

• Best: Learn the end-to-end VLA further with IL with sufficient data and calculations.
• Second-best: Since the model is insufficient, harnessing such as memory, planner, verifier, and recovery rule is attached externally.

Under this assumption, once the model is large enough and trained with sufficient demonstration, harnessing should disappear. Harnessing is an engineering patch that complements an incomplete model.

Alternative hypothesis

• IL is optimal for condensing frequently occurring situations and reflexive skills into parameters.
• Harnessing is optimal for adapting through memory, search, verification, and additional observations in unobserved long-tail situations.
• In an open-world environment, all exceptions cannot be enumerated in advance as training data.
• If so, harnessing may not be a temporary supplement but a structurally necessary component of open-world intelligence.

Is IL the best and harnessing suboptimal?
Or are IL and harnessing responsible for different calculations, and is harnessing essentially the best structure for long-tail autonomy?

“Harnessing may be best” does not mean that robot learning should not be done. A more accurate argument is as follows.

Rather than a structure that compresses all capabilities into a single end-to-end policy, a structure that combines learned policy with runtime memory·monitor·planning·verification can provide higher open-world robustness at the same total computational budget.

11. The Industrial Direction Indicated by Thor and Alpamayo

The combination of DRIVE AGX Thor and Alpamayo presented by NVIDIA shows that this change is not just a research imagination but is being materialized into industrial architecture.

In January 2026, Jensen Huang announced Alpamayo and said, “The ChatGPT moment for physical AI is here”. NVIDIA describes Alpamayo as a reasoning VLA that reasons in rare long-tail driving scenarios and generates trajectories and reasoning traces together.[17]

The important point is that NVIDIA’s strategy is not simply to place a huge model such as Alpamayo 1 directly in a vehicle. NVIDIA defines Alpamayo as a large-scale teacher model, and presents a structure that fine-tunes it or distills it into a small runtime model and integrates it into the actual AV stack. [17]

Alpamayo 2 Super, announced in May 2026, is a 34B reasoning VLA teacher model. It provides 360-degree perception, meta-action, and chain-of-causation traces and trajectories, and the path to be distilled into a compact model and executed in DRIVE AGX Thor inside the vehicle is specified. [18]

Large-scale teacher model → simulation·closed-loop RL → compact model distillation → Thor onboard deployment → safety monitor and fallback stack

AlpaGym, also announced, is a closed-loop RL framework that allows models to experience the results of their driving decisions within simulation. It is a structure that places compounding errors and long-tail edge cases that are not revealed through static datasets into the learning loop.[18]

DRIVE AGX Thor provides up to 1,000 INT8 TOPS and 2,000 FP4 TFLOPS and is an automotive SoC targeting generative AI and high-throughput LLM inference.[19]

This is not a structure that chooses between IL and harnessing. Frequent situations are compressed into the runtime model through demonstration and distillation, long-tail reasoning is strengthened through reasoning supervision and RL, and at the time of deployment, the monitor·planning·safety stack selectively uses calculations according to risk.

Thor-Alpamayo is not a story about “running a large model in a car,” but a system design that separates train-time intelligence and runtime intelligence.

12. Turning ‘Harnessing Is Best’ into a Research Hypothesis

The preceding discussion can be translated into research questions as follows.

Under the same total computation budget, does a VLA that allocates some computations to runtime memory·planning·verification show higher performance and safety in a long-tail environment than an end-to-end VLA that allocates all computations to additional IL?

Hypothesis 1. Adaptive runtime reasoning has higher long-tail calculation efficiency than additional IL.

For the same total GPU time or energy budget, we compare models that put all computations into training-time fine-tuning and models that leave some computations to uncertainty-triggered runtime reasoning.

• OOD detour success
• blocked-route recovery
• collision rate
• false goal-arrival rate
• intervention rate
• success per unit compute
• Joules per successful episode

Hypothesis 2. Failure awareness and failure recovery should be evaluated separately.

No matter how good the recovery policy is, if the failure detector does not work, recovery will not start. Conversely, if the detector is overly sensitive, unnecessary stopping and backtracking increases.

• failure probability calibration
• failure detection delay
• false-positive rate
• missed-failure rate
• Recovery success after detection
• risk–coverage curve

Hypothesis 3. Deliberation/Planning Expert is necessary for discovering new detours

Evaluation of returning to an existing path and evaluation of discovering a new path when the environmental topology has changed must be separated. The shortest path that existed during training is physically blocked during deployment and the following is measured.

• New path discovery rate
• exploration overhead
• Loop occurrence frequency
• dead-end recognition time
• Invalid goal-arrival declaration
• detour efficiency
• Route efficiency obtained without a map

In manipulation, this role can be specified as TAMP Expert. Navigation is supported by route-level planning expert or topological deliberation module.

Hypothesis 4. Fast–slow VLA improves accuracy–latency Pareto frontier

In normal times, only the Action Expert is run, and the Deliberation/Planning Expert and Verifier are called only when the Monitor detects high uncertainty.

• Average and p95 decision latency
• reasoning invocation rate
• reasoning tokens per episode
• success per dollar
• success per Joule
• calibration error
• intervention-free mission duration

It can be verified whether this structure forms a better Pareto frontier between a model that reasons at every step and a model that does not reason at all.

If adaptive harnessing consistently outperforms end-to-end IL for the same computational budget, harnessing is no longer an ancillary engineering trick. Harnessing becomes the core computational architecture of open-world embodied intelligence.

Conclusion: More Training vs. Deeper Thinking When It Matters

CorrectNav shows that the recovery behavior of navigation policies can be improved by recycling failure trajectories as training data. However, during execution, the model does not explicitly determine that it is wrong. An external oracle and a distance-based detector determine deviation, a trajectory planner creates a recovery path, and the model imitates the results.

This method is effective in absorbing frequent and predictable failure modes into model parameters. However, in the real world, obstacles, environmental changes, observation ambiguities, goal conflicts and interactions that cannot be fully enumerated in advance continue to appear.

The next-generation VLA is likely to be a system in which the fast Action Expert handles most situations, the lightweight Monitor monitors uncertainty and the possibility of failure, and the Deliberation/Planning Expert·Memory·Search·Verifier operates only when necessary.

IL makes general actions faster, and RL strengthens long-term outcomes and recovery/reasoning policies. Harnessing distributes test-time compute according to the current situation.

Currently, cloud reasoning is expensive. In complex calls, hidden reasoning tokens can account for more than 90% of the API token cost, and if called every few seconds, the hourly cost of one robot can increase from tens to hundreds of dollars.

However, there is no reason to give up reasoning. Advances in decoding architecture, distillation, latent reasoning, adaptive invocation, and edge hardware can rapidly reduce current costs and latency. There is no guarantee that today's economic performance will be the same as next year's economic performance.

Which intelligence should be pre-compressed into the weights, and which intelligence should be calculated at runtime?

And the more fundamental question is this.

Is harnessing a workaround to compensate for undertrained models, or is it part of the architecture intelligence needs in order to operate in the real world?

The DeepSeek moment showed that “time to think” in language models can change the level of intelligence. The teacher-RL-distillation-onboard stack presented by Thor and Alpamayo shows that the principle has begun to extend to the physical world.