Companion analysis · From HumanWAM to GR00T 2: world-action models, data, and deployment

A robot reaches the right shelf and then stops: the object is behind a box, the previous grasp failed, and the plan assumes an empty hand. A better action predictor might help with the grasp. It does not automatically decide which assumption broke, recover the object, or remember the fix next time. The recent wave of agentic robotics moves those responsibilities into explicit, inspectable loops.

NVIDIA's work is useful because the loops appear at several levels: COMPASS automates navigation development; Vesta reasons at runtime; ASPIRE improves executable skills; ENPIRE manages physical policy experiments; AW-0 learns code alongside world-action prediction; GR00T 2 combines a policy with programs and recovery. TinyAstral, from a different research team, shows how harness improvements can survive distillation into a small planner. [1] [4] [5] [8] [11] [13] [14]

TinyAstral studies RSI, recursive self-improvement, through bounded changes to a manipulation agent's harness. Its evidence concerns software evolution and distillation under fixed rules and budgets. Results below are author-reported and checked against primary sources through 12 November 2026; the architectural synthesis and deployment recommendations are our interpretation. [14] [15]

1. Why several directions are moving at once

The mechanism is more specific than “the model can reason.” Robot software now exposes perception, motion, resets, and outcomes through callable interfaces. Rich traces make a failed experiment legible to a coding agent. Simulators provide repeatable trials; stronger multimodal models diagnose more failure types; persistent skill libraries prevent every task from starting over. Their combination lowers the cost of running the next engineering iteration.

This is our explanation of the convergence, not a measured publication-growth claim. The key dependency remains an environment that tells the truth. If an API reports a grasp as successful when the object slipped, the agent can build a coherent plan on a false state. More reasoning then compounds the error. Better feedback and termination checks can therefore produce larger gains than a larger planner.

LoopWhat changes?Representative workWhat it does not imply
Inference-time agencySubgoals, tool calls, memory, retriesVesta; GR00T 2 + AgentNo automatic policy learning
Skill/program improvementExecutable code and reusable repairsASPIRENo automatic update to base-model weights
Physical policy researchTraining recipes, policies, data and infrastructureENPIRE; COMPASS developmentThe coding agent need not run on every control tick
Learned agentic representationModel jointly represents programs and predicted executionAW-0Generated code is not automatically a verified controller
Harness RSI + distillationTools/feedback improve first; compact planner learns laterTinyAstralNot an ever-growing model rewriting itself online
Figure 1 · Three places where an agent can act

Development

Scene / reset / verifier interfaces
Coding agent proposes and tests changes
COMPASS / ENPIRE: train, compare, package

Deployed task loop

Instruction + observations + memory
Planner → subgoals / skill / WAM calls
Fast controller → evidence → recovery

Cross-episode improvement

Inspect failures and versioned traces
ASPIRE / RSI: validate reusable repairs
Freeze harness → distill → acceptance gate

Conceptual synthesis; the named projects do not collectively constitute one verified end-to-end system.

COMPASS starts from X-Mobility, trains robot/environment-specific residual specialists, and can distill specialists into a shared mobility policy. The agent-driven tutorial automates scene preparation, smoke tests, residual training, diagnosis, evaluation, and packaging. At deployment, the policy reads RGB, odometry, and a goal and produces velocity commands. The coding agent is not required to narrate or choose every steering correction. [1] [2] [3]

That makes “agentic navigation” two different propositions. An agent can develop a navigation policy; alternatively, it can choose semantic destinations, maintain task memory, and replan during navigation. The first should be measured by engineering time, accepted checkpoints, and matched goal/fall/travel-time tests. The second needs route success, SPL, instruction grounding, recovery, and latency in the deployed loop. A video of one does not validate the other.

Vesta illustrates the runtime side. It combines spatial reasoning and an explicit observation/progress/reasoning/action memory structure, and can send waypoints to a lower-level controller. On R2R-CE val-unseen, its reported SR is 55.5 and SPL 50.8, versus the specialist InternVLA-N1's 55.4 and 52.1. Similar success with worse path efficiency is a more useful reading than “generalists beat specialists.” Those are simulated navigation results, not hours of autonomous G1 operation around people. [4]

