Gemini 4 Argon for Robotics: Google Wires Generate-Verify-Revise Into Every Layer of the Robotics Stack

Gemini 4 Argon for Robotics: Google wires "generate → verify → revise" into every layer of the robotics stack

Source: Google Developers Blog — Gemini 4 Argon for Robotics

Author: Kanishka Rao (Principal Software Engineer, Google DeepMind) · Compiled by RobotWorld · October 13, 2026 · Via @googledevs

Links: Original post · ERQA benchmark · MuJoCo · Gemini API docs

On October 13, 2026, Google published a robotics post that reads very little like a model launch. There is no new architecture in it, no loss function, no training curve. All twelve demonstrations are driven by plain-language prompts — and they ship things that actually run. Gemini 4 Argon is not positioned as a stronger robot policy; it is pitched as a general-purpose physical reasoning model spanning the entire robotics lifecycle. It writes code, builds simulators, labels data, and diagnoses its own failures. Google's headline number: 87% on ERQA using pure reasoning, which the company says outperforms every other frontier model.

The claim worth extracting: every demo is "generate → verify → revise", not "perceive → act"

Laid side by side, the twelve examples share one skeleton. The model first generates something executable — a MuJoCo scene, a timestamped script for a video world model, a multi-granularity annotation hierarchy, a WebAssembly reimplementation of a legged-locomotion paper. Then it checks that artifact with something that does not depend on how it was produced. Then it revises. Crucially, Google writes verification into the prompt rather than leaving it to taste:

• Spot stepping on a pedal bin: a 2-agent verification swarm — a foot-verifier checking pedal centering and a hand-verifier checking 3D hand-in-bin alignment — and nothing is released until both pass.
• Real2Sim from robot cameras: rendered views from head_left, left_wrist and right_wrist must line up with reality (visual match), and simulated fingertip contact forces must match the logged tactile_force in timing, magnitude and direction (physical match).
• Sketch to humanoid throw: not "produce a nice animation" — knock down 6 of 6 boxes in closed-loop physics, with pelvis drift under 3 cm.
• Paper reproduction: a headless Chromium + Playwright verification loop asserting 0 console errors and non-zero task progress over 300+ frames.
• Data labeling: a dedicated quality_control_and_reweighting layer that downweights non-progressing retry loops to 0.15x–0.25x for behavior cloning.

The most revealing passage in the whole post is Real2Sim's "No sim cheating" clause. After t = 0 it forbids modifying MjModel parameters, applying external forces, using welds or equality constraints, setting or rolling back object qpos/qvel, disabling collisions — and explicitly forbids "reporting contact forces that don't come from the MuJoCo solver (for example, copying the logged tactile readings)." You do not add that line speculatively. A model that both builds the rig and grades the result has a very short path to writing the answers on its own exam paper; Google's response is not to avoid the situation but to pin it down clause by clause, each with a machine-checkable acceptance test.

Holding the numbers sideways: one hard metric, twelve claims

The single result that invites cross-model comparison is ERQA 87%, which Google frames as evidence of a step change in physical understanding, code generation and visual-semantic reasoning. Everything else in the post is single-point, self-reported, and missing control details. The 56% → 75% success figure names no task set, no number of rollouts, no real-world retry count. The SO-101 iterations give three successful timings and no failure rate. None of this makes the results false; it makes them declared capability rather than established reliability.

1. Robot control: three completely different paths

Spot mobile manipulation: build the digital twin, then touch the hardware

Argon controls a Boston Dynamics Spot (12-DoF legs + 6-DoF arm) learning a new skill: stepping on the foot pedal of a trash bin to drop soda cans inside. Before touching the real pedal, the model builds an articulated MuJoCo digital twin of that specific pedal bin and practices three-leg tripod balance in it.

Why it matters: the substance is not "a robot dog throws away trash," it is that the model manufactures the training environment by itself. Environment modeling is normally the expensive part of Real2Sim — a pedal bin with correct joint physics can cost an engineer half a day. Google has said elsewhere that this kind of Video-to-Sim-to-Real pipeline compresses weeks of manual simulation work into hours; shown a video of a person playing cornhole, Argon drove an Apptronik Apollo humanoid to seven consecutive successful shots in a real-world trial.

Zero-shot control: hand the VLM a coordinate ruler

A simple arm is asked to right a fallen mug and drop a crumpled napkin inside it. Argon does not write a control policy; it reasons with a visual coordinate harness plus action primitives over several turns. The wrist-camera frame it receives is overlaid with a 2 cm world-coordinate grid, a cyan crosshair at the current pinch center, cyan [ + ] brackets for jaw opening, and a green line for object long-axis orientation.

The prompt also exposes the economics. It offers three explicit call-granularity tiers: Coarse (2–4 calls), Pre-Grasp Hover Verify (4–7 calls), and Fine Visual Servoing (8–20 calls) — an admission that every VLM round trip costs real time, and that control precision and latency sit on the same dial. When status == "grasp_failed", the required move is to look_at, re-observe, and re-enter the loop.

