Data hungry
RL is often extremely data-inefficient and can need thousands or millions of iterations just to find something that resembles a starting point.
Robots should be able to learn new tasks and recursively self-improve, without any human input or dedicated data and training campaigns. PHYSICA is building towards that goal to give customers a product that keeps working even when the tasks are changing. PHYSICA 0.1 is the first step in that direction: a robot brain that learns new physical skills from scratch, in the real world, without human demonstrations. It is a learning loop that starts from a slow first success and improves itself through practice, with no human input.
Part I
Deploying an autonomous system always starts with the same step 1: collecting data. We may take this as a given, but our customers don’t. When our customers buy a robot, they expect it to work not only on today’s workflows, but also to adapt to the new products and tasks that may need handling tomorrow. For a human operator, it is sufficient to explain the new task. They may need some supervision in the beginning and take a day or two to get proficient, but they don’t need to go back and learn the basics.
So we asked: why should this be different for robots? And how can we work towards a stack that shifts the learning process from the lab to the field?
Can we learn new tasks, from scratch, in the real world, without human demonstrations?
For robots to learn on the job, there needs to be a different way for them to understand new tasks, memorize workflows, create sub-tasks and adapt to variations. Luckily, this kind of sematic knoweldge is readily available in a wide array of frontier models. Even more, recent frontier models have shown that they can operate real robots through code or direct teleoperation and the capabilities will keep improving. Frontier models will never be strong enough to drive real robots in real time for skilled execution, but they carry semantic task knowledge which is enough for initial demonstrations to start a learning loop. The question is: can we build a learning loop that takes this semantic knowledge and turns it into a real-world skill?
Leverage frontier models to provide semantic knowledge to bootstrap a self-learning loop.
The AI equivalent of self-learningis Reinforcement Learning (RL). And while RL is a powerful concept, it is not something you want to run without guardrails on real robots. RL from scratch works in simulation or on limited locomotion tasks[1] because the learning process can spend thousands to millions of samples on erratic early movements. In the real world, those movements would break the robot or its environment.
But what if we use frontier models to provide this early semantic knowledge? Would that be enough to build a learning loop that is robust and efficient enough to train from scratch in the real world? That is the hypothesis behind PHYSICA 0.1
All autonomous systems are based on two major learning paradigms: Imitation Learning (IL) and RL. If we want robots to learn new skills ‘on the job’, they need to lean heavily on RL. Recent systems already move in this direction by adding RL on top of imitation (e.g., π*0.6[2]), but their starting point is still demonstration data. If you can get RL working on its own, you not only reduce the amount of IL data needed to start with, the robot can also become much better than any reproduction of human teleoperation data could ever be.
That second point matters. Imitation can only be as good as the demonstrator, and in robotics the gap is worse, because the demonstrator rarely shares the robot’s body: a human hand, a teleoperation rig and a robot arm move differently. More data makes the policy more robust, yet it cannot unlock what the hardware itself is capable of. So if we can achieve more stable RL loops on real robots, we are not only accelerating deployment cycles but also improving the performance.
Reinforcement Learning is the path to superhuman performance. Unfortunately, RL is hard.
While RL seems like a great tool to get the most performance out of any learning system, RL is notoriously difficult to get right, along several dimensions at once.
RL is often extremely data-inefficient and can need thousands or millions of iterations just to find something that resembles a starting point.
RL can be very brittle, and runs may diverge on the smallest change to hyperparameters or implementation details.
RL is prone to reward hacking: instead of solving the task the human intended, the agent finds a ‘hack’ that scores better without solving the problem.
Training a large pretrained model further can erode what it already knew.
RL is also called learning from trial and error, but most often that is a misnomer. The majority of approaches ignore all failures and learn only from successes. This can be easier algorithmically, but it means the model only remembers what worked and never what didn’t. That in turn makes algorithms and learned skills brittle and data-inefficient, and hurts generalization. To achieve our goal, we need models that understand what didn’t work, so that they learn solutions that are robust and can recover from failures.
A robot brain has to handle several concepts of different importance and urgency at the same time. It has to understand the context and the overall task, and break the task down into sub-tasks. It has to localize target objects and plan manipulation strategies. It has to observe its environment and slow down if humans enter the workspace. And finally it has to execute sub-tasks skilfully, i.e., fast and reliably.
These jobs live on very different timescales and semantic layers, so we give each its own layer:
| Layer | Rate | What it does |
|---|---|---|
| Reasoning | <1 Hz | Understands the context, decides on the next sub-task. The robot can take a second to deliberate. |
| Physics | ~10 Hz | Has an intuition of how objects interact and how they will move under manipulation, separate from the reasoning about the steps of a task. For the tasks our robots target, ten updates a second is a reasonable timescale. |
| Skill / control | ~100 Hz | Executes the movements. These should be fluent and skilful: stutter-free and confident, which is best achieved with control at high frequency. |
This is the core architecture of PHYSICA, and it is what allows sample-efficient RL from failures. Each component focuses on one level of abstraction, so the system can break tasks down into sub-tasks that individual skills solve easily, build the physical understanding that lets it learn from failures, and train fast skills without affecting the reasoning levels.
Two pivotal elements inside the physics layer make this architecture reach the data efficiency and speed that real-robot learning needs:
Seen from the robot, picking up a box on the left and picking up the same box on the right are two different physics problems. The physics model instead predicts how the object moves in its own frame, where they are the same problem. What it learns in one place transfers to other positions, and to other robots. It also makes failures informative: a failed grasp still shows how the object moved, so the model can learn from it.
Most pixels in a camera frame are background with no bearing on the interaction. Like biological vision, the physics model looks closely only where the interaction happens: a small selector finds the target in a coarse view, and only a high-resolution crop around it goes into the model. This cuts the cost per frame, which is what makes a physics layer at around 10 Hz on real hardware feasible.
Much of imitation learning is really learning task semantics. Solving a task requires understanding it, and most of the signal in teleoperation and video data is exactly that. This is a gap that frontier models are closing rapidly, so we use it: they interpret the task and provide the first attempt.
That attempt is slow, but successful, and it is enough to get a good RL loop started. It skips the data campaign entirely and lets PHYSICA focus on what semantics alone cannot deliver: getting better. See how the reasoning model starts the loop ↓
Part II
How a frontier model, a physics model and a robot policy improve each other.
Getting the first demonstration is the easy part.
Self-learning is difficult.
Practice needs a starting point, and a frontier model provides one: a slow first success, with no human demo. The hard part is learning efficiently from the robot’s own attempts. That is what the physics model and the learning loop are for.
01 — The learning loop
Read clockwise. The frontier model starts the loop once; after that, real attempts and the physics model take turns improving the policy.
02 — How it works
03 — Inside the model
Layer 3 · Reasoning · <1 Hz
Knows what the task is, gets the robot to a first success, and says what comes next.
What should happen next?
1 · Understand the task
A frontier model reads the instruction and the scene and turns them into what the rest of the system needs: which object matters, and what counts as success. This is the part of the problem that transfers broadly, so PHYSICA does not try to learn it from scratch.
2 · First demonstration
The frontier model teleoperates the robot until the task succeeds once. No human demonstration is needed. On the real SO-101 the first exploration took 19.7 s; making it fast is the job of the layers below.
3 · Sequence subtasks
For a longer task, the reasoning layer decomposes the goal into subtasks and chooses which skill to run next. It works at the slowest rate, below once a second, and asks only “what should happen next?”—the physics and the motion are left to Mθ and gφ.
Layer 2 · Physics model · ~10 Hz
Predicts what a candidate motion will do to the object, using temporal abstraction and foveation: success, time, and how it moves.
What will this interaction do?
Sees the proposed gripper path relative to the estimated object frame, focused visual features, and task context.
Predicts success probability, time to success, and a compact code for how the object will move.
Transfers because interaction geometry is represented around the object—not around a particular robot’s joints.
1 · The idea
Learning efficiently needs a model of the world. PHYSICA’s is a vision-based physics model: it looks at the camera images and a candidate action, and predicts what the action will do to the object—whether it succeeds, how long it takes, and how the object moves.
With that model, practice can be planned and evaluated inside the model instead of only on the robot. But world-action models are inefficient: they predict everything, every pixel at every timestep. PHYSICA makes the model efficient and general by borrowing two ideas from biology, then keeps the skill itself specific to each robot.
2 · Efficient
To make the model efficient, we start from how it sees. Every perception module, and every dynamics model built on perception, starts from pixels. Usually all of them are processed. That is wasteful: most pixels are background with no bearing on the interaction, compute grows with resolution, and fine contact detail is lost when the whole frame is downsampled.
Biological vision instead uses a fovea: high acuity on what matters, a coarse periphery for context. PHYSICA does the same. A selector finds the object in a coarse view, and only a high-resolution crop around it goes to the model.

