This survey organizes the fragmented field of agentic robots, where foundation models plan, call tools, monitor execution, and recover from failures, into four domains (Model, Data, Environment, Harness) covering 17 categories, so researchers can compare contributions on the same axes instead of talking past each other.
Suppose you’ve wired a Vision-Language-Action model into a robot arm to clear a table. The VLA produces an action chunk, the gripper misses the handle, and now what? A pure action model has no way to notice the miss, pick a different skill, or retry from a known state. Over the past two years, papers have bolted on planners, memory, verifiers, recovery policies, skill libraries, and runtime safety gates, each solving a slice of this problem.
The trouble, which the authors flag as their motivation, is that these contributions are scattered across different venues using different vocabulary. A paper on “self-improving robots” and one on “embodied agents” may describe nearly the same loop. Readers can’t tell what’s new, what overlaps, or which component actually caused a reported win. The paper’s one named precedent for taxonomy work is PAPAV, which compares computer-use and robot-use agents along Perceive-Anticipate-Plan-Act-Verify. This survey takes a wider cut: it covers not just task execution, but also how agents shape training data, simulated worlds, and the software plumbing around learned policies.
The core move is a four-domain split, where each domain names a place agent decisions act:
•
Model covers five interventions on the learning and decision stack: Training (an agent writes reward code or edits training recipes, as in Eureka Eureka), Perception, Planning, Robot Control, and Adaptation.
•
Data covers Collection (physical rollouts, simulator rollouts, or Generative data synthesis), Annotation (text, spatial, interaction, outcome labels), and Refinement (filtering trajectories, fixing labels).
•
Environment covers Reconstruction (building executable scenes from video or images), Task Generation (goals, success predicates, curricula), and Benchmarking (test suites and evaluators, with a strong warning that scores depend on the full execution contract).
•
Harness covers the runtime software: Orchestration (who runs next, for how long), Memory, Monitoring and Recovery, Skills (reusable code or behaviors, descended from Code as Policies), Infrastructure (tool APIs, policy serving, safety gates), and Layered Systems (a System 2 planner over a System 1 Vision-Language-Action model over an analytic System 0 controller like inverse kinematics).
A single paper can live in several boxes. The authors call out Zero2Skill as touching data collection, annotation, and refinement in one pipeline, and HarnessVLA as spanning orchestration, memory, and recovery. The taxonomy is functional, not exclusive.
A stylized loop that recurs across the surveyed systems:
while not goal_satisfied(state):
obs = perceive(sensors, memory)
subgoal = planner.decide(obs, memory, skills)
executor = orchestrator.route(subgoal, state)
result = executor.run(subgoal, obs) # VLA, tool, or skill
memory.write(subgoal, result)
if monitor.failed(result):
state = recovery.handle(result, memory)
else:
state = update(state, result)
The survey’s contribution is naming the design choice at each line and cataloging who made which choice.
Being a survey, the “findings” are patterns across roughly 400 cited works rather than new experiments. Several are worth carrying away.
•
Benchmark scores conflate the agent with its executor. Two systems with similar success rates can differ enormously in what the agent decides versus what a strong underlying Vision-Language-Action model already does. On RoboDojo, the authors report that GPT-6 Astra used as a manipulation agent reaches 22.48% average success across 42 simulation tasks, above several trained specialist policies but far from solved. The paper argues this number is informative only alongside the executors, observation access, and retry budget.
•
Perception is the dominant failure source in several code-as-policy systems. The authors note that most real-robot errors in VoxPoser trace to perception, and OK-Robot shows how errors compound when off-the-shelf detectors, segmenters, and grasp generators chain without recovery. One cited study drops from 65.0% success with privileged simulator state to 22.5% with RGB alone.
•
Hardening a tool interface can matter more than a better model. ASPIRE, which adds primitive-level traces and repair validation around existing executors, lifts macro-average success on perturbed LIBERO-PRO from 14% to 62%. The paper reads this as evidence that the harness around a policy is a first-class research target, not glue.
•
Self-improvement doesn’t always compound. A cited 123-round study found that accepted skill revisions did not add up to success on the target task, even with replay and held-out checks. The authors treat this as an open problem, not a solved one.
•
If you’re building an agentic robot stack, use the taxonomy as a checklist. For each of the 17 categories, ask whether your system makes an explicit choice or inherits a default. Undocumented defaults in Monitoring, State Connection, or Handoff Timing are where silent failures hide.
•
If you’re reading agentic-robot papers, demand the full execution contract before trusting a number: what executors were available, what observations the agent saw, how many retries were allowed, and whether the scene was reset between attempts. The paper argues that otherwise-identical benchmarks (LIBERO, LIBERO-PRO, RoboCasa) measure different abilities under different protocols.
•
If you’re designing an evaluation, separate scene bugs, infeasible tasks, and bad success predicates. The Environment section argues each failure mode needs its own repair path; conflating them makes it impossible to tell whether the agent, the world, or the evaluator failed.
•
Worth testing in your own work: whether adding a decision model (a small, calibrated classifier that picks among code-proposed options at every step, in the style the paper describes for Jev and d1) between your planner and your executor reduces latency without sacrificing success. The survey positions this as an emerging layer, not a validated technique on robots.
The companion GitHub repository tracks the cited works.
This is a survey, so the strongest evidence is the organization itself, not controlled experiments. Numbers quoted from individual papers (the 22.48% on RoboDojo, the ASPIRE lift, the perception-error claims) inherit the methodology and reporting of their sources, which vary. The paper’s citation set skews heavily toward 2025 and 2026 preprints, including many that have not been peer-reviewed; some cited model names (GPT-6 Astra, Gemini 4 Argon) reflect a future-dated snapshot of the field. The taxonomy is non-exclusive on purpose, which is honest but means it can’t be used to count papers in a category without double-counting. Finally, the four outlook problems the authors raise, fair benchmarking, real-robot deployment, inference efficiency, and cross-embodiment transfer, are flagged as open; nothing here resolves them.