Gemini 4 Argon for Robotics: Google DeepMind's Physical Reasoning Model Scores 87% on ERQA

Google DeepMind announced Gemini 4 Argon, a general-purpose physical reasoning model that the lab describes as a step change in physical understanding, code generation, and visual-semantic reasoning for robotics. The headline result: on the Embodied Reasoning (ERQA) benchmark, which tests a model's ability to understand and solve physical, spatial problems in 3D environments, Argon scores 87% using pure reasoning, outperforming every other frontier model.

DeepMind frames the release as an accelerator toward physical AGI, and presents representative prompts showing Argon applied across the entire robotics lifecycle rather than to a single narrow task.

What Gemini 4 Argon is and what it is benchmarked on

Gemini 4 Argon is positioned as a general-purpose physical reasoning model, not a task-specific policy. DeepMind states it "bridges coding, visual perception, physics simulation, and embodied robot control," reasoning natively over multi-view video, 3D geometry, contact mechanics, and proprioceptive telemetry.

The model's capability claim rests on the ERQA benchmark, which DeepMind describes as testing a model's ability to understand and solve physical, spatial problems in 3D environments. Argon's reported score is 87% using pure reasoning, which DeepMind says outperforms every other frontier model.

Robot control: three demonstrated workflows

Argon is demonstrated on three distinct control workflows: real-to-sim-to-real mobile manipulation, zero-shot arm control, and closed-loop steering of a video world model.

Spot mobile manipulation with MuJoCo practice

Argon controls a Boston Dynamics Spot quadruped (12-DoF legs plus a 6-DoF arm) to learn a new skill: stepping on a foot-pedal trash bin to throw away soda cans. Argon creates an articulated MuJoCo digital twin of the foot-pedal bin to practice its moves before stepping on the physical pedal and dropping cans into the open bin.

The prompt instructs the robot to pick up two Diet Coke cans and trash them, and to verify with the front cameras that the front-right foot target is centered on the pedal before stepping down. It also specifies a "2-agent verification swarm (foot-verifier and hand-verifier)" to verify both the foot-pedal step and the 3D hand-in-bin alignment before releasing.

Zero-shot control with a visual coordinate harness

Argon controls a simple robotic arm to place a fallen mug upright and put a crumpled napkin inside it, reasoning with a visual coordinate harness and action primitives over several turns. The wrist camera image is annotated with a 2 cm world-coordinate grid, a cyan crosshair marking the current 3D pinch center, cyan brackets showing the jaw opening and closing line, and a green line showing the object's long-axis orientation.

The prompt defines a closed-loop turn workflow: inspect state via an HTTP observation endpoint, select VLM call granularity upfront (coarse 2–4 calls, pre-grasp hover verify 4–7 calls, or fine visual servoing 8–20 calls), then send motion primitives and verify visually after every turn. If the status returns grasp_failed, the model is instructed to call robot.look_at(...) to re-observe and recover closed-loop. The available primitives are exposed as code-as-policies calls such as robot.grasp, robot.place_until_contact, robot.move_by, and robot.move_until_contact.

Omni control: steering a video world model

Argon steers robots inside the Gemini Omni World Model to rearrange five scattered Scrabble tiles (G, R, A, N, O) into a clean row spelling A-R-G-O-N. Rather than specifying one static prompt, Argon steers in a closed visual loop: it writes timestamped action prompts, inspects intermediate rollout keyframes, and refines its prompts. DeepMind labels the demonstration a 33-step steered video rollout.

The steering prompt requires breaking complex motions into one simple, single-direction action at a time, keeping inactive hands retracted, explicitly stating which workspace areas become empty after an object moves, and using [MM:SS.mmm] timestamps wrapped in <omni_prompt> tags.

Real2Sim: three ways Argon builds simulation twins

Argon reconstructs physically calibrated simulation environments from three different input sources: real robot camera feeds, egocentric human video, and hand-drawn sketches.

Robot view to simulation

