There are four main approaches to making a robot agentic today. No survey gives this exact count, because each sorts the field by a different question. Counting the alternative ways a robot's decisions reach its motors at run time gives four.
What separates them is what the frontier reasoning model outputs. Hybrids that switch between approaches step by step are combinations, not a fifth approach.
- Layered orchestration. The model picks and steers learned skills (VLAs, world action models, RL policies) as tools.
- Code as policy. The model writes a program over perception and control primitives.
- Constraint- and objective-mediated generation. The model writes value maps, keypoint constraints or costs; an optimizer turns them into motion.
- Direct control. The model emits the motion targets itself.
End-to-end VLAs and world action models are not counted as approaches, even ones that reason internally. The surveys disagree on them. Salimpour et al. count end-to-end models as one integration type. Wang et al. include a standalone policy only when a foundation-model planner or verifier steers it. Qin et al. state that action prediction alone does not make a system agentic. Here they appear as the motor layer that the run-time paths drive.
How the 2026 surveys count
Each survey answers a different question, which is why their counts differ.
| Survey | Date | What it sorts by | Its count |
|---|---|---|---|
| Envisioning Agentic Robotics (Grid Robotics: Lan et al.) | Nov 2026 | How the reasoning layer reaches the body | 3 execution paths: layered orchestration, direct control, code as policy; hybrids recommended |
| A Survey of Agentic Robotics: Toward Continual Self-Improvement (Wang, Jiang, Shen, Soh) | Oct 2026 | Where the foundation model's decisions act, coded across 2,343 systems | 3 loci: task orchestration, motion/action generation, improvement |
| Towards Agentic Robots (Qin et al.; CUHK, Fudan, Tsinghua and others) | Oct 2026 | Which part of the robot system model decisions shape | 17 categories in 4 domains: model, data, environment, harness |
| Weights or Skills? (Jena et al.) | Aug 2026 | Whether competence ships as network weights or as code | 6 technique branches; code as policy split into 5 levels of self-improvement |
| Towards Embodied Agentic AI (Salimpour et al.) | Nov 2025 | How the foundation model is integrated | 4 types: single-shot tool calls, agentic loop, orchestration, direct or embedded |
The four approaches here combine two sources. Three are the execution paths named in Envisioning Agentic Robotics. The fourth comes from Wang et al., who split motion generation three ways: direct action, programs, and objectives that a solver executes. Wang et al.'s improvement locus and Qin et al.'s Data and Environment domains are real and growing. But they describe how robots are built and improved, not how a robot acts, so they are covered under Beyond run time. Harness functions (memory, monitoring and recovery, skill libraries) appear in every approach, so they are not an approach of their own.
1. Layered orchestration
This is how the frontier labs ship today. A reasoning model plans, tracks progress and decides when to replan. Fast learned policies do the physical work as bounded subtasks.
In production stacks
- Gemini Robotics 2.5 (DeepMind, Nov 10 2026). The Gemini Robotics ER model tracks the workflow; the 2.5 VLA does the reaching, grasping and placing. Kitting automotive parts on Apptronik's Apollo 2 at Mercedes-Benz reached 96% success.
- GR00T 2 (NVIDIA, Nov 2026). A reasoning model marks grasp and release points on the camera view.
- On the YAM arm, instruction following rose from 40% to 92%.
- Long-horizon trash sorting went from 0 to 17 of 20 runs.
- Three toy assemblies scored 98, 97 and 97 out of 100.
- π0.7 (Physical Intelligence, Apr 2026). The motor model itself is built to be steered from above: it accepts language coaching, strategy metadata and subgoal images generated at run time by a small world model.
In research harnesses
- VLAs-as-Tools: a VLM agent calls specialized VLA tools for bounded subtasks and replans when they report progress events. On three real Franka tasks, success rose from 16.7% to 58.3% under matched data and compute.
- RoboHarness: wraps VLAs, RL policies and task-and-motion planners as skills. It learns where each policy works from execution memory, and steers the robot into the next policy's familiar states before handing over.
- VoLo (NVIDIA): the VLM can interrupt and redirect a VLA or world action model mid-run, because the physical world keeps moving while the model reasons.
- EMERGE-Policy: splits the agent into sub-agents for perception, monitoring, verification and memory, with branch-based recovery.
What decides whether it works. A systematic study of hierarchical VLA agents (Hu, Shridhar, Shah, Tan, Xie) found that model choice and interface design jointly shape performance. A carefully designed hierarchy beat both a flat VLA and a naive hierarchy. Three design questions recur:
- The interface. What the reasoner hands down is moving from text subgoals to pictures: subgoal images, grasp marks, traces.
- Switching. When control passes between layers: on a timer, on an event, or by interruption.
- Handoffs. Each motor policy only works in states its training data covered. Chaining policies fails at the seams unless the harness manages the transition.
Strengths and limits. Dexterity comes from specialized motor models; semantics and recovery come from the reasoner. But the system can only do what its motor tools can do, and nobody knows those tools' capability boundaries in advance.
2. Code as policy
Here the frontier model acts like a robotics engineer. It writes perception, planning and control code against the robot's interfaces, runs it, watches what happens and fixes it. The approach goes back to Google's Code as Policies (2022). What is new in 2026 is that coding agents can now get a robot working without a human writing the code.
Key evidence
- CaP-X (Fu, Goldberg, Jim Fan and others, 2026) benchmarks 12 frontier models on robot manipulation through generated code.
- Performance depends heavily on the abstractions a human designer provides, and drops as they are removed.
- Test-time compute closes much of the gap even with low-level primitives: multi-turn interaction, execution feedback, visual differencing, automatic skill synthesis.
- RL with verifiable rewards (CaP-RL) improves success and transfers from simulation to real robots with little loss.
- Vals Robo-bench (Oct 2026) runs each model in its vendor's coding agent (Codex, Claude Code). The agent gets only a robot's datasheet, kinematic model and sensor specs, and writes everything else itself.
- Platforms: a Franka arm with 13 tasks, and a Unitree G1 humanoid with 11 tasks and no walking or balance controller.
- Top scores: GPT-6.1 Sol 28.3%, GPT-6 Astra 23.3%, Claude Opus 5.5 14.6%.
- No model reached 2 points on the humanoid tasks.
- Common failures: declaring a task done before it was, and thinking too long while the simulated physics kept running.
- Project Fetch, Phase Two (Anthropic, Jun 2026). Claude Opus 4.7 worked a robot dog on its own: connecting to the lidar and cameras, writing control programs, detecting objects and navigating.
- It finished four tasks in 9 minutes 35 seconds. The fastest human team, aided by an older Claude, took 181 minutes.
- It wrote 1,045 lines of code against that team's 10,309.
- It still could not fetch the ball: closed-loop control during the approach and grasp failed.
Strengths and limits. Code needs no robot training data, can be read and debugged, and builds a reusable skill library. It is strongest at integration: drivers, sensors, perception, planning. It is weakest where control must react to contact every fraction of a second. That is exactly the gap learned motor models fill.
3. Constraint- and objective-mediated generation
Here the model specifies what a good motion must satisfy, and an optimizer works out the motion. The model writes 3D value maps, keypoint constraints or cost functions; a solver turns them into trajectories and re-solves as the scene changes. Wang et al. treat it as one of three ways a foundation model shapes motion, beside direct action and programs.
Key work
- ReKep (Huang, Wang, Li, Zhang, Fei-Fei; 2024). The task becomes a sequence of relational keypoint constraints: Python functions that score 3D keypoint configurations. Vision-language models synthesize the constraints automatically, and a hierarchical optimizer solves them repeatedly as a closed-loop policy running in real time.
- VoxPoser and MOKA are earlier examples that Wang et al. place in the same class.
- EmboAlign (Northwestern and Stanford, Mar 2026). It pairs this approach with a video generation model. A VLM writes constraints encoding spatial, kinematic and safety requirements; these are used to select among generated video rollouts, then to refine the robot trajectory and correct retargeting errors. It was tested on six real-robot tasks.
Strengths and limits. The optimizer delivers geometric precision and constraint satisfaction that language and code alone struggle with, and the spec is easy to inspect. The weak point is the spec itself. The Goal-VLA authors note that VLM-generated value maps, constraints and rewards are often inaccurate, because current VLMs are weak at precise spatial reasoning.
4. Frontier models in direct control
Here the general-purpose reasoning model is the policy. It looks at the cameras, emits a short chunk of motion through a tool call, looks again and repeats. There is no learned motor model and no program in between. This is the newest approach and the most contested; it only became plausible with the spatial reasoning of the late-2026 frontier models.
How it is run. The open-source Inspect Robots framework puts a frontier model in the slot where a VLA would sit. The model drives the robot through tool calls, one approver-checked motion chunk per call. Every run is clamped to the robot's limits by default, with a cap on how far each step can move.
Results so far
- Robocurve on real YAM arms (Sept 2026), 20 trials each:
- Block into bowl: GPT-6 Astra 19, Claude Fable 5.1 8, Claude Fable 5 just 1.
- Astra averaged 2.5 minutes and $0.94 per run, against 6.8 minutes and $2.12 for Fable 5.1.
- Dexterous insertion: Astra and Fable 5.1 both succeeded only twice, stalling at the same final step.
- Robocurve, six tabletop tasks (Sept 23): Claude Opus 5.5 matched Astra on average progress, about 36%, at roughly $0.90 per run. Astra fully completed five tasks; Opus 5.5 completed one.
- RoboDojo Sim (Anthropic-run, Nov 9): a simulated two-arm benchmark with 42 tasks, built to rank VLAs.
- Scores: Claude Fable 5.2 64.9%, Opus 5.5 39.4%, Gemini 4 Argon 34.2%, GPT-6 Astra 29.8%, Fable 5.1 27.6%.
- Caveats: Anthropic ran every model itself and has not said whether the figure is a score or a success rate. Its post also doesn't say whether Fable 5.2 drove the arms directly or worked through code or skill models.
The case for it. In a YC interview, Waddle Labs and Robocurve make the bitter-lesson argument: models trained on code, computer use and first-person video will beat models trained only on scarce robot data. They claim that frontier output speed is roughly doubling every month and could allow real-time control by the end of 2026. In the same interview, Waddle Labs said it compresses what the big model learns in context into reusable skills that smaller, faster models can run.
The case against it.
- Latency. Physics keeps moving while the model thinks.
- Cost. About $1 to $2 per simple pick.
- Precision. Contact-rich steps such as insertion still fail.
- Safety. In Robocurve's RoboHarm test, models rarely refused harmful commands. Across five hazardous instructions, Astra attempted 97 of 100 trials. Fable 5.1 refused 20 times, all in the task that asked it to stab a baby doll.
Hybrids: choosing the path step by step
The four paths are not exclusive, and the strongest systems mix them. Envisioning Agentic Robotics argues that the interfaces don't form a scale from easy to hard. Each brings its own priors, control burden and failure modes. Its authors recommend testing three set-ups side by side: skills only, direct end-effector control, and a hybrid where the model chooses per step.
The result they cite shows why: in one benchmark, GPT-6 Astra scored 92% with native control, fell to 61% when restricted to skills, and recovered to 85% when it could decide per skill whether to use one. Forcing a strong reasoner through a narrow interface cost more than it gained.
Beyond run time: agents that improve robots
Two activities change what a robot runs on, not how it acts in the moment, and either can sit on top of any of the four approaches. ASPIRE is self-improvement on top of code as policy, and Learning While Deploying is self-improvement on top of a VLA stack. The line between the two activities is blurry: ENPIRE generates its own rollouts while improving policies, and RoboGen builds worlds and learns skills in the same loop.
Self-improvement
Here the model's decisions outlast the episode: it makes lasting changes to the robot's policies, rewards, code or skills. Wang et al. split this into two kinds, and the second is where 2026's activity is.
- Fixed-procedure improvement. The model supplies candidates inside a pipeline humans designed. Examples include Eureka (LLM-written reward functions), DrEureka, RoboCat and RoboGen. Fleet RL on VLAs belongs here too: Learning While Deploying (AgiBot) runs offline-to-online RL on autonomous rollouts and human interventions from a robot fleet.
- Agent-directed improvement. The model also chooses the evidence, runs tests, changes the procedure or picks what to change. Of the 2,343 systems Wang et al. coded, only 17 do this, and 16 of them appeared in 2026.
- ENPIRE (NVIDIA, CMU, Berkeley and others; Jun 2026). A harness lets coding agents run the physical loop themselves: reset the scene, run a policy, verify the outcome, refine. The agents read logs, consult the literature and rewrite training code. They trained policies to 99% success on dexterous tasks such as organizing a pin box and fastening a zip tie, faster when an agent team worked across a robot fleet.
- ASPIRE (NVIDIA and others; Jun 2026). It writes and repairs code-as-policy programs from multimodal execution traces, stores validated fixes in a growing skill library, and searches over new tasks and programs. On unseen long-horizon LIBERO-Pro tasks it reached 31% success against 4% for prior methods.
This approach is still rare. Persistent improvement shows up in about one system in five each year, with no clear upward trend. What changed in 2026 is that frontier coding agents started directing the loop instead of feeding candidates into it.
Data and world generation
Here the model doesn't control the robot or change its code. It decides what the robot learns from and is tested on. Qin et al. give this two of their four domains. Data covers collection, annotation and refinement. Environment covers rebuilding scenes, generating tasks and building benchmarks.
- AutoRT (Google DeepMind, 2024). A VLM describes each scene, an LLM proposes tasks, and a written "robot constitution" filters them for safety. It directed over 20 robots across several buildings and collected 77,000 real episodes.
- RoboGen (2023–24). Runs a propose-generate-learn cycle: the agent proposes skills, builds simulation scenes for them, picks a learning method and generates the training supervision.
- V-CAGE (2026). Synthesizes simulation data agentically, in place of scripted pipelines that break when tasks fail.
- Gemini Robotics 2.5 (Nov 2026). Gemini 4 Argon turned real camera scenes into digital twins and thousands of varied practice runs. It also analyzed failure videos, proposed causes, and tested fixes in simulation and on robots.
The catch is the gap to reality. Envisioning Agentic Robotics notes that synthetic data still carries a sim-to-real gap, so generated worlds supplement real deployment data rather than replace it.
Side by side
Dexterity trades against generality: the less a system relies on learned motor models, the less robot data it needs, and the worse it handles contact.
| Approach | What the model outputs | Robot data needed | Strongest at | Weakest at | Examples |
|---|---|---|---|---|---|
| 1. Layered orchestration | Subgoals, subgoal images, grasp marks | Yes, for every motor model | Dexterous skills inside long tasks | Handoffs between policies; tasks outside the tools' range | Gemini Robotics 2.5, GR00T 2 with a reasoner, VLAs-as-Tools, RoboHarness |
| 2. Code as policy | A program over perception and control primitives | No | Integration, perception, planning, reusable skills | Fast closed-loop contact | CaP-X, Vals Robo-bench agents, Project Fetch |
| 3. Constraint- and objective-mediated | Value maps, keypoint constraints, costs | No | Geometric precision via an optimizer | Inaccurate specs from weak VLM spatial reasoning | ReKep, VoxPoser, EmboAlign |
| 4. Direct control | Motion chunks, one per tool call | No | Novel tasks with no setup | Latency, cost per action, precision, safety | Robocurve trials, Fable 5.2 on RoboDojo |
Where the lines blur, and what is still open
The approaches are starting to mix. A coding agent can call a VLA as one of its primitives. Waddle Labs distills what a frontier model learns in context into skills that smaller, faster models run. Anthropic hasn't said whether Fable 5.2's RoboDojo result came from direct control, code or skill models. Meanwhile, motor models are absorbing agent functions themselves: π0.7 takes coaching mid-task, and Physical Intelligence's MEM gives a VLA language-based memory for tasks up to about 15 minutes.
Open questions:
- Inside or outside? Will planning, memory and recovery stay in a harness around the motor model, or move into the model?
- Speed and cost. Can frontier models get fast and cheap enough for direct control of contact-rich work, or will they always need a learned layer below?
- The interface. Which language will reasoners and motor layers settle on: text, pictures (subgoal images, marks) or code?
- Evaluation. Most numbers here come from the labs that built the systems. Neutral evaluations (Robocurve, Vals, the RoboDojo leaderboard) are still small, run few trials, and disagree on setup.
- Safety at the action layer. DeepMind's ASIMOV-Jailbreak benchmark reports 99.5% jailbreak resistance for Gemini 4 Argon, against 82% for Gemini Robotics ER 2. RoboHarm suggests that frontier models in direct control mostly comply with harmful commands.
Demo videos and project pages
| Approach | Project | Where to watch |
|---|---|---|
| 1. Layered orchestration | Gemini Robotics 2.5 (DeepMind) | Launch post |
| 1. Layered orchestration | GR00T 2 with a reasoning model (NVIDIA) | Project page |
| 1. Layered orchestration | VoLo (NVIDIA) | Project page |
| 1. Layered orchestration | Hierarchical VLA agents study | Project page |
| 1. Layered orchestration | π0.7 (Physical Intelligence) | Project page |
| 2. Code as policy | Vals Robo-bench | Leaderboard and run examples |
| 3. Constraints | ReKep | Project page |
| 4. Direct control | Robocurve trials | Jay Chooi's posts |
| Beyond run time | ENPIRE (NVIDIA and others) | Project page |
| Beyond run time | ASPIRE (NVIDIA and others) | Project page |
Sources
Surveys
- Envisioning Agentic Robotics: A New Era of Robotic Systems, Grid Robotics
- A Survey of Agentic Robotics: Toward Continual Self-Improvement, Wang, Jiang, Shen, Soh
- Towards Agentic Robots: Model, Data, Environment, and Harness, Qin et al.
- Weights or Skills? A Survey of Robot-Learning Techniques, Jena et al.
- Towards Embodied Agentic AI, Salimpour et al.
Systems and results
- Gemini Robotics 2.5, Google DeepMind
- GR00T 2, NVIDIA GEAR
- π0.7 and MEM, Physical Intelligence
- What Matters in Orchestrating Robot Policies
- VLAs-as-Tools, RoboHarness, VoLo, EMERGE-Policy
- CaP-X, Vals Robo-bench, Project Fetch, Phase Two (summary)
- ReKep, EmboAlign
- Inspect Robots, Robocurve: Astra vs Fable, Robocurve: Opus 5.5 vs Astra, RoboHarm
- Claude Fable 5.2 on RoboDojo, Humanoids Daily
- Waddle Labs and Robocurve, YC interview
- ENPIRE, ASPIRE, Learning While Deploying
- AutoRT, RoboGen, V-CAGE