Back to Explore
NewsVibeFix editorialUpdated Nov 21, 2026

96% on a Real Factory Line: Gemini Robotics 2.5 Puts a Humanoid to Work

On Nov 10, 2026, Google DeepMind released Gemini Robotics 2.5, its most capable vision-language-action model to date. Tested on 200+ tasks, it helped Apptronik's Apollo 2 humanoid sort automotive parts on live Mercedes-Benz lines with a 96% success rate. This article unpacks what that 96% actually means — and what it does not.

Apptronik's Apollo humanoid robot in an official studio portrait

On November 10, 2026, Google DeepMind released Gemini Robotics 2.5, calling it its most capable vision-language-action model to date. Two numbers in the announcement stand out: the model was tested across more than 200 distinct tasks, and in a real automotive-factory pilot, Apptronik's Apollo 2 humanoid sorted automotive parts with a 96% success rate. This is one of the rare robotics results this year that comes from a production line rather than a laboratory.

But this article starts with a question worth answering first: what does 96% actually mean? Is a production line ready to be handed to robots, or is this a milestone number under one pilot configuration? DeepMind's own announcement is restrained — the pilot is a pilot, with no claim of deployment, no price, no public API, and no open weights. This piece follows the announcement itself: what the model is, what the 200 tasks tested, what the Mercedes-Benz pilot actually did, what was added on safety, and — for ordinary developers and founders — how far this is from something you can use.

First, the terms: what a VLA is, and what ER is

Gemini Robotics 2.5 is a VLA model — a vision-language-action model. It works like this: it watches what a camera sees, understands an instruction given in natural language, and turns that understanding into concrete movements of a robot's arms and fingers. Older robots mostly ran fixed programs: engineers pre-scripted each motion, and a different part or a different position meant re-tuning. The VLA approach is the reverse: the model looks, understands, and decides how to act on its own, with a chance to adapt on the spot to something it has never seen.

DeepMind's product shape this generation is two models working as a pair. Gemini Robotics 2.5 is the "actions model," controlling how the hands and arms move; Gemini Robotics ER is the "embodied reasoning" model, tracking multi-step workflows — what step we are on, what to pick up next, whether the order is right. In the Mercedes-Benz pilot, that was exactly the split: ER watched the state of the whole sorting workflow, while 2.5 controlled the hands that grabbed and placed. This division is worth remembering, because it makes a point: getting a robot to work takes more than moving well — something also has to remember the process and watch the sequence. Splitting reasoning from action is how DeepMind answers that.

The model runs on many kinds of robots, not only humanoids. The announcement names two: Apptronik's Apollo 2 humanoid, fitted with the five-finger, 22-degree-of-freedom SharpaWave hand, and the Franka Duo platform with two-fingered parallel grippers. Running on both a dexterous five-finger hand and a two-finger gripper means the model has learned "how to manipulate objects," not "how to operate one particular robot." For people building robot hardware, that matters: model and hardware are decoupled, so switching hardware does not mean retraining from scratch.

200 tasks: what was tested, and how to read the numbers

DeepMind says it evaluated Gemini Robotics 2.5 across more than 200 distinct tasks, and that the approach could scale to many more. The examples in the announcement are deliberately everyday: serving food with tongs, tying a bow on a gift box, pipetting a liquid. Together they cover three hard capabilities: using everyday tools, handling soft objects that deform, and delicately handling fragile things. This is the hardest part of robotics: tightening a bolt on a factory line can be won with precision and repetition, but tying a bow is different every time — too light and it will not hold, too heavy and it tears.

On results, the announcement says success rates rose 30% to 100% depending on the task type compared with previous baselines, while tasks were completed 20% to 30% faster. Read that range carefully. First, 30% to 100% is a span, and the announcement does not publish the per-task baseline figures, so there is no way to know which task improved by 30% and which by 100%. Second, which "previous baselines" are meant is not named. The numbers show that progress is large, but they cannot be used to compare against other labs' models head to head. That is a common pattern in vendor announcements: keep "there was progress" and "how much progress" separate when you read them.

One piece of background is worth adding: the accelerator behind this progress is Gemini 4 Argon. DeepMind says Argon's robotics research capabilities helped solve two bottlenecks — the need for massive amounts of physical data, and the need for highly efficient modeling algorithms. Argon works as a simulation engine: starting from a real camera scene, it generates thousands of varied simulated practice runs and builds a realistic digital twin; combined with real training demonstrations, that lets the robot generalize faster to new scenes and objects. Argon can also watch video footage to hypothesize why failures happen, and test the best fixes in simulation and directly on real robots. In other words, the progress in 2.5 is not only a stronger model — it is a stronger way of training models: practice thousands of times in simulation first, then verify on real hardware.

How Gemini Robotics 2.5 works: camera images and language instructions go to Gemini Robotics ER for workflow reasoning, then Gemini Robotics 2.5 drives Apollo 2's arms, with execution results feeding back to correct the plan in real time

Argon behind the scenes: thousands of practice runs in simulation first

