For the technical details behind TI-0.1, see our technical report.
The US has been deploying robots for 65 years, but robots are not yet common in our lives. Robots predominantly execute highly repetitive routines in highly structured environments, and even in the most structured and repetitive industries, like manufacturing and logistics, 9 out of 10 businesses don’t have a single robot.
Generally intelligent robot models (like TI-0) running on generally capable robot hardware (like Sonny) offer a path to scale robotics far beyond narrow tasks in structured settings. But there is no internet of data for the physical world. At Tutor, we believe that deploying robots into real-world settings and collecting demonstrations from human “Tutors” is a critical step toward building general robot intelligence, but experimentation and failure data in production settings come at an enormous cost. How can we achieve far more reliable autonomous behavior from far less real-world data, letting robots quickly learn complex tasks in the real world at human speed and reliability?
Our answer: frontier models like GPT-6 Astra can now build a simulation of a robot’s task from a few real-world demonstrations, matching not just how the scene looks but how the robot and objects move. Seeded by Tutor demonstrations, agents reconstruct the task in simulation (real2sim) and train policies there with reinforcement learning. They then deploy those policies back to the robot (sim2real), where real rollouts show what the simulator still gets wrong. This turns robot learning into a deployment-time compute scaling problem: given a robot deployed for an intended task, performance scales purely with compute.
Today we are introducing TRACE, an agentic harness in which frontier LLM agents rebuild a robot’s task in simulation and train policies there, along with TI-0.1, the first model in our TI series trained with it. Starting from just a few Tutor demonstrations, TI-0.1 learns its task entirely in simulation and runs autonomously on Sonny at human speed. These results point to a clear path to deploying millions of Sonny robots across the physical economy.
For more technical details, please see our technical report.
How TRACE works
TRACE stands for Telemetry-grounded Reconstruction, Alignment, and Closed-loop Evaluation: the three steps below.
Starting from a few Tutor demonstrations, agents rebuild the task in simulation: both the scene the robot saw and how the robot and objects actually moved. Replaying the robot’s recorded commands in simulation lets us check the physics, not just the picture.
Inside that simulation, a policy practices the task with reinforcement learning. Teaching it the behavior we actually want takes care: in one Lego experiment, the policy learned to dump out the whole bin instead of removing a single brick. Agents review the rollouts and refine the task until the behavior matches what we intended: work that once took a robotics team weeks of building scenes, tuning physics, and debugging rewards.
Finally, we distill the RL policy into TI-0.1, a model that acts from camera images and the robot’s own joint readings, and run it on Sonny, where it moves at human speed with smooth, decisive motion. The video at the top of this post is TI-0.1 running autonomously at 1× speed. Every real-world trial shows where the simulation still differs from reality, and the agents fold that back into the next round of training, so more compute keeps buying a better policy.
Software infrastructure for training and deployment at scale
At Tutor, we believe robotics is the ultimate systems problem. While the model is a critical component of building and deploying generally capable robots, our team works across the stack to build the infrastructure necessary to make robots work at scale. Training and running frontier robot models requires rethinking the full robotics software stack.
We built Golem, a new robot software stack, so that every robot records what it saw, what it was asked to do, and how it moved on one consistent timeline. Golem runs camera processing and arm control in Rust, alongside policy inference on the robot’s GPU. In our comparison with our previous Python-based stack, it used 90% less CPU and 79% less RAM, with 68% lower camera-streaming latency. This infrastructure supports the cycle from collecting demonstrations to running policies and inspecting their behavior on hardware.
Towards robots everywhere
TI-0.1 is a first step, but Tutor’s ultimate mission is to proliferate robots for the common good, and our work is not complete until Tutor robots are deployed at scale making the physical world a meaningfully cheaper and better place to live. Next, we are scaling TRACE across many more tasks in DF1 and into real-world deployments with Tutor’s customers across the United States.
If you are interested in working on scaling robot learning and deployment in the real world, please consider applying to join our team.