For a navigation product, the practical architecture is a semantic agent over a timed motion contract: a subgoal includes a frame, reachable region, stop condition, and timeout; localization and collision response remain fast. The interesting experiments are lost-target recovery, map changes, and delayed observations. Asking an LLM to output velocity directly is not required to benefit from agentic planning.

3. Manipulation: ASPIRE saves skills; ENPIRE runs experiments

ASPIRE treats a robot program as something that can be debugged from multimodal traces. Perception overlays, grasp proposals, motion trajectories, and collision feedback expose where a plan failed. The agent repairs code, reruns it, and stores validated experience in a skill library. The reusable object is often a tool-use rule or recovery pattern, not a newly trained motor policy. [5] [7]

Its study separates a debug split from held-out seeds: LIBERO-Pro uses 160 tasks and 50 evaluation seeds per task; Robosuite uses 100 seeds per task; BEHAVIOR-1K uses 25. Those budgets matter because an agent can otherwise appear stronger simply by making more attempts. The reported unseen long-horizon transfer example is 31% versus 4% for the comparison method; it remains a bounded suite, not a general success rate for homes. [5] [6]

A skill library is also a dependency graph. A repair that assumes a top-down camera, a particular gripper, or a fully visible object needs those preconditions recorded. Retrieval alone cannot determine compatibility. We would store the triggering failure, coordinate convention, tool version, required sensors, evidence of improvement, and a retirement test with each skill. Stale memory is a physical failure mode, not merely a retrieval-quality problem.

ENPIRE moves outward to the experiment loop: reset, run, verify, improve. The Environment module exposes repeatable resets and outcome checks; Policy Improvement can use heuristics, behavior cloning or RL; Rollout schedules real trials; Evolution compares hypotheses. This is the infrastructure needed before “let a coding agent improve the robot” becomes a meaningful, reproducible instruction. [8] [9] [10]

Its showcased 99% is pass@8: up to eight failure-conditioned in-context retries per subtask inside a long rollout. It is not 99% first-attempt success, and not eight independent samples selected after the fact. Recovery is valuable, but its cycle time and damage budget must be reported. A production acceptance test should show pass@1, bounded-retry success, time-to-completion, and unrecoverable resets together. [8]

Parallel robots shorten some experiments while creating coordination work. ENPIRE reports Mean Robot Utilization and Mean Token Utilization, and notes underused robots and increasing token consumption with scale. A robot waiting while agents read logs is idle capital. Faster wall-clock discovery should therefore be compared with robot-hours, accelerator-hours, tokens, resets, and human maintenance—not just the number of agents launched. [8] [10]

4. Agentic WAM: code can be a learned interface, not only an outer prompt

AW-0 places code, video, and action experts inside a Mixture-of-Transformers design. Code offers explicit task structure and reusable calls, while video/action streams ground the intended execution. This differs from placing a general LLM above a frozen policy: planning structure is part of model training. It still depends on annotation quality, available primitives, and whether predicted code is executable in the current scene. [11] [12]

Its hybrid executor runs code slices that pass validity and progress checks, otherwise falling back to action chunks. On the reported RoboTwin setting, hybrid execution raises randomized success from 20.6% to 29.2%, while clean success falls from 80.8% to 63.1%. The trade-off is informative: explicit structure can help when visual execution shifts, yet API grounding and switching can hurt in easy conditions. Hybrid is a design to calibrate, not an automatic improvement. [11] [12]

On eight real tasks across YAM and Tianji–Sharpa, AW-0 reports a 71.1 average rubric score over 3×16 rollouts per task, versus DreamZero's 46.0. This is additive task progress, not 71.1% complete end-to-end success. Progress is useful for locating bottlenecks; a factory acceptance test still needs the terminal predicate. The two metrics should remain separate even when the paper displays both as percentages. [11]

GR00T 2 supplies the outer-system comparison: on RoboCasa365, SFT scores 67.2%, RL 72.4%, Agent 81.8%, and RL + Agent 88.0%. Its RoboDojo bank-0 sequence is 35.2%, 40.8%, 72.3%, and 75.8%. Programs, executor selection on development seeds, and online recovery contribute to the agent rows. The gains support combining execution learning with task-level correction, while forbidding attribution of the final system score to the base WAM alone. [13]

