Nova X Robotics

Intelligence in Action

PHYSICA 0.1
Self Teaching Robots
Zero human demos. Faster than human teleop.

Nova X Robotics AI Team1, O. Kroemer2, R. Liutikov3
1Nova X Robotics 2Robotics Institute, Carnegie Mellon University 3Karlsruhe Institute of Technology
October 2026

Research film · 01:30 — From first guided motion to autonomous, model-based practice.

tldr

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

How we have always done it....

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.

Scaling Laws of Imitation Learning

Illustrative chart of data cost versus final task performance: the imitation-learning curve (data points at ~500h / $27k, ~10kh / $0.5M and ~500kh / $27M) rises steeply up to a human-demonstration limit near 90 percent; the PHYSICA self-learning curve stays low and extends to 100 percent
Figure 01 Imitation learning needs exponentially more human data for each step in performance, and stops at the human-demonstration limit. The region beyond it is only reachable with self-learning.

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.

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.

Brittle

RL can be very brittle, and runs may diverge on the smallest change to hyperparameters or implementation details.

Reward hacking

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.

Forgetting

Training a large pretrained model further can erode what it already knew.

So if we want to get RL working from scratch on real robots, have to build a learning loop that is robust and efficient enough to train from scratch in the real world, with only very few and rough initial demonstrations coming from frontier models.

For this line of research, we build on three key principles.

1. Learn from failure

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.

2. Separation of concerns in a semantic ladder

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:

LayerRateWhat it does
Reasoning<1 HzUnderstands the context, decides on the next sub-task. The robot can take a second to deliberate.
Physics~10 HzHas 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 HzExecutes 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:

Object frame

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.

Foveation

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.

3. Start from frontier-model semantics

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 ↓

Learned knowledge & skills

Learned knowledge and skills by data source: Level 1 Skilled Movements (real-world practice, autonomous exploration, self-play, long-term operation) and Level 2 Contact Physics (physical interaction and sensor data) require real-world practice, i.e. PHYSICA; Level 3 Task-Level Physics (human and robot demonstrations) and Level 4 Task Semantics (language and internet video) are already largely covered by frontier models today
Figure 02Internet-scale data is strongest at semantics. Interaction data reveals contact physics and the skilled movement of a particular body.

What we found: Our Key insights.

  • Splitting up the levels makes it easier to learn what is relevant. Each layer sees only what it needs. →
  • Frontier models carry enough semantics to get a good RL start. A slow first success, with no human demonstration. →
  • Good RL can break the imitation performance ceiling. A learned skill can beat the teleoperation reference. →
  • Good RL has to be highly data-efficient. Real-robot learning leaves no room for millions of samples. →
  • An object-centric physics model. Knowledge transfers across positions and robots, and failures become informative. →
  • Target-centric perception. Look closely only where the interaction happens. →
  • Generalize at the physics level, specialize at the skill-policy level. Physics transfers across robots, execution stays faithful to each body. →
Superhuman teleoperation performance.
19.7 → 0.9 sreal SO-101 pick, first exploration vs. fastest learned
1.43 vs. 3.07 smedian learned pick vs. median pick in teleop seed data (5 real objects)
1.60 smedian learned real pick (SO-101)
0.916held-out real success AUC (chance: 0.5)
See the results ↓

Part II

The model and learning loop

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

One loop, from a slow first success to a fast skill.

Read clockwise. The frontier model starts the loop once; after that, real attempts and the physics model take turns improving the policy.

The PHYSICA learning loopA frontier model bootstraps a slow first success. The robot then practises; its attempts become interaction data, which update the object-frame physics model; the physics model trains the joint-space policy; the robot practises again with the faster policy. Physics-model and policy updates alternate.01 · BOOTSTRAP · ONCEFrontier modelSupplies task semantics anddrives the robot to a slowfirst success. No human demo.02 · ACTRobot practisesExecutes a candidate motion;observes success, timing andobject motion with its sensors.03 · EXPERIENCEInteraction dataSuccessful and failedattempts, from the robot’sown sensors.04 · UPDATEPhysics model MθObject frame · temporalabstraction · foveation. Predictssuccess, time, object motion.05 · IMAGINEPolicy gφRobot / joint-space skill.Proposes motion and duration;trained against Mθ.first successattemptsupdate Mθtrain gφ in Mθpractise again, faster↻ alternateFrontier model: enters once,to start the loop.Loop 02 → 03 → 04 → 05 → 02:repeats until the skill is fast.The PHYSICA learning loopFrontier model bootstraps a first success; robot practises; interaction data; physics model update; policy trained in the physics model; back to practice.01 · BOOTSTRAP · ONCEFrontier modelSupplies task semantics anddrives the robot to a slowfirst success. No human demo.slow first success02 · ACTRobot practisesExecutes a candidate motion;observes success, timing andobject motion with its sensors.attempts03 · EXPERIENCEInteraction dataSuccessful and failedattempts, from the robot’sown sensors.update Mθ04 · UPDATEPhysics model MθObject frame · temporalabstraction · foveation. Predictssuccess, time, object motion.train gφ in Mθ05 · IMAGINEPolicy gφRobot / joint-space skill.Proposes motion and duration;trained against Mθ.practise again, faster · alternate
Figure 03The learning loop. The frontier model starts the loop; afterwards physics-model updates and policy training alternate.