Given a real robot teleoperation episode, Argon builds a MuJoCo scene of the robot and reconstructed task objects, then iterates against two verification objectives: a visual match (MuJoCo renders from the head_left, left_wrist, and right_wrist cameras line up with and look like the real observations) and a physical match (simulated contact force/torque on each Sharpa fingertip matches the logged tactile force in timing, magnitude, and direction).

The prompt imposes explicit anti-cheating constraints. Task objects may move only through real MuJoCo contact with the robot hands and the environment via mj_step. After t = 0, the model may not change MjModel parameters, apply external forces or torques to objects, use welds or equality constraints, apply feedforward torques beyond joint-space PD, set or roll back object qpos/qvel, disable or exclude collisions, or report contact forces that do not come from the MuJoCo solver. Offline-planned robot commands may only be changed in frames where the real fingertips are near an object, and each command must stay within 0.55 rad for arm joints and 0.65 rad for hand joints of the logged teleop trajectory.

Human view to simulation

Given an egocentric human video of a manipulation task, Argon identifies the task-relevant objects, replaces crude bounding boxes with compound convex-decomposed meshes so concave containers support physical interior placement, and retargets the human hand trajectory onto a 76-DoF bimanual humanoid with 22-DoF five-fingered hands in MuJoCo contact physics.

The prompt specifies a 500 Hz dexterous motion-fitting stress test: retarget 3D human wrist and finger keypoints to the humanoid's 7-DoF arm and 22-DoF hand joints, step the trajectory in MuJoCo at 500 Hz (dt = 0.002s) with zero kinematic weld constraints, and verify opposing thumb-and-finger force closure, clean object lift of more than 2 cm, and stable final placement.

Sketch to simulation

A developer can photograph a rough pen-and-paper sketch — showing an Apollo 2 humanoid throwing a ball along a parabolic arc to topple a 3-2-1 stack of boxes on a table — and have Argon automatically construct the GPU-accelerated mujoco_warp scene, synthesize a balanced 76-DoF whole-body and five-finger throw trajectory, verify 6/6 target knockdown in closed-loop physics, and export a Blender 4.5 Cycles render.

The prompt specifies a 50 Hz whole-body throwing trajectory of 140 steps over 2.80 seconds across four phases: stable 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 five-finger opening at peak hand velocity. Verification requires the humanoid to maintain upright balance with less than 3 cm pelvis drift and to knock down all 6 target boxes.

Physical understanding: labeling, puzzle solving, and value functions

Argon is demonstrated on three physical-understanding tasks: agentic multimodal hindsight labeling, a vision-only closed-loop puzzle solver, and dense value function estimation.

Hindsight labeling and data quality control

Given an overhead video of a bimanual ALOHA 2 robot folding a square sheet of paper into an origami fox over 136 seconds, Argon produces a time-aligned 4-level hindsight annotation hierarchy: Episode Goal (G1), 6 contiguous Semantic Subtasks (G2), 17 contact-level Atomic Primitives (G3), and automated Quality Control reweighting that holds task progress flat during fumbles and retries.

Argon can identify poor manipulation segments such as pauses, unstable grasps, and fumbles. The prompt instructs the model to hold task_progress_pct flat during non-progressing slip and delamination retry loops and to downweight them by 0.15x to 0.25x for Behavior Cloning.

Find the odd ball: a vision-only closed-loop solver

To recreate the classic 12-ball balance scale puzzle with robots, Argon builds a bimanual Franka FR3 MuJoCo environment with 12 visually identical pool balls — 11 standard at 150 g and one odd ball at either 270 g or 30 g — plus an articulated Roberval two-pan balance scale with parallelogram equality constraints (mjEQ_joint) so the pans stay horizontal.

Argon then writes a vision-only closed-loop solver that relies strictly on stereo RGB camera inputs and robot proprioception, with privileged task observations disabled. The solver segments the balls, pans, and trays in both stereo views, triangulates their 3D coordinates, visually reads the balance scale tilt from stereo vertical pixel disparity (+1 = left heavier, -1 = right heavier, 0 = balanced), and isolates the odd ball into the Heavy (Red) or Light (Blue) tray within 3 weighings. The environment rewards 1.00 for isolating the true odd ball in the correct tray within three weighings.