5. TinyAstral: evolve the harness, then compress the planner

TinyAstral's first stage freezes its approximately 180B teacher. Frontier coding agents change the surrounding harness: perception, tool behavior, feedback, task memory, and recovery. Candidate and parent face paired task/seed cases under pre-registered acceptance tests, with separate training, selection, and evaluation seeds. Only accepted changes survive. RSI here means a controlled software-improvement loop; the teacher is not modifying its own weights. [14] [16]

The second stage freezes the final harness, collects teacher reasoning and recovery trajectories, and trains 0.8B–4B students that use the same tools. This preserves software improvements while reducing planner inference cost. It is not distillation of every perception and control service into a 4B network. Segmentation, geometry, motion planning, and the improved harness remain part of the deployed system. [14] [16]

RoboTwin-50 / same 500 episodesInitial harness %Final harness %What was updated?
Frozen teacher (~180B)33.463.6Harness only
Untrained Qwen3.5-4B planner14.641.2Harness only
TinyAstral-4B36.262.8A separate student distilled at each harness snapshot

Strict success requires an autonomous done call and a correct terminal state. An environment success flag is not fed to the planner; tool-level verification can reject an incorrect done. That makes stopping behavior part of competence. The 4B student's 62.8% equals 314/500, close to the teacher's 318/500. This is evidence for transferring harness gains in that domain, not proof that 4B equals 180B in general reasoning. [14] [15]

TinyAstral-4B evaluationStudentTeacherProtocol boundary
Guava93.6% / 450 episodes94.7%Used for RSI and distillation; strict success
LIBERO-PRO78.3% / 300 episodes80.0%Used for RSI and distillation; not vanilla LIBERO
VLABench41.2% / 500 episodes46.2%Unseen benchmark; official success metric
EB-Manipulation27.6% / 228 episodes32.0%Unseen benchmark; different termination semantics
Real SO-ARM101Closed-loop examples; offline next-call accuracy also reportedNot a matched aggregate deployment SRDo not convert next-call accuracy into task success

Keeping teacher reasoning improves transfer in the reported ablations: removing it lowers LIBERO-PRO from 78.3% to 59.0%. The real-data ablation improves offline next-call accuracy from 0.235 to 0.923, but that is not an equivalent gain in complete real-task success. Both results favor preserving the type of evidence being measured rather than compressing every experiment into a single percentage. [14]

Compute savings also need a unit. On the measured 20-episode deployment subset, TinyAstral-4B uses 25.3 accelerator-seconds per episode; the teacher uses 123.8 with four accelerators and speculative decoding. That is about one fifth of teacher accelerator time, not a fivefold reduction in total robot cycle time or training cost. Tool execution, perception services, and the original harness search still have to be paid for. [14] [15]

Figure 2 · TinyAstral's two-stage separation

Evolve

Frozen teacher + current harness
Read failures → propose general edit
Paired selection tests → accept or reject

Distill

Freeze accepted harness H*
Collect reasoning and recovery branches
Train compact students in the same interface

Evaluate

Same harness, different planner
Strict terminal success and held-out seeds
Cost includes accelerator count and tool services

Redrawn from the paper's method; RSI selection and final evaluation must remain separate.

6. What would count as recursive improvement that matters?

A self-improving system can optimize the wrong evaluator faster than a human can. The outcome verifier must be tested independently, especially for false positives: a peg partly inserted, an object briefly placed then knocked away, or a navigation goal reached by crossing a forbidden region. Freeze its definition during candidate selection. If the agent edits both the policy and the definition of success, the improvement curve loses its meaning.

Separate improvement data, candidate-selection data, and final evaluation. Paired seeds reduce scene noise but do not eliminate adaptive overfitting after hundreds of proposals. A final held-out task family, a fresh environment, and a different robot are stronger tests of reusable improvement. Publish rejected candidates and spent resources as well as the final successful branch; otherwise an apparent autonomous breakthrough can conceal extensive search.