02 — How it works

Three layers, three speeds.

How PHYSICA 0.1 works The robot is given a task in words, a real stereo camera image of the scene (an SO-101 arm, a red cube and a box) and its joint positions. Perception uses foveation: the whole scene is seen at low resolution and only a crop around the target is kept at high resolution. A three-layer ladder processes this. The reasoning layer, a frontier model running below 1 Hz, outputs the next sub-task. The physics layer, an object-frame physics model Mθ running at about 10 Hz on the foveated crop, predicts for each candidate motion whether it succeeds, how long it takes and how the object moves. The skill policy, at about 100 Hz, outputs joint-space motion. The real robot executes it: a learned pick takes 0.9 seconds, against 19.7 seconds on the first try. The robot observes the outcome with its own sensors: success or failure, time and object motion. A learning loop feeds the outcome back: attempts update M, the policy is trained against M, and the robot practises again, faster. The frontier model bootstraps once, giving a slow first success without any human demonstration. what the robot senses the plan perception the model What the robot is given Three layers, three speeds What it does Task, in words“Clean up the table” stereo camera, real SO-101 Foveation whole scenelow resolution target crophigh resolution Only the crop around the targetis kept at full detail. Joint positionswhere each joint is now Reasoningfrontier model <1 Hz Reads the task, decides what comes next → next sub-task: “grasp the red cube” bootstraps once: slow first success, no human demo sub-task The model · improves with practice Physicsphysics model Mθ ~10 Hz input: foveated crop, object frame For each candidate motion, predicts: success · time · how the object moves M scores candidates Skill policy ~100 Hz Executes each sub-task, fast and fluent → joint-space motion learned real pick, 0.9 s (first try: 19.7 s) Outcomefrom its own sensors success or failure · time taken how the object moved Learning loop attempts update M policy trained against M practise again, faster How PHYSICA 0.1 works Top to bottom: the robot is given a task in words, its joint positions and a real stereo camera image of the scene. The reasoning layer, a frontier model below 1 Hz, outputs the next sub-task and bootstraps once with a slow first success and no human demonstration. Perception uses foveation: the whole scene at low resolution, and only a crop around the target at high resolution. The physics layer, an object-frame physics model Mθ at about 10 Hz on the foveated crop, predicts success, time and object motion for each candidate motion. The skill policy at about 100 Hz outputs joint-space motion. The real robot runs it: a learned pick takes 0.9 seconds, against 19.7 seconds on the first try. The outcome is sensed by the robot itself. A learning loop returns the outcome to the model: attempts update M, the policy is trained against M, and the robot practises again, faster. what the robot senses the plan perception the model What the robot is given Task, in words“Clean up the table” Joint positionswhere each joint is now stereo camera, real SO-101 Reasoningfrontier model <1 Hz Reads the task, decideswhat comes next → next sub-task:“grasp the red cube” bootstraps once: slow first success,no human demo sub-task The model · improves with practice Foveation: sharp only where it matters whole scene,low resolution target crop,high resolution Physicsphysics model Mθ ~10 Hz input: foveated crop,object frame For each candidate motion, predicts: success · time · object motion M scores candidates Skill policy ~100 Hz Executes each sub-task,fast and fluent → joint-space motion learned real pick, 0.9 s (first try: 19.7 s) Outcomefrom its own sensors success or failure · time takenhow the object moved attempts update M, policy trained against M practise again, faster
Figure 04How PHYSICA 0.1 works. Three layers run at three speeds, from a frontier model that decides the next sub-task to a policy that moves the joints. A frontier model starts the loop once; after that, every attempt makes the physics model and the policy better. Foveation keeps the whole scene at low resolution and only the crop around the target at high resolution.

03 — Inside the model

General physics in object space.
Fast skill in robot space.

R

Layer 3 · Reasoning · <1 Hz

Reasoning Model

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

It supplies the semantics.

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

It drives the robot to a slow first success.

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

It decides which skill comes next.

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φ.

Mθ

Layer 2 · Physics model · ~10 Hz

Object-frame physics model

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?

Mθ(τobj, ô, xfov, etask) → (psuccess, tsuccess, zobject)

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.

