A robot that performs a task once proves capability; one that performs it reliably, shift after shift, creates value.
Robots can now pick previously unseen objects and follow language instructions, fold textiles and handle deformable materials, and perform contact-rich manipulation. Driven largely by policies learned from human demonstrations, Physical AI has advanced rapidly in recent years, bringing tasks that—despite their apparent simplicity—were beyond robots only a few years ago into the lab.
But a successful lab run answers only one question: can the robot do the task? Production asks a harder one: how often can it do the task, at the required speed, without human intervention? Small differences in success rate become large operational differences when a robot repeats the same task thousands of times.
Customers do not buy good-looking learning curves or polished videos; they buy successful cycles between interventions, which is why reliability is not one metric among many for Toutatis, but the final product.
Physical AI has no shortage of human demonstration data. Teleoperation, imitation learning and increasingly capable pretrained robot models can give robots strong starting behaviours from real examples. What the industry still needs is a fast, repeatable way to turn those starting behaviours into 99+% performance.
But demonstration data teaches a robot what people did—not necessarily what will maximize success, reduce cycle time or eliminate the rare failures that stop a system from running unsupervised. Reinforcement Learning is the key to converting that demonstrated capability into production-level robotics. It lets the robot improve against the actual operating metric instead of simply becoming better at imitation.
Deployment begins where the human demonstration data ends, as objects move, fabric folds differently, cables catch, friction changes and tolerances accumulate. At industrial scale, “usually works” still means “requires supervision,” which is the last-mile problem Toutatis is designed to solve.
Introducing Toutatis
Toutatis is Gobano’s RL deployment engine: an efficient learning loop that takes a robot from a human-demonstration dataset to the “Reliability” target required by the operation.
We begin with a small task-specific dataset: typically 10 to 200 initial human demonstrations, depending on the complexity of the task. From that data, we train an Imitation Learning policy using flow matching. The Imitation Learning policy gives the robot a useful starting behaviour—it can approach the object, execute the broad sequence and generate rollouts without learning everything from scratch.
In parallel, we train a task-specific world model from the same human demonstrations. It builds a compact latent representation of the scene: what is present, how the scene may change under an action, which transitions create progress and where failures tend to emerge. Toutatis combines two learning timescales: the world model periodically refreshes this representation as real-world coverage expands, while our in-house Reinforcement Learning algorithm uses it for fast policy improvement.
The RL loop optimizes the real task outcome rather than imitation alone: did the task succeed, how reliably, and at what speed? Every autonomous attempt becomes data for fast policy updates and rapid iteration during final-stage training. As those attempts expand the states, contacts and failure modes covered by the task, they also refresh the world model on a slower timescale.
The operating promise is simple: once the robotic setup and data-collection infrastructure are in place, Toutatis can move from the initial human demonstrations to a reliability-optimized controller in a few days. The robot spends that time improving against the real outcome rather than waiting for another large data-collection round. Full project timelines may also include tooling, cell integration and operational validation; the speed described here is the learning loop itself.
RL is the last mile of deployment
The recent history of generative AI offers a useful analogy. Modern generative AI models begin with pretraining, reading enormous amounts of text and code to learn what comes next; in the process, they acquire broad knowledge, useful representations and remarkable latent capabilities. Yet next-token prediction alone does not optimize how that capability is used.
Reinforcement Learning is a central part of the post-training process that turns this latent potential into behaviour people can actually use. Trainers generate candidate answers and evaluate them using verifiable outcomes, human preferences, AI feedback or explicit principles. RL then optimizes qualities that pretraining learns only indirectly: correctness, instruction following, helpfulness and safety.
DeepSeek-R1-Zero made the idea concrete: starting from a pretrained base, pure RL—without supervised reasoning examples—produced reflection, verification and long-form reasoning, outperforming strong frontier baselines including GPT-4o on demanding reasoning benchmarks. The same principle shapes frontier post-training: OpenAI trains its GPT-5.6 reasoning models with RL, while Anthropic’s Constitutional AI follows supervised learning with Reinforcement Learning from AI feedback. The recipes differ, but in both cases outcomes—not prediction alone—shape behaviour after pretraining.
Pretraining creates capability. Reinforcement Learning converts capability into performance and alignment.
Robotics & Physical AI as a whole is following the same path. Imitation learning can provide a capable initial policy, but human demonstrations do not directly optimize success rate, cycle time, recovery or intervention rate. Those are outcomes—and outcomes are where Reinforcement Learning is strongest.
From the outset, Toutatis was built around a task-specific world model for each operation, rather than relying only on embeddings inherited from the starting policy. Its representation is jointly shaped by Imitation Learning, visual reconstruction, action-conditioned dynamics prediction and reward or task-progress prediction. The resulting latent state is therefore more than a compressed imitation feature: it is built to answer the questions the RL algorithm needs to solve—what is likely to happen next, whether an action creates progress and how valuable the resulting outcome is. This compact, outcome-aware representation becomes the state space for fast policy and value learning across the entire task.
Within the learning stack, our thesis is deliberately bold: RL is necessary and sufficient for deployment. It is necessary because deployment is defined by outcomes rather than human demonstrations, and industrial customers set unforgiving acceptance thresholds for success rate, cycle time and interventions. It is sufficient because, once a capable starting policy exists, the robot can improve by acting on the real task and optimizing the real result.
Much of the industry has so far bet that scale alone will solve robotics. We believe deployment has a different shape: start with the real task, run the real robot, optimize the real metric, and iterate fast.
A practical two-timescale learning system
End-to-end visual Reinforcement Learning is expensive because every update must pass through the full vision stack. Simply freezing a generic visual encoder is faster, but a generalist representation can miss task-specific details such as fine contact states, precise geometry and subtle object configurations that are required to solve the task cleanly.
Foundational work on world models, latent-space learning and real-robot adaptation has shown that compact predictive representations can be used efficiently for downstream control. Toutatis applies this idea by learning a task-specific world model from accumulated real task data: initial human demonstrations, followed by robot experience collected throughout improvement and deployment. Its compact Scene & Context latent representation is trained with four complementary signals: multi-step flow-matching behaviour, visual reconstruction, action-conditioned dynamics prediction and reward or task-progress prediction.
The flow-matching policy objective grounds the representation in action; visual reconstruction preserves scene geometry; action-conditioned dynamics captures how the scene changes; and reward or progress prediction encodes what matters for task success. Together, these objectives produce a carefully designed latent state that captures what the robot sees, what is likely to happen next and whether an outcome advances the task.
We then freeze the visual encoder and use it to generate compressed embeddings for the collected real robot data. The RL loop treats these representations as its state space and trains compact policy and value models from real experience—not imagined transitions—without repeatedly backpropagating through the full vision model.
Toutatis uses two learning timescales. The frozen representation supports fast policy updates and rapid iteration during final-stage training, while new real-world experience periodically refreshes the world model as task coverage expands.
Reinforcement Learning therefore operates on the world model’s latent scene representation while learning from experience collected on the real robot.
Crucially, the world model is cumulative: every new rollout expands its coverage of scene configurations, contacts, transitions and failure states. As that coverage becomes denser, the latent representation becomes more precise where control decisions matter, giving each policy update a more consistent view of successful behaviour and the remaining failure modes.
Train for success rate—not only task reward.
A controller can be blocked from deployment by either its cycle time or its failure rate. A conventional RL target maximizes average task reward, which typically blends completion speed and task success. This is useful for improving capability and cycle time, but the average can rise while rare failures remain. Toutatis includes a dedicated reliability optimization mode developed specifically to close this gap.
In “Reliability” mode, training explicitly prioritizes repeated successful completion until the controller reaches the required acceptance threshold. “Performance” mode then rewards earlier completion while protecting that reliability level. These are different training objectives—not merely different ways of measuring the same controller.
The sequence follows the customer’s acceptance criteria: first make the task reliable, then reduce cycle time without sacrificing that reliability. Behaviour that already works stays anchored, while unresolved failures remain visible instead of being diluted by routine successes. Toutatis therefore optimizes the outcome production ultimately cares about: successful cycles between interventions.
The same targets remain available as operating conditions evolve. New robot experience re-enters the fast RL loop immediately; broader changes in task coverage refresh the world model on the slower timescale.
Results in simulation and on real setups
We use controlled simulation benchmarks to isolate the learning algorithm, then real setups to test what ultimately matters: whether the full system can survive physical variation and meet an operational target. The two forms of evidence answer different questions and should not be conflated.
Robomimic Simulation Benchmark
We first evaluate our system on the classic Robomimic benchmark suite. For both tasks, we start from human demonstrations, learn the task representation, and run our in-house Reinforcement Learning algorithm on the resulting embeddings.
Before RL starts, reconstruction gives us a simple, interpretable probe of the compact world-model representation. The first row shows the original demonstrations from the two training cameras; the second shows what the world model reconstructs after compressing that scene into its latent state. Reconstruction is not the representation itself, nor a controller result, but it shows which geometry and task context survive compression.
As these videos show, the reconstructions remain remarkably close to the original observations. Despite its compact size, the world model’s latent space preserves the scene geometry, object state and task context needed to reconstruct the scene. This is an interpretable probe of the learned representation—not a policy rollout.
We then freeze this task-specific representation and run our in-house Reinforcement Learning algorithm on its compressed embeddings. The evidence below pairs inspectable final evaluations with convergence in the critical 90–100% region, where the remaining failures determine whether a controller is production-ready.
Each reel covers 1,000 rollouts. The first five and final five run in real time; the middle 990 are shown at 10× speed without pauses. A persistent counter reports successes and failures, and both observations used by the controller remain visible throughout.
Real-setup benchmarks
Simulation provides a controlled environment for iterating on the learning algorithm. But the decisive test is whether it works on a physical setup, using only real data. Here, we present results from three R&D benchmarks, each designed to expose a different real-world deployment challenge:
- Ball Picking: a simple single-arm picking benchmark with limited initial data.
- Towel Folding: a dual-arm benchmark for folding a towel from varied flat configurations.
- Zip-tie Insertion: a dual-arm benchmark for handling and precise insertion.
For each task, we first inspect what the world model retains from the scene, then measure how the RL controller improves through real-world experience.
Reconstruction reveals how much of the original scene survives compression into the task-specific latent space—including geometry, object state and task context. It is a probe of the world model, not a controller result.
The same real-data loop drives all three controllers. Ball picking reached 108/108, towel folding reached 99/100, and zip-tie insertion—the most precision-sensitive task shown here—reached 31/31 despite its tight alignment tolerances.
The progression curves track each base IL policy through the RL process to 99+% success.
Starting from only 11 human demonstrations, the initial IL rollout phase achieved 24/100 successes. Across 854 real-world rollouts, repeated rollout collection and RL training then reached evaluations of 101/107, 121/123 and 108/108.
Starting from 135 human demonstrations, the controller worked well on easy cases, but the initial collection covered too narrow a range of configurations and omitted harder task modes. RL can robustify a capable policy, but it cannot recover a part of the task that the data never exposes. We therefore collected 215 additional demonstrations around those difficult cases during the improvement cycle, which spanned 2,633 real-world rollouts. The final evaluation reached 99/100.
Starting from 107 human demonstrations, seven milestone controllers were tested across 177 controlled autonomous evaluations while the system learned from 3,375 insertion-focused real-world rollouts. The final controller completed all 31 trials in its evaluation batch.
Small models, tight loops and low compute
Toutatis is designed to start from small, task-specific datasets rather than requiring large-scale robot pretraining. The real-world results in this article begin with 11 human demonstrations for Ball Picking, 107 for Zip-tie Insertion and 135 for Towel Folding. Autonomous rollouts then densify coverage over a few days of robot time and improve the success rate. When the initial dataset leaves out a behaviour or part of the operating space, targeted human demonstrations are collected to fill the gap.
Freezing the task-specific encoder allows us to cache visual embeddings instead of recomputing them during every RL update. On the same benchmark, this made policy training approximately 10× faster than our equivalent end-to-end visual RL setup.
Separately, the RL policy and value networks themselves are deliberately compact. We trained them on a gaming PC—and, for simpler tasks, even on a laptop. Using modern optimization techniques, the deployed policies ran locally on a gaming laptop, with inference taking approximately 3 milliseconds per control step for Ball Picking and around 10 milliseconds for Towel Folding. Both leave most of the control budget available for sensing, communication and feedback, while reducing exposure to the inference-delay problems of action-chunked policies, including pauses and discontinuities at chunk boundaries.
This compactness is intentional and is itself an important result: reliable Physical AI does not always require a massive model or remote compute cluster, especially for repetitive tasks with a naturally well-defined operating scope.
Beyond these compact controllers, the same recipe opens a path to improving pretrained VLAs and world action models. Their broader priors can provide a stronger starting capability, while Toutatis adapts the representation to the real operation and optimizes the deployment outcome through the same efficient RL loop.
From a repetitive task to a robot workforce
Gobano aims to automate repetitive physical tasks. Toutatis is designed to make those deployments faster and more reliable. When a task is a good fit, we start from the real objects, operating constraints and expected rate, then build the setup, teach the robot, improve it through real-world learning and validate it against the required outcome.
The task may be straightforward but repetitive, or physically difficult to automate with fixed rules: handling variable parts, folding textiles, manipulating bags, cables, straps or irregular packaging. In either case, the deployment is built around the real task and its real operating conditions—including the material, friction, wear, tooling and variation the robot will encounter on your floor.
Define the objects, working conditions, cycle time and success criteria.
Collect demonstrations, train the task model and learn from autonomous attempts.
Once the task meets its reliability target, deploy the robot. Further learning iterations use real operating experience to reduce cycle time without sacrificing reliability.
Toutatis is the learning engine behind that workforce. It turns a small set of human demonstrations into an initial controller, then uses autonomous experience to improve the failures and cycle-time limits that prevent deployment. The output is not a research model or a collection of isolated demos, but a deployed robot workforce measured by successful cycles, throughput and interventions per shift.
99% is a milestone, not the finish line. Once reliability meets the customer’s acceptance threshold, Toutatis can shift the objective toward shorter cycle times while continuing to learn from the failures that emerge in operation.
We are now advancing Toutatis on two fronts: making reliable controllers faster on our R&D setups, and bringing that autonomy to the robots working with our first customers. Stay tuned—we will share results from both tracks in upcoming articles.
Building reliable Physical AI requires exceptional work across the full stack—from learning algorithms and world models to robotic systems and real-world deployment. We are always looking for world-class scientists, engineers and roboticists who want to help turn this technology into dependable robot work. If that sounds like you, explore our open roles.
If your operation contains a repetitive physical task, bring us the task. We will evaluate what it takes to deploy a robot workforce against your operating target.