Value function estimation

Argon is described as a general value function for robotics tasks. Evaluated on a 60-second bimanual ring-sorting episode from a human UMI dataset, Argon iteratively inspects synchronized head, left-gripper, and right-gripper camera feeds around contact transitions to generate dense value function and task progress predictions, decomposing the trajectory into 28 segments with positive, neutral, and negative progress slopes.

Research and self-improvement

Argon is also demonstrated generating training data and improving its own hardware execution.

Action improvement via simulation

Starting from a single RGB photo of a real tabletop, Argon autonomously builds a calibrated MuJoCo simulation twin, defines new tasks, and synthesizes a closed-loop motion generator to collect 4,500+ domain-randomized episodes in simulation. DeepMind reports this boosts real-world physical robot success rate from 56% to 75% and reduces completion time from 35s to 24s.

The prompt covers a bimanual workspace with two 7-DoF Franka FR3 arms with parallel-jaw grippers and 4 RGB cameras, and asks for procedural 3D meshes and compound MuJoCo collision primitives for all 9 party props, a 77-task single-arm and bimanual curriculum, and a closed-loop IK trajectory generator across ±10 cm pose randomization.

Self-improvement for visual pick and place

On a simple 6-DoF arm, Argon iteratively self-improves both execution speed and placement accuracy on a pick and place task via trial and self-reflection. DeepMind reports three iterations: Iteration 1 at 58.9s, Iteration 2 at 22.9s (which grazed the box rim on drop), and Iteration 3 at 17.4s with a dead-center drop.

The workflow is staged: Stage 1 measures objects and produces a dry-run plan with no hardware motion; Stage 2 places the gripper above the target without touching it and verifies with the wrist camera that arm and vision agree; Stage 3 executes autonomously, self-diagnoses failures by reviewing its own logs and wrist/overhead footage, and optimizes to be at least 2× faster within safety limits.

One-prompt robotics paper reproductions in MuJoCo WebAssembly

With a single prompt per paper, Argon reads a robotics control manuscript and any released checkpoints, ports the physics model and closed-loop controller into self-contained MuJoCo WebAssembly browser labs, and verifies them in headless Chromium. DeepMind cites examples including 7-network hierarchical locomotion in DeepLoco, 50 Hz PPO actors in HUSKY, and Web Worker iLQR in Whole-Body MPC.

The demonstration shows five landmark legged and humanoid papers running live in the browser: Robotic Soccer OP3 1v1, DeepLoco, Massively Parallel Deep RL ANYmal C, Whole-Body MPC Go2, and HUSKY G1 Skateboarding — drawn from 68 interactive browser sandboxes reproduced by Argon. The prompt requires matching the paper's exact physics timestep, actuator gains (kp/kv), torque limits, and kinematic constraints in MuJoCo XML, running real neural inference or Web Worker iLQR in JavaScript at the paper's exact control rates, and running a headless Chromium (Playwright) verification loop asserting zero console errors and non-zero task progress over 300+ frames.

What DeepMind says this means

DeepMind's stated conclusion is that Argon "understands not just what objects are in a scene, but how they physically interact with agents to accomplish whole-body dexterous tasks." The lab calls Gemini 4 Argon an important milestone accelerating the path toward physical AGI, with the goal of enabling robotics that can work alongside humans to solve complex challenges.

Availability and access

Gemini 4 Argon is available across Google's developer platforms as of the announcement:

Google AI Studio: available to Google AI Ultra subscribers.
Gemini API: available with the paid tier of the Gemini API in AI Studio. The model identifier is gemini-4-argon, used in the Interactions API with day-one support across the google-genai SDKs.
Google Antigravity: available for Google AI Ultra subscribers. Select Gemini 4 Argon (gemini-4-argon) as the active model for complex planning, /goal runs, and multi-agent orchestration.