Omni control: timestamps are the control signal

Inside the Gemini Omni World Model, Argon arranges five scattered Scrabble tiles (G, R, A, N, O) into A-R-G-O-N. There is no trajectory and no inverse kinematics. What the model writes is timestamped action prompts ([MM:SS.mmm], wrapped in <omni_prompt>), then inspects intermediate rollout keyframes and revises its own prompt. The published result is a 33-step steered rollout.

2. Real2Sim: moving the real world into MuJoCo

Robot view to simulation: the hardest constraints in the post

Input is a real teleoperation episode; output is a MuJoCo scene tuned against two verification objectives: head_left, left_wrist and right_wrist renders must line up with real observations, and simulated contact force/torque on each Sharpa fingertip must match the logged tactile_force in timing, magnitude and direction.

The tuning budget is tight. Only static assets and their initial poses may change, plus offline-planned commands only in frames where the real fingertips are near an object, staying within 0.55 rad for arm joints and 0.65 rad for hand joints of the logged trajectory; everything else replays unchanged.

Human view to simulation: a 500 Hz fitting stress test

Input is an egocentric human manipulation video; output must be physically solvable. Two details carry the weight: crude bounding boxes are replaced with compound convex-decomposed meshes so concave containers actually support interior placement, and human wrist and finger keypoints are retargeted onto a 76-DoF bimanual humanoid (7-DoF arms with 22-DoF five-fingered hands) and stepped at 500 Hz (dt = 0.002s) with zero kinematic weld constraints.

Sketch to simulation: a photograph of a napkin becomes GPU physics

Photograph a rough pen-and-paper sketch — an Apollo 2 humanoid throwing a ball along a parabolic arc to topple a 3-2-1 stack of boxes — and Argon builds a GPU-accelerated mujoco_warp scene, synthesizes a 76-DoF throw (50 Hz, 140 steps, 2.80 s, across four phases: stance and five-finger power-grasp closure, torso/shoulder wind-up with ankle-hip center-of-mass compensation, forward whipping acceleration, and synchronized 22-DoF finger opening at peak hand velocity), and verifies 6/6 knockdown with pelvis drift under 3 cm before exporting a Blender 4.5 Cycles render.

3. Physical understanding: turning observation into trainable signal

Multi-granularity hindsight labeling: quality control, not just labels

Given overhead video of a bimanual ALOHA 2 folding a square sheet into an origami fox over 136 seconds, Argon produces four time-aligned levels: G1 the overall goal as one imperative sentence, G2 six contiguous semantic subtasks (naming which arm anchors and which folds), G3 seventeen contact-level atomic primitives of 3–15 seconds each, and quality_control_and_reweighting.

This layer is where the money is. Most robot datasets fail not because they lack labels but because failed recovery attempts sit in the training set at equal weight to clean successes. Having the model identify pauses, unstable grasps and fumbles, and mark those spans as flat-progress, automates the cleaning job that used to belong to humans.

Find the odd ball: a vision-only solver for the 12-ball puzzle

Argon builds the rig first — two 7-DoF Franka FR3 arms, twelve visually identical pool balls (eleven standard 150 g, one odd at 270 g or 30 g), and an articulated Roberval two-pan balance scale whose Gold and Teal pans are held horizontal by mjEQ_JOINT parallelogram equality constraints, plus Red (heavy) and Blue (light) submission trays. It then writes a solver restricted to stereo RGB and proprioception (add_privileged_task_observations=False): segment and triangulate, read tilt from stereo vertical pixel disparity (+1 left heavier, -1 right heavier, 0 balanced), rotate gripper wrist yaw by 90 degrees to clear the rims.

A general value function: video becomes a curve with slopes

Argon is also used as a general value function. Given a 60-second bimanual ring-sorting episode from a human UMI dataset, it inspects synchronized head, left-gripper and right-gripper feeds around contact transitions and emits dense value / task-progress predictions, decomposing the trajectory into 28 segments labeled positive, neutral or negative slope.

4. Research and self-improvement: one photograph to 4,500 episodes

Action improvement via simulation: the only before-and-after in the post

Starting from a single overhead RGB photo of a real tabletop, Argon builds a calibrated MuJoCo twin, defines new tasks, synthesizes a closed-loop trajectory generator, and collects 4,500+ domain-randomized episodes — all verified at reward == 1.0 in physics — lifting real-world success rate from 56% to 75% and cutting completion time from 35 s to 24 s.

This one deserves special attention because it is the only example carrying a complete input → output loop: a photograph in, thousands of verified episodes out, measurable improvement on real hardware at the end. If it reproduces in other labs, it is the commercially most valuable paragraph in the post — Google's draft answer to whether robot data scarcity can be broken with photographs times simulation.

SO-101 self-improvement: 58.9 s to 17.4 s in three rounds