Notation
Mθ
the physics model; θ are its learned parameters.
ô
the estimated object frame: the target object’s pose (position and orientation), estimated from the stereo images.
u, T
a candidate action: the motion code u and duration T proposed by the policy gφ.
τobj
the gripper path of that candidate motion, expressed in the object frame ô.
xfov
foveated visual input: high-resolution crops of the stereo images around the target object.
etask
task context: an embedding of the task.
psuccess
predicted probability that the motion succeeds, written P̂(success) in the objective.
tsuccess
predicted time to success; Ê[tsuccess] in the objective is its expected value.
zobject
a compact code for how the object will move: its predicted path.

1 · The idea

A model that sees, and predicts what an action will do.

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.

Stereo images and a candidate action go into the physics model, which predicts success, time and object motion Inputs stereo images candidate action Physicsmodel Prediction success? time to success object motion

2 · Efficient

Look closely only where the interaction is.

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.

Photo of the SO-101 arm and a red cube: the whole scene enters blurred and foveation outlines the target object. Only that crop is being processed at higher resolution.
The SO-101 scene. Left: the whole scene enters blurred and foveation outlines the target object. Right: Only that crop is being processed at higher resolution.

Cost per frame: whole frame vs. foveated

MeasuredCost falls almost linearly with the cells kept; selection plus the coarse view add about 10 ms. The selector costs 2.05 ms per frame.

3 · Object-centric

The Center of it all.

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.

Two boxes at different positions: different gripper paths in the robot frame, the same path in the object frame Robot frame robot two different paths Object frame one shared path
gφ

Layer 1 · Policy · ~100 Hz

Robot-specific skill policy

Fast motion in this robot’s own joint space, rolled out for each subtask.

How should this body move now?

gφ(c, etask) → (u, log T)  ·  Dψ(u, s) → q(s)

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.

Notation
gφ
the skill policy; φ are its learned parameters.
c
the current context: the start pose of the target object (its estimated frame ô, as in Mθ) and of the gripper.
etask
task context: an embedding of the task, as in Mθ.
u
the motion code: a low-dimensional latent describing the whole motion.
T
the motion’s duration; gφ outputs log T so it stays positive.
Dψ
the motion decoder; ψ are its parameters, learned as a joint-space motion autoencoder.
s
normalised time along the motion, from 0 (start) to 1 (end, reached at time T).
q(s)
the decoded joint-space trajectory: this robot’s joint angles at phase s.
Ê[tsuccess]
the expected time to success that Mθ predicts for the motion.
P̂(success)
the success probability psuccess that Mθ predicts for the motion.
pmin
the minimum predicted success probability a faster motion must keep.

1 · Robot-space skill

Fast motion, specific to this body.

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

One skill per subtask, close to the hardware.

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

The model proposes; the robot confirms.

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

minimize Ê[tsuccess]   subject to   P̂(success) ≥ pmin

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

Results

Our experimental principles

  1. No human data. No demonstrations, no teleoperation.
  2. No sim-to-real transfer. Nothing learned in simulation is deployed on the robot.
  3. Real-world verification. Every result in this post is measured on real hardware.

04 — Real robot

Learning from scratch on a 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.

19.7 sfirst frontier-model exploration
0.9 sfastest learned real pick
1.60 smedian learned real pick
0.916held-out real success AUC

The self-learning loop on a real SO-101 · one red cube, real attempts only

Bootstrap
Real SO-101 arm during its first exploration of the cube pick, timer at 19.7 seconds

A Claude agent writes the first practice behaviour.

After that, the loop learns only from real attempts. No teleoperation on the SO-101.

19.7 s first exploration

Perceive
Held-out real camera frame: the selector's red cross sits inside SAM3's green circle on the red cube

Camera-only perception on real images.

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

Imagine
One held-out real attempt: the measured sideways cube push reaches 5 cm; M's predicted path gets closer to it as M is trained on 50, 100, 200, 400 and 666 real attempts

M predicts success and how the cube moves.

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

Practice
Real SO-101 arm lifting the red cube after practice, timer at 0.9 seconds

Practice makes the real pick fast.

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

Figure 05The self-learning loop on the real SO-101. Bootstrap and Practice: the first exploration and a learned pick, both real time; pick time runs from first motion until the cube is lifted. Perceive: red × = selector, green ○ = SAM3 label, held-out frame (constant-guess baseline: 46 px). Imagine: held-out attempt #720, measured cube path (black) vs. M trained on 50 to 666 real attempts (light → dark); the cube-stays-still baseline scores 1.55 cm.

Grasp-point error vs. real successful grasps

