Gemini 4 Argon for Robotics: 87% on ERQA, Spot in MuJoCo, and Sim Data That Lifted Success 56% to 75%

Google has published a robotics guide for Gemini 4 Argon, and the headline number is 87% on the Embodied Reasoning (ERQA) benchmark, which Google says beats every other frontier model using pure reasoning. The post, written by Kanishka Rao and dated October 13, 2026, goes beyond the score: it shows Argon controlling a Boston Dynamics Spot after practicing in a simulated twin, building simulation scenes from a hand-drawn sketch, labeling robot video, and generating simulation data that raised a real robot's success rate from 56% to 75%. This post summarizes what Google shows, which numbers are checkable, and what is still a vendor claim.

If you missed the model itself, start with our Gemini 4 Argon launch coverage and the four-way comparison with Opus 5.5, Grok 4.7 and GPT-6 Astra. For the previous robotics generation, see Gemini Robotics 2.

Quick reference

How does Argon score on ERQA?

Image: Google

Google's chart (tool off, N=400, higher is better) shows:

ERQA tests a model's ability to understand and solve physical, spatial problems in 3D environments, answered as questions rather than by moving a robot. Two cautions. First, the numbers are Google's own and the benchmark is associated with Google's robotics research, so independent replication matters. Second, the gap to the second-place model is 4.7 points on 400 questions, which is meaningful but not enormous. A benchmark of question answering also does not measure whether a physical robot succeeds, which is why the demonstrations below matter more than the bar chart.

What can Argon do with a robot?

Spot, practicing in a digital twin

Video: Google

In the first demo Argon controls a Boston Dynamics Spot (12-DoF legs and a 6-DoF arm) to learn a new skill: stepping on a foot-pedal trash bin to throw away soda cans. Before touching the physical pedal, Argon builds an articulated MuJoCo digital twin of the bin and practices a three-leg tripod balance there. The prompt asks for a "2-agent verification swarm" (a foot-verifier and a hand-verifier) to check the foot placement and hand alignment before releasing.

The interesting pattern is real-to-sim-to-real: the model uses simulation as a scratchpad for a risky motion, then verifies with cameras before acting.

Zero-shot arm control with a visual coordinate harness

A simple robot arm must stand a fallen mug upright and put a crumpled napkin inside. Argon works over several turns using a calibrated wrist-camera image with a drawn 2 cm grid and "code-as-policies" primitives such as look_at, grasp, place_until_contact and move_by, sent to a local HTTP endpoint. The prompt tells the model to emit one sentence of observation and then a single curl command per turn.

This is a useful template if you build with a camera-equipped arm: annotate the image with coordinates, expose a small set of verified primitives, and keep the loop closed.

Steering a video world model

Argon also steers Google's Gemini Omni world model to rearrange five Scrabble tiles into the word ARGON. Rather than one static prompt, it writes timestamped action prompts, inspects keyframes from each rollout, and refines, over a 33-step steered video rollout.

What is Real2Sim and why does it matter?

A block crossing from a dotted tray into a solid tray, representing a robot task moving from simulation to the real world

Robot learning is limited by real-world data. A good simulation twin lets you generate unlimited practice, but building the twin is slow. Google shows Argon doing the building from three kinds of input:

1. Robot view to simulation. From a real teleoperation episode, Argon builds a MuJoCo scene and tunes object assets so renders from three cameras match the real footage, and simulated fingertip contact forces match logged tactile readings in timing, magnitude and direction. The prompt forbids "sim cheating": no external forces, no setting object positions after the start, no copying logged readings.
2. Human view to simulation. From an egocentric human video, Argon replaces crude bounding boxes with convex-decomposed meshes for containers and retargets the human hand trajectory onto a 76-DoF bimanual humanoid with 22-DoF hands, stepped at 500 Hz.
3. Sketch to simulation. From a photographed pen-and-paper sketch of a humanoid throwing a ball at a stack of boxes, Argon builds a mujoco_warp scene, synthesizes a 140-step whole-body throw, checks it knocks down all 6 boxes in closed-loop physics, and exports a Blender render.

The demos are prompts plus videos, so a reader can see the instructions. What we cannot see is the failure rate: Google shows representative successes.

What about physical understanding?

Argon is also shown as a labeling and judging model for robot data.