On a simple 6-DoF SO-101 arm, Argon improves speed and placement accuracy by trial and self-reflection: iteration 1 at 58.9 s, iteration 2 at 22.9 s (grazing the box rim on the drop), iteration 3 at 17.4 s with a dead-center drop. The procedure is staged: measure objects and dry-run a plan with no hardware motion; hover and use the wrist camera to confirm that arm and vision agree, recording both camera feeds; then execute autonomously, self-diagnose from logs and footage on failure, re-check the fix in dry run, and once successful make it at least twice faster within safety rule R5.

One-prompt paper reproductions: five landmarks running in your browser

One prompt per paper. Argon reads the manuscript and any released checkpoints, then ports the physics and closed-loop controller into a self-contained MuJoCo WebAssembly browser lab — DeepLoco's seven-network hierarchical locomotion, HUSKY's 50 Hz PPO actors, Whole-Body MPC's Web Worker iLQR — matching each paper's exact physics timestep, actuator gains (kp/kv), torque limits and kinematic constraints in MuJoCo XML, with real inference running in JavaScript at the paper's exact control rates.

The numbers, in one place

Area	Metric	What it actually means
Embodied reasoning	ERQA 87%	Pure reasoning; Google says ahead of all frontier models
Spot	12-DoF legs + 6-DoF arm	Boston Dynamics Spot
Zero-shot control	2–4 / 4–7 / 8–20 calls	Coarse / pre-grasp hover verify / fine visual servoing
Real2Sim visual	3 cameras aligned	head_left, left_wrist, right_wrist
Real2Sim physical	±0.55 rad arm / ±0.65 rad hand	Tuning bound against the logged teleop trajectory
Real2Sim anti-cheat	No MjModel edits / external forces / welds / qpos rollback / faked contacts	All effective after t = 0
Human to sim	500 Hz (dt = 0.002s), zero welds	Human keypoints onto a 76-DoF humanoid
Sketch throw	50 Hz / 140 steps / 2.80 s / 6 of 6 / pelvis drift < 3 cm	Closed-loop physics acceptance criteria
Hindsight labels	4 levels: 1 goal / 6 subtasks / 17 primitives (3–15 s)	Failed spans downweighted to 0.15x–0.25x for BC
Odd ball	11 × 150 g plus one 270 g or 30 g	Solved within three weighings for reward 1.00
Value function	28 segments (positive / neutral / negative)	60-second bimanual ring-sorting episode
Sim action improvement	4,500+ episodes; 56% → 75% SR; 35 s → 24 s	One photo to a 77-task curriculum to real-hardware gains
Self-improvement	58.9 s → 22.9 s → 17.4 s	Three SO-101 rounds; round two grazed the box rim
Paper reproduction	0 console errors, 300+ frames of progress	WASM sandboxes verified with Playwright

Reading it carefully: what is proven and what is not

The post is dense, but two claims need separating: "Argon can produce these demonstrations" versus "Argon can do these things reliably on your floor."

• No independent verification. ERQA 87% is the only public benchmark result, with no evaluation methodology published; every other number comes from Google's own robots in Google's own scenes.
• No latency, no failure rate, no operating cost. The question that dominates real closed-loop deployment — how long does one VLM round trip take — is not answered. The three call-granularity tiers are a hint that round trips are expensive, but no milliseconds are given, and SO-101 reports only successful rounds.
• The demos are curated. Twelve examples, three per area, is not an evaluation covering a task space. Performance across different robots, grippers, and lighting is unaddressed.
• The anti-cheat clause is itself evidence. When you have to forbid copying logged tactile readings into your contact-force report, it is because the shortcut is tempting. A model that builds the rig and grades the run is a genuinely new failure mode, and Google handles it by enumerating prohibitions rather than assuming good behavior.
• Access is limited. Availability today is the paid Gemini API tier, AI Studio, and Antigravity for Ultra subscribers (model name gemini-4-argon via the Interactions API, with day-one support in the google-genai SDKs). Reported introductory pricing is $2 per million input tokens and $10 per million output tokens, doubling after November 2026 — and since token cost scales linearly with the number of closed-loop call rounds, industrial users should price that before anything else.

Getting your hands on it, and where this leaves us

The working entry points today: Google AI Studio (Ultra subscribers), the Gemini API paid tier (model gemini-4-argon through the Interactions API, day-one support in google-genai), and Google Antigravity for Ultra subscribers doing complex planning, /goal runs and multi-agent orchestration.

Google's own framing: Argon bridges coding, visual perception, physics simulation and embodied robot control, reasoning natively over multi-view video, 3D geometry, contact mechanics and proprioceptive telemetry — understanding not just what is in a scene but how objects physically interact with an agent to accomplish whole-body dexterous tasks. The company calls it a milestone on the path to physical AGI.

From where RobotWorld sits, the number to watch is not 87%. It is the pattern that repeats twelve times: once a model can build its own sandbox, write its own acceptance tests, and review footage of its own failures to assign blame, the bottleneck in robotics shifts from having enough data to being willing to let the model grade its own paper.