Real SO-101: the median 3-D error of the camera grasp target falls from 3.63 cm with 50 successful grasps to 1.29 cm with 7,624, against 3.87 cm for a constant average grasp point
Figure 06Anchor model trained on pooled real stereo rollouts, tested on the 173 held-out attempts.

Cube-path error vs. real attempts used to train M

Test path error falls from 1.04 to 0.73 cm on successes and from 1.65 to 1.26 cm on failures as training grows from 50 to 666 real attempts, against 1.55 and 1.82 cm for assuming the cube stays still and 0.85 and 1.59 cm for a class-mean oracle that is told the outcome in advance
Figure 07Mean ± sd over 5 seeds on all held-out test attempts. Dashed: the cube-stays-still baseline. At 666 real attempts, PHYSICA M reaches 0.73 cm on successes and 1.26 cm on failures; a class-mean oracle scores 0.85 and 1.59 cm, and assuming the cube stays still 1.55 and 1.82 cm. The oracle is told in advance whether the grasp succeeds and predicts the average measured path for that outcome; PHYSICA M must predict the outcome itself and still beats it.

↑ 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

From one cube to a cluttered table.

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.

The multi-object arena

Figure 083D scan of the multi-object arena. Drag to rotate, scroll to zoom.

Averaged over all 5 objects:

1.0 sfastest learned pick
1.43 smedian learned pick
1.3 cmgrasp-point error from the camera
0.97held-out success AUC
3.07 smedian pick in teleop seed data
7,340total attempts

Multi-Object Table Clear

Real-robot rollout, 18 s at real-time speed: the SO-101 arm picks the whiteboard marker, the coiled cable, the yellow cube and the red cube off the arena floor one by one and drops each into the cardboard boxReal-robot rollout from the other side of the arena, 21 s at real-time speed: the SO-101 arm clears the coiled cable, the red cube, the screwdriver, the yellow cube and the whiteboard marker into the cardboard box behind it
Figure 09Real rollouts on different initial tabletop settings. Both videos play at 1× (real-time) speed.

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

From single arm to bimanual, from the lab to the field.

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

References

  1. N. Rudin, D. Hoeller, P. Reist, M. Hutter. Learning to Walk in Minutes Using Massively Parallel Deep Reinforcement Learning. Conference on Robot Learning (CoRL), 2021. arXiv:2109.11978
  2. A. Amin et al. (Physical Intelligence). π*0.6: a VLA that Learns from Experience. November 2025. pi.website/blog/pistar06
  3. L. Smith, I. Kostrikov, S. Levine. A Walk in the Park: Learning to Walk in 20 Minutes With Model-Free Reinforcement Learning. arXiv preprint, 2022 (demo version at RSS 2023). arXiv:2208.07860 · project page
  4. L. Engstrom, A. Ilyas, S. Santurkar, D. Tsipras, F. Janoos, L. Rudolph, A. Madry. Implementation Matters in Deep Policy Gradients: A Case Study on PPO and TRPO. ICLR, 2020. arXiv:2005.12729
  5. P. Henderson, R. Islam, P. Bachman, J. Pineau, D. Precup, D. Meger. Deep Reinforcement Learning that Matters. AAAI, 2018. arXiv:1709.06560
  6. S. Huang, R. F. J. Dossa, A. Raffin, A. Kanervisto, W. Wang. The 37 Implementation Details of Proximal Policy Optimization. ICLR Blog Track, 2022. iclr-blog-track.github.io
  7. J. Clark, D. Amodei (OpenAI). Faulty Reward Functions in the Wild. December 2016. openai.com/index/faulty-reward-functions · video: CoastRunners
  8. V. Krakovna, J. Uesato, V. Mikulik, M. Rahtz, T. Everitt, R. Kumar, Z. Kenton, J. Leike, S. Legg (DeepMind). Specification gaming: the flip side of AI ingenuity. April 2020. deepmind.google
  9. D. Driess, J. T. Springenberg, B. Ichter, L. Yu, A. Li-Bell, K. Pertsch, A. Z. Ren, H. Walke, Q. Vuong, L. X. Shi, S. Levine (Physical Intelligence). Knowledge Insulating Vision-Language-Action Models: Train Fast, Run Fast, Generalize Better. arXiv preprint, 2025. arXiv:2505.23705
  10. M. Wołczyk, B. Cupiał, M. Ostaszewski, M. Bortkiewicz, M. Zając, R. Pascanu, Ł. Kuciński, P. Miłoś. Fine-tuning Reinforcement Learning Models is Secretly a Forgetting Mitigation Problem. ICML, 2024. arXiv:2402.02868

06 — Paper

Nova X PHYSICA 0.1: Self-Learning Foundation Model for Zero-Shot Skilled Task Learning

Nova X Robotics AI Team, O. Kroemer and R. Liutikov

BibTeX

@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}
}