• Hindsight labeling. Given a 136-second ALOHA 2 video of a robot folding an origami fox, Argon produces a four-level annotation: an episode goal, 6 semantic subtasks, 17 contact-level primitives, and quality-control reweighting that holds task progress flat during fumbles and retries so they are downweighted for behavior cloning.
• Find the odd ball. Argon builds a bimanual Franka FR3 environment with 12 identical pool balls and a balance scale, then writes a vision-only solver that finds the heavier or lighter ball within three weighings.
• Value function. On a 60-second bimanual ring-sorting episode from a human UMI dataset, Argon predicts dense task progress and splits the video into 28 segments with positive, neutral and negative progress.

Data quality is the quiet bottleneck in robot learning, so a model that can flag fumbles and produce consistent labels is practically valuable even if it never drives a robot.

The strongest claim: simulation data improved a real robot

Under "research and self-improvement", Google says that starting from a single RGB photo of a real tabletop, Argon built a calibrated MuJoCo twin, defined new tasks, and wrote a closed-loop motion generator that collected more than 4,500 domain-randomized episodes. Training a generalist vision-language-action (VLA) model with that data reportedly improved real-world success rate from 56% to 75% and cut completion time from 35s to 24s.

Google's separate general-availability announcement for Argon adds a second example: in an internal test, Argon watched a raw video of a human playing cornhole, built the simulation code, and when transferred to Apptronik's Apollo humanoid the robot sank seven consecutive shots in a real-world trial. Google calls this a "Video-to-Sim-to-Real" pipeline.

What is verified: the numbers are in Google's post with a video. What is not: the task list, number of trials, variance, and whether the baseline VLA was tuned. It is one robot setup with party-prop manipulation. Treat it as a good proof of concept.

How to try the pattern yourself

You do not need a Spot to learn from this post. The simulation-only prompts can be adapted in an afternoon.

1. Install the physics engine. MuJoCo is open source and has Python bindings. Start with a single articulated object such as a hinged bin lid.
2. Give the model a verification contract. Copy the rules from Google's Real2Sim prompt: what may be tuned before the simulation starts, what may not be touched after, and what counts as a pass (for example, an object lifted more than 2 cm and placed stably).
3. Ask for an interactive report. Google's prompt asks for an HTML session viewer with a synced timeline and real-versus-simulated views. A visual report makes it far easier to catch a model that has quietly cheated.
4. Keep the loop closed. After each action, feed back an annotated image or state dump, and let the model choose between coarse and fine control, as the mug prompt does with its two-to-twenty call options.
5. Log failures. Record every failed episode. The hindsight-labeling demo shows why: fumbles and retries are useful data once they are labeled and downweighted.

Treat any code the model writes for real hardware as untrusted until it has run in simulation and been reviewed by a person. Joint limits, speed caps and contact-force limits should live outside the prompt, in the controller.

Where this sits in the Gemini line

Argon is a general model, not a dedicated robotics policy. That is the difference from the earlier robotics-specific releases: Gemini Robotics 2 targeted whole-body control directly, while this post shows a general reasoning model acting as planner, simulation builder, labeler and judge around a robot. The two approaches are complementary. A specialized policy runs fast on the robot; a general model such as Argon can build the practice environments and label the data that train it.

What this means for what you build

• Use the model as a simulation engineer. The most reusable idea is asking a coding-strong multimodal model to build and verify a simulation, including explicit rules against cheating. Our coverage of NVIDIA Cosmos 3 shows the open-world-model side of the same trend.
• Constrain the action space. The mug demo works because the model emits calls to a small set of safe primitives.
• Verify before you act. Both the Spot and ball-puzzle demos add a verification step, a pattern worth copying for any agent that touches the physical world.
• Compare with humanoid platforms. Figure's approach is covered in our Helix 02 post.
• Mind safety. Letting a general model write control code for hardware needs hard limits; see the speed, joint and force limits implicit in the primitives above.

Caveats

• Vendor-published demos and benchmark; no independent evaluation is cited.
• ERQA is question answering, not control success.
• Demonstrations are curated; failure cases are not shown.
• Pricing, rate limits and robotics-specific access for Argon are not covered in this post; check Google's documentation.

What we are watching next

• Independent ERQA and robot-control evaluations of Argon.
• Whether Google open-sources the MuJoCo skills used in the demos.
• How Argon compares with specialized robotics models on real hardware.
• Pricing and availability, which our Argon launch post tracks.

Related reading

• Gemini 4 Argon launch: benchmarks and pricing
• Gemini 4 Argon vs Opus 5.5 vs Grok 4.7 vs GPT-6 Astra
• Gemini Robotics 2: whole-body VLA
• NVIDIA Cosmos 3 physical AI world model
• Figure Helix 02
• Gemma 4 on an open duck mini robot

Details are accurate as of October 13, 2026. All Argon figures come from Google's own post; we will update this page when independent results appear.