3 · Object-centric
To make the model’s data transfer, we change where it looks from. Seen from the robot, picking up a box on the left and the same box on the right are two different physics problems. PHYSICA learns physics in the object’s own frame instead, where they are the same problem. Data generalises more efficiently: an interaction learned in one place transfers to others.
Layer 1 · Policy · ~100 Hz
Fast motion in this robot’s own joint space, rolled out for each subtask.
How should this body move now?
Proposes a low-dimensional motion code u and explicit duration T for the current context.
Decodes that code into a smooth joint-space trajectory for this robot.
Improves through gradients from the learned physics model and through successful motions collected in practice.
1 · Robot-space skill
gφ proposes a low-dimensional motion code u a for the current context. A decoder Dψ turns that code into a smooth joint-space trajectory for this particular robot. Physics transfers through the object frame; execution stays faithful to each robot.
2 · Rolls out each subtask
For the subtask the reasoning layer has chosen, gφ proposes the motion and the robot executes it, responsive at the joint level and close to its sensors. It answers “how should this body move now?”
3 · Trained in the model, improved by practice
gφ improves through gradients from the learned physics model Mθ, and through the successful motions collected when the robot practises. It searches for faster motions only where Mθ predicts they stay reliable, which is this objective:
Model-based self-improvement
The system searches for faster motion only inside a learned reliability constraint. Prediction proposes the improvement; physical execution supplies the evidence.
One system, three coupled timescales
The division is the point: semantic reasoning can transfer broadly; physics transfers through object-relative structure; execution remains faithful to each robot.Part III
Our experimental principles
- No human data. No demonstrations, no teleoperation.
- No sim-to-real transfer. Nothing learned in simulation is deployed on the robot.
- Real-world verification. Every result in this post is measured on real hardware.
04 — Real robot
We run the recipe on a real SO-101 arm with a stereo camera: the robot practises, and the same perception and physics-model recipe is trained on its own attempts.
After that, the loop learns only from real attempts. No teleoperation on the SO-101.
19.7 s first exploration
A small selector finds the cube; only a crop around it is processed at high resolution. The grasp target sharpens as successful grasps pile up. How ↑
2.1 px selector · 1.29 cm grasp point
On 173 held-out real attempts, in the cube’s own frame. More real practice, closer predictions. How ↑
0.916 success AUC · 0.73 cm path error
The policy is trained through M and tried on the robot; every attempt updates M again.
19.7 → 0.9 s to pick up the cube
↑ Watch the research film at the top of the page
One red cube, though, is the friendly case: rigid, regular and easy to see. A recipe that never sees human data has to hold up when the objects stop being convenient.
05 — Generalizing to multiple objects
We add four objects that are harder to pick: a second cube, a coiled cable, a screwdriver and a thin whiteboard marker, and let the same loop practise on all five.
Averaged over all 5 objects:


Give each layer only what it needs, let a frontier model supply the first success, and self-practice carries the robot past the imitation ceiling.
Next
Our next step is to run the same experiment, under the same three principles, on bimanual industrial tasks, enabling self-improvement in the field without human intervention.
References
06 — Paper
Nova X Robotics AI Team, O. Kroemer and R. Liutikov
@inproceedings{physica2026,
title = {Nova X PHYSICA 0.1: Self-Learning Foundation Model
for Zero-Shot Skilled Task Learning},
author = {{Nova X Robotics AI Team} and Kroemer, O. and Liutikov, R.},
booktitle = {CoRL 2026 LBR},
year = {2026}
}