QuestionMeasurementCommon misleading shortcut
Did planning improve?Same actor, perception and retry budget; agent ablationAttribute a better controller to a smarter planner
Did policy learning improve?Same resets and held-out starts; pass@1 plus bounded retriesCompare pass@8 with pass@1
Did the harness generalize?Frozen planner; new tasks, sensors and bodiesReuse task-specific memory and call it zero-shot
Did compression reduce cost?Accelerator-seconds, p95 latency, all services, cycle timeEquate parameter ratio with whole-system savings
Did parallelism help?Robot-hours, tokens, wall-clock, utilization, maintenanceReport shorter wall-clock and hide resource growth
Is improvement safe to promote?Independent constraints, rollback, damage and intervention logsLet the candidate grade itself

7. A deployment architecture with two learning clocks

We would separate an immutable deployed version from an experimental branch. At runtime, a compact planner calls a versioned skill API or WAM executor; independent motion constraints bound velocity, force, workspace, and deadlines. Logs capture both tool intent and physical outcome. After enough failures accumulate, an offline improvement loop proposes a repair, tests it, and distills it if useful. Promotion requires an external acceptance gate and a reversible version.

The fast clock handles execution and recovery in the current episode. The slow clock improves tools, policies, and datasets across episodes. Confusing them creates two failures: online experimentation without a bounded operating envelope, or offline learning advertised as instant adaptation. COMPASS, ASPIRE, ENPIRE, AW-0, and TinyAstral occupy different parts of this design; no single paper establishes the entire architecture.

Multi-robot coordination adds another contract. One robot's repair may be incompatible with another's camera transform or gripper; a shared skill must carry those dependencies. Shared experience can accelerate learning, but shared control needs explicit task allocation, resource locking, and collision rules. Parallel policy research in ENPIRE should not be relabeled as verified autonomous multi-robot task coordination.

8. Our outlook: the durable asset is validated experience

Over the next one to two years, we would watch three experiments. First, do harness improvements transfer to a new robot without carrying task-specific exceptions? Second, can an agentic WAM choose between code and continuous action with a calibrated failure detector, rather than a heuristic that merely shifts errors? Third, can compact students retain recovery while cutting complete-system cost after perception and tool services are included? Each needs a budget-matched test.

NVIDIA's strongest contribution in this cluster is the breadth of the engineering loop: navigation adaptation, reusable skills, physical experimentation, predictive actions, and deployment infrastructure. That breadth is valuable, but not evidence that the components already compose without integration work. TinyAstral offers a complementary lesson: a large model's useful improvement may live in the harness, and a smaller model can inherit it if the teaching traces preserve reasoning and recovery.

The recent acceleration is real as a change in what researchers can automate: more of the work between a failure and a tested repair is now executable by agents. The unresolved deployment question is whether that automation lowers the cost of sustained, safe task completion. A growing skill library, a high pass@8 score, or a small planner is promising evidence. None is a substitute for that final measurement.

An agent needs a policy and an observable outcome

The detailed GR00T 2 analysis covers the action policy and its adaptation cost; the Compass 1 article covers a navigation policy with explicit historical evidence. Neither is a complete agent evaluation by itself. Archon’s Compass 1 is distinct from NVIDIA’s COMPASS framework discussed here. An integration should keep task success, recovery attempts, model calls, and human resets visible, rather than turning extra retries into an unqualified claim of better policy generalization.

Primary sources

  1. COMPASS: NVIDIA development workflow
  2. COMPASS: implementation
  3. X-Mobility: model and control interface
  4. Vesta: embodied reasoning and navigation
  5. ASPIRE: skill discovery and evaluation
  6. ASPIRE: paper
  7. ASPIRE: implementation and primitive contracts
  8. ENPIRE: physical improvement loop and pass@8
  9. ENPIRE: paper
  10. ENPIRE: implementation
  11. AW-0: code, video, action, and hybrid execution
  12. AW-0: paper v1
  13. GR00T 2: agentic execution and post-training
  14. TinyAstral: RSI, distillation, and compute accounting
  15. TinyAstral: results and deployment examples
  16. TinyAstral: reproducible harness evolution