General-purpose robots have to pull off two very different jobs at once. They need to read a cluttered, full-room visual scene, hold a multi-minute plan in memory, and converse with a person — and, in the same instant, close a high-frequency control loop that keeps a balancing humanoid upright and moves a delicate hand without dropping whatever it holds. Cramming both jobs into a single end-to-end network forces uncomfortable trade-offs: the large context window you want for reasoning fights the low latency you need for torque control.
On July 28, 2026, Google DeepMind pushed directly against that trade-off with Gemini Robotics 2, followed on July 30 by Gemini Robotics ER 2. Rather than one monolithic network, the suite splits the problem across three specialized models — whole-body vision-language-action (VLA) control, high-level embodied reasoning, and on-device adaptation — each tuned to a different cadence and context size. The same modular thinking is visible across recent robotics and VLA research collected on the arXiv robotics listings and on Hugging Face Papers, where decomposed perception-planning-control stacks have become a recurring pattern. Understanding DeepMind's specific split clarifies why this architecture is gaining traction.
Gemini Robotics ER 2 is the cognitive planner of the stack. It is a vision-language model built for embodied reasoning: it ingests the live camera feed and a natural-language instruction, then decomposes a task that may run several minutes into structured sub-goals. Beyond planning, ER 2 manages dialogue with a human supervisor, interprets spatial context, and coordinates multiple robots operating in a shared workspace — deciding which sub-task gets handed to which platform.
Operating more slowly than the control layer (roughly a few times per second), ER 2 trades frequency for breadth of context. That separation matters: a reasoning model can afford to run a large context window and a careful forward pass because it is not on the critical 100 Hz balance-control path.
If ER 2 decides what to do, Gemini Robotics 2 decides how the hardware moves. As a vision-language-action (VLA) model, it drives motor control for bi-arm manipulators and full humanoid bodies, from feet to fingertips.
The model unifies dynamic balance with fine manipulation. It generates trajectories for whole-body actions like crouching, walking, and navigating cluttered spaces. For physical interaction, it controls a range of end-effectors: five-fingered, 22-degree-of-freedom (DoF) hands for delicate tasks such as tying knots, alongside two-fingered grippers for precise packing and placement.
Operating at the edge, Gemini Robotics On-Device 2 is an efficient VLA variant optimized for local execution directly on robot hardware. Its job is low-latency closed-loop control plus adjustment to hardware variation — the part of the problem most sensitive to per-robot kinematic quirks.
DeepMind reports that On-Device 2 can adapt to a new robot embodiment with only a few hours of operational data and fewer than 200 demonstration examples. That low-shot capability targets a real bottleneck in physical AI: retargeting fine control policies to new kinematics without collecting enormous demonstration datasets for every new morphology.
A physical goal requires continuous handoff across all three layers. Consider a user instructing a humanoid to clear a cluttered workspace and pack items:
Conceptual pseudocode for that loop:
class GeminiRoboticsOrchestrator:
def __init__(self, er_model, vla_model, ondevice_model, hardware):
self.er_planner = er_model # Gemini Robotics ER 2
self.vla_controller = vla_model # Gemini Robotics 2
self.ondevice_agent = ondevice_model # On-Device 2
self.robot = hardware
def execute_user_task(self, prompt: str):
visual_state = self.robot.get_camera_feed()
subtasks = self.er_planner.plan_multistep_task(prompt, visual_state)
for subtask in subtasks:
if self.er_planner.detect_human_proximity(visual_state):
if not self.er_planner.verify_collaborative_safety(subtask):
self.robot.trigger_emergency_stop()
return "Stopped: human safety boundary exceeded."
motion_plan = self.vla_controller.generate_whole_body_trajectory(
subtask=subtask,
kinematics=self.robot.get_kinematic_spec(), # e.g. 22-DoF hand + legs
current_pose=self.robot.get_joint_states(),
)
while not motion_plan.is_complete():
local_obs = self.robot.get_sensor_readings()
adjusted_cmd = self.ondevice_agent.adapt_control_step(
planned_cmd=motion_plan.next_step(),
sensor_delta=local_obs,
)
self.robot.send_motor_commands(adjusted_cmd)
This is illustrative, not a reference implementation — but it captures the core idea: each model owns a layer, and the orchestrator just passes intent down and sensor data up.
Physical environments demand explicit safety verification, so DeepMind introduced the ASIMOV-Agentic benchmark to evaluate agent behavior under physical ambiguity. It measures three capabilities:
At runtime, ER 2 enforces active safety constraints: when a human is present, it detects them in real time and can trigger an automated emergency stop. This is safety enforced deterministically at the control layer, rather than only at the prompt level — a distinction that matters when a model can actuate physical hardware.
Developers evaluating the platform should separate launch claims from public access:
The low-shot adaptation claim (under 200 demonstrations in a few hours) is notable, but independent verification across varied third-party hardware will require broader deployment. For now, the architectural pattern is more immediately actionable than the specific weights.
By separating long-horizon reasoning, whole-body motor control, and local hardware tuning into distinct models, Gemini Robotics 2 offers an actionable blueprint for building physical AI that can adapt across robot morphologies without forcing one network to do everything at once.