Half the credit for 2.5's progress belongs to another model: Gemini 4 Argon. DeepMind says plainly in the announcement that Argon's robotics research capabilities helped solve the two most painful bottlenecks in training robots — physical data must be massive, and modeling algorithms must be efficient. Argon works as a simulation engine: starting from a real camera scene, it generates thousands of varied simulated practice runs and builds a realistic digital twin; combining those simulated runs with real demonstration data lets the robot generalize faster to new scenes and objects it has never seen. Collecting data on real hardware alone would make training 200 tasks unaffordable in time and cost; piling up volume in simulation first, and using real hardware only for verification and correction, changes the speed of development entirely.

Argon does more than provide extra practice. It can watch a video of a failure, hypothesize why it happened, and test competing fixes in simulation and on real robots to see which works best. That step matters: robot failures often lie not in the motion itself but in understanding the scene — mistaking a shadow for an object's edge, or a tray's reflection for a part. Running more trials alone does not fix that kind of problem; first you have to work out why it failed. Argon here plays the role of a researcher that watches footage, proposes hypotheses, and runs controlled experiments, not just a sparring partner. DeepMind calls this approach "accelerating robotics research with frontier intelligence," and 2.5 is the first report card that approach has produced.

Argon is also out in front on long-horizon safety. The announcement notes that in DeepMind's own agentic robotics evaluations, Argon currently leads on refusing unsafe tasks, resolving uncertainty, and working in proximity to humans. Those three are exactly the gates a robot must pass to move from "demo" to "daily life": a demo can script the task, but everyday tasks are always ambiguous — what if the instruction is vague, the object is in the wrong place, or someone walks past? How a model handles those questions decides whether it can be trusted around people. The inference-time safety guidance in 2.5 and ASIMOV-Jailbreak answer "don't do bad things"; Argon's three items answer "don't do the wrong thing when things are unclear." Together, they form the complete picture of robot safety.

The 96% at Mercedes-Benz: what actually happened

The pilot is the most concrete part of the release. DeepMind, Apptronik, and Mercedes-Benz ran Apollo 2 humanoid robots on active automotive production lines in Kecskemét, Hungary, and Sindelfingen, Germany, doing automotive kitting: sorting individual parts from bulk bins into organized trays in the exact order needed for each vehicle on the line. Kitting is monotonous, repetitive, physically taxing work, and getting the order wrong disrupts the whole line — the kind of job people do not want to do, but cannot afford to get wrong.

The workflow went like this: the ER model tracked the workflow and kept count of where things stood, while the 2.5 model controlled the hands and arms, reaching into supply bins, picking up metal automotive brackets, and placing them into sequencing containers, correcting for gaps as it went. The final figure was a 96% success rate. DeepMind's own wording is restrained: "this pilot shows promising progress toward widespread real-world industrial applications." That is "progress," not "ready for large-scale deployment."

The 96% figure deserves three qualifications. First, it describes "this pilot configuration," not "all tasks": the bins, the sorting order, and the part types were all fixed for the pilot, and a different line or a different batch of parts would change the number. Second, it is a success rate, not availability: a failed pick and a stopped line are two different things, and the pilot published nothing about how failures are recovered, whether a human has to step in, or how long recovery takes. Third, DeepMind's own word is "proof-of-concept," not "deployment." A proof of concept answers "does this path work"; deployment answers "can it run for three months straight without incident." Between the two lie changeover times, failure rates, maintenance costs, union negotiations, and safety certification. Reading 96% as "robots can already take over factories" overshoots; reading it as "a humanoid robot handed in a verifiable report card from a real production line for the first time" gets it right.

Safety: steering around obstacles, and refusing bad instructions

Once robots leave the lab for workshops full of people and moving vehicles, safety is the first gate. DeepMind described two layers. The first is physical safety: 2.5 uses inference-time reasoning guidance to steer around physical hazards in real time — somewhat like the safety classifiers around Gemini's text responses, except here they protect a robot's movements. The evaluation figures in the announcement: safe task completion improved by 33% around obstacles and by 43% around nearby people. Both come from DeepMind's own evaluations, but the direction is clear: the robot is not blindly following instructions; it actively avoids hazards while it works.

The second layer is jailbreak protection — stopping bad instructions. DeepMind released a new open-source benchmark, ASIMOV-Jailbreak, containing hundreds of prompts that disguise unsafe requests across dozens of scenes, designed to test whether a robot can be talked past its safety limits. One attribution needs care here: the 99.5% jailbreak-resistance figure in the announcement belongs to Gemini 4 Argon, not to Gemini Robotics 2.5 itself; the 82% it is compared against is the previous baseline, Gemini Robotics ER 2. The two numbers sit close together and are easy to mix up, but the ownership must not be mixed: Argon's score shows progress in the reasoning model, while 2.5's own jailbreak score is not separately published. The open benchmark itself is good news — other teams can now test their robots against the same questions, giving safety capability a public yardstick — but the announcement should be read with "whose score" kept straight.

