// SOFTWARE · AUTONOMOUS POLICY TRAINING
Describe the task. Get a verified policy.
Our pipeline turns a task written in plain English and a digital model of your robot into a trained policy: the program that tells the robot how to move to get the job done. No expert hand-tunes it. Every result is graded on how often it succeeds in situations it never practiced, never on its own internal score.
01 — Results so far
Measured in simulation, on conditions held out from training.
// Simulation results in NVIDIA Isaac Lab. The second gripper trained with domain randomization: friction, stiffness and sensor noise varied on every attempt. 95% is measured with training randomness switched off, at approach distances the policy never trained at. Testing on real robots is the next milestone.
02 — How it works
A search over rewards, judged by measurement.
A robot learns a skill by trial and error, with a reward formula scoring every attempt. Writing that formula is the slow, expert part of training, and our loop writes, tests and revises it on its own. A person sets the task and the bar. The system does the iterations.
-
Task in English
"Grip the block squarely, carry it low over the bin, set it down, then let go." That sentence plus a digital model of your robot is the whole input.
Input -
Generate rewards
An AI language model writes candidate rewards, built from a library of scoring terms we have already tested. It is told every failure the system has already seen.
LLM · Eureka method -
Gate before training
Quick checks, taking milliseconds to minutes, reject a broken reward before it can waste an hour of GPU time.
Cheapest check first -
Train in parallel
Thousands of simulated robots practice at once on each GPU, the graphics chip that runs the simulation, with several candidate rewards and random starting points running side by side. Runs that stall or fall apart are stopped automatically.
NVIDIA Isaac Lab -
Grade on held-out conditions
Each policy is retested at distances and settings it never trained on. That success rate, not the reward score, decides the ranking.
Measured success -
Diagnose the failure
Every failed attempt gets a category: never gripped, dropped on the way, stopped short, released too high. The dominant failure picks the next fix.
Failure catalog -
Advance the curriculum
Training is staged like a lesson plan: pick, then carry, then place. Each stage starts from the last stage's winner, and moves on only after it clears its own bar.
Staged training -
Verified policy out
You get the policy, its success rate under each held-out condition, and footage. The measurement is part of what you receive.
Deliverable
Steps 02–06 repeat until the policy clears the bar or the system reports it is stuck, with the reason. No one watches the dashboards.
- PPick
- TCarry
- APlace
- B–CWider approaches
- NNoise down: steady, repeatable motion
03 — Gates
Every reward is checked before it reaches a GPU.
Each check runs before the next, more expensive one. The first gate tests the task itself: a hand-scripted reference motion has to succeed in every condition, and the success test has to reject drops, throws and a gripper that never lets go. A task has to be solvable before any reward search begins.
Have a picking, kitting or machine-loading task?Phase 1 is ready now: we can train and verify a policy for your gripper and part in simulation.
Tell us the task →04 — Why held-out grading
We grade every policy on conditions it never trained on.
Held-out grading measures what a policy will do on the parts and positions it meets next. A policy scored on its own training conditions is partly scored on memory: in one of our own placing runs, the top policy succeeded 91% of the time under training conditions and 43% under held-out ones. Ranking on the first number would have shipped the wrong policy.
// Placing stage, prototype gripper, simulation. The system then kept training until the policy, with training randomness switched off, reached 95% on held-out conditions.
05 — It learns from its mistakes
Every failure becomes a rule the next search starts with.
When a run fails in a new way, the cause is written into a failure catalog with its evidence and the safeguard that now prevents it. Every future reward search reads that catalog. A fix made once applies to every policy after it, on every robot.
One recent example: a carry reward paid an off-center grip almost as well as a good one, so the policy traded grip quality for speed. The fix was not a new weight. It was a rule: carry pay starts only after the grip passes the success test's own check. That rule now applies to every task the system trains.
06 — Compared
What changes for an automation team.
| Typical hand-tuned training | MK2 pipeline | |
|---|---|---|
| Reward | Written and re-tuned by an expert, per task | Generated, gated and revised automatically |
| Ranking | Reward curves and a person's judgment | Measured success on held-out conditions |
| Failures | Rediscovered on the next project | Cataloged, and checked on every future run |
| Supervision | Someone watches every run | Runs stop, advance or report stuck on their own |
| What you receive | A saved model file | A policy, its numbers per condition, and footage |
| New gripper | Start over | About a day of setup; same task, same checks |
07 — Phases
From trained policies to the pipeline in your hands.
Every number on this page is from simulation, and the bridge to real robots is already going in: domain randomization, which varies friction, motor stiffness and sensor noise on every practice attempt, so a policy cannot rely on one perfect simulated world. Real hardware is what comes next.
-
Ready now
Phase 1 — Trained policies per task
We run the pipeline for a given gripper and task and deliver the policy with its held-out success rates and footage. Verified in simulation; two-finger grippers today.
-
Critical next step
Phase 2 — Real-hardware validation
A real gripper and arm in a real cell, with real success rates reported next to the simulated ones.
This is the step that lets us sell the pipeline to companies, and we want to get there as fast as possible. What we need is hardware: a gripper, an arm and a concrete pick, kitting or tending task.
-
As soon as Phase 2 proves it
Phase 3 — The pipeline, licensed to companies
Automation teams run the pipeline on their own robots and tasks. The same pipeline then brings up the Dex Hand: the setup a new gripper needs is exactly the setup a multi-finger hand needs.
Can your robot cell be our first real-world test?A gripper, an arm and a concrete task are all it takes.
Pre-order request →08 — Read more
How we grade a grasp policy.
The blog covers why we rank on held-out conditions, and what the failure catalog caught on its way to a 95% pick-and-place policy.
Contact
Help us get it on real hardware.
Tell us the gripper, the part and what success looks like. We will reply with how we would train it and how we would measure it, in simulation now and in your cell next.
Email us →