Who can use it, and who cannot yet

This is the most down-to-earth section of the whole announcement: Gemini Robotics 2.5 is rolling out to DeepMind's robotics partners. The announcement publishes no price, no public API, no open weights, and no date for a wider release. Ordinary developers can neither buy it nor download it today. The partners DeepMind thanked are Agile, Apptronik, and Mercedes-Benz, and the model runs on platforms such as Apollo 2 and Franka Duo. In other words, this release is first for partners, and second a signal to the industry.

That pace matches how the robotics industry has worked for years: get the model running with a small set of hardware partners, verify it in real settings, then consider widening access. The contrast is instructive: a language model is often usable on a web page the day it launches, while a robotics model on launch day is in the hands of partners only. That slowness is not DeepMind being cautious; the feedback loop of the physical world is itself slow. Changing one line of code has to be verified on real hardware, and a mistake can damage equipment or hurt someone — it cannot ship as casually as a web page. So robotics announcements should be read on a longer timescale: today's pilot is the product of the year after next; today's open benchmark is the starting line for the whole industry's safety capability.

The hardware range is worth a paragraph of its own. What 2.5 runs on spans from a humanoid with a five-finger dexterous hand, Apptronik's Apollo 2, to a two-arm platform with two-finger grippers, the Franka Duo. That means the model has learned something more general than "one robot's instruction manual" — it has learned to manipulate objects. For hardware makers, that is good news: once model and hardware are decoupled, switching robots does not mean retraining the model from scratch. For application developers, it means the same task definition could later be reused across different hardware. The condition, of course, is that DeepMind actually opens the model to more hardware partners — today the list holds only a few names such as Agile and Apptronik, and the speed of that opening decides when this "generality" becomes real.

For developers in China, there is another practical reality: no Chinese company appears in the partner list for this frontier robotics model. There is no direct path to use it right now. But ASIMOV-Jailbreak is open source, and the technical approach — vision plus language plus action, reasoning separated from execution, simulation first and real hardware second — is public. Understanding that playbook is worth more than waiting for a model you cannot use to open up.

What it means for people building products

The most direct takeaway: if you build anything in robotics, automation, or embodied AI, this release offers an architecture worth copying. Reasoning separated from execution, a simulation engine accelerating training, and an open safety benchmark — those three together are the methodology DeepMind is really publishing. The split in particular — ER runs the process, 2.5 runs the hands — is a useful reference for any team building robot applications: do not expect one model to both remember the workflow and control the fingers. Layer the work, let each layer do its own job, and failures become easier to locate.

There is also a lesson for vibe-coding founders. Robots are becoming AI's next deployment target: we used to write web pages and apps; next we may write "skill packs" that let a robot complete a task. Among the 200 tasks DeepMind tested are everyday scenes such as serving food, tying a bow, and pipetting, alongside industrial ones such as sorting parts. Behind every task is the same loop — see, understand, act, correct — and each can be broken into data, prompts, and acceptance criteria. If component libraries are how we write web pages today, task definitions like these may be how we write robot skills tomorrow. Learning how a task is defined and evaluated matters more than learning any single model first.

Finally, back to the 96%. It is not the finish line, or even the halfway point. It is a marker: the first time a humanoid robot handed in a verifiable report card from a real production line. The report card has bright spots and a lot left unwritten — how failures recover, how long changeovers take, whether the costs work, when you can buy one. DeepMind did not invent answers for the unwritten parts, and that honesty itself is worth noting. The real significance of the November 10 release is not the number 96%, but that it moved robots from "lab demo" to "factory pilot": demos can be edited, pilots cannot. The data in a pilot is real, and so are the problems — and that is exactly what physical intelligence starting to land looks like.

Views 10Comments 0

Comments (0)

ME
0/1000
Loading comments...

Sources

Browse projectsPublish your project

Related articles

A scientist in a white coat and safety glasses examines a sample under a microscope in a bright laboratory, holding a tablet
News
Great at Assembling Molecules, Weak at Picking Drugs: OpenAI's MedChemBench Grades AI's Medicinal Chemistry

On 20 November 2026, OpenAI released MedChemBench: 99 medicinal-chemistry problems from 117 papers and patents, covering 761 molecules. GPT-6.2 Astra scores 84.5% overall — but 95.4% on assembling structures and only 50.4% on choosing compounds. The total flatters; the components tell the truth.

Industry TrendsModel UpdatesTesting & Quality
A developer with glasses types on a laptop late at night at a wooden desk, a large monitor behind showing colourful code, blurred city lights outside the window
News
Run the Middle Layers Three Times: Inkling 2 Mini Puts a 26B Coding Model on Your Laptop

On 20 November 2026, Thinking Machines Lab released Inkling 2 Mini: a 26.4B-parameter looped transformer that runs its middle 12 layers three times per token, fits in about 20GB, and runs offline on a laptop. It leads open-weights models of its size on DeepSWE and SWE-bench Verified — with the caveats printed in the same announcement.

Product LaunchModel UpdatesAI Coding