Cross-Embodiment Policy Transfer

Overview

A robot can learn a task, but what happens when we want a different robot to do it? I explored that question with two simulated arms: a Franka (Robot A) and a Kinova (Robot B). I wanted to transfer both an existing task and, eventually, improvements learned through further training.

The task

Pick up a banana and place it on or in a bowl. NVIDIA’s GR00T policy—here, the neural network that turns camera views and robot state into actions—was trained for the Franka. The challenge was to make it work on the differently shaped Kinova without training it on Kinova recordings.

Hypotheses

I proposed a fixed adapter: rules between the policy and Robot B that translate observations and actions, with nothing in those rules learned.

  1. Transfer the skill: can the original Franka policy perform the task on the Kinova through that adapter?
  2. Transfer an improvement: if further training improves the policy on the Franka, does the Kinova improve too, without changing the adapter?

The experiment follows three steps: build an adapter, test the original policy on both arms, then train it further on Robot A and evaluate what changes on both robots.

The Methodology

  1. Fixed adapterTranslates between the policy built for Robot A and the different movements and robot state of Robot B.
  2. Cross-paintingChanges the camera images sent to the policy so it sees the familiar Franka arm in place of the Kinova.
  3. P0 → P1P0 is the original policy; P1 is its further-trained version. Does training on Robot A also improve performance on Robot B?
  4. ABBAI integrated NVIDIA Nemotron 3.5 Super VL as a visual supervisor alongside the policy, supporting the decision of when to release.

Nebius × NVIDIA Global AI Hackathon · Physical AI track · October 2026 · solo learning project · simulation only

Robot A · Franka · original policy · 1×Robot B · Kinova · fixed adapter · 6×

Why do this?

If one trained policy could drive many different arms, the expensive part, the training, would only have to happen once. A few things that could lead to:

  • Cheaper than starting from scratch. Two ways to get Robot B to Robot A’s success rate: an adapter, or training B from scratch. Which costs less, in price and in time? I haven’t measured this. It’s something to explore next.
  • Arms that can go to work. Robot arms, and machines in general, could be cross-deployed as workers on a policy that already exists, saving the cost of training a network for each one.
  • Policies for more people. Not everyone can train their own policy: it costs thousands of runs. With an adapter for certain tasks, people could reuse an existing policy. A learned adapter is still an idea; mine is fixed, with nothing in it trained.
Miodrag holding a microphone, pitching his robot idea in front of a screen of live English and Korean captions.

Why I tried this

At the Seoul kickoff, Dhruv talked about training a policy on one robot. My head went straight to: ok, what if we want to use it on another one? That’s cross-embodiment policy transfer, and an adapter seemed like the answer. When I said that to him, he snapped his fingers and shook my hand. So I knew I was onto something.

The idea didn’t come out of nowhere. Days earlier, a business owner told me about a product that solved the problem for one system but needed an adapter for the others. And adapters are how I’d been thinking about MCPs and deterministic LLM workflows, the way you get reliable outputs. Then here was the same word, used for robots.

I presented the idea and took Dhruv’s questions in front of the whole room (that’s the photo). I figured my instincts could lead somewhere interesting, or at least to a great learning experience in the time the hackathon gave me.

Photo: Bloom, from “Physical AI Will Be This Year’s Christmas Gift”

Robot A and Robot B

Both arms have seven joints, but they’re shaped differently and move differently. Their grippers behave differently too: in this simulator, B’s takes 23 control steps to close, where A’s takes 2.

The policy is NVIDIA’s GR00T N1.7, in the version trained on DROID [3], a large set of Franka recordings.

Everything ran in NVIDIA’s Isaac Sim, in RoboLab’s banana-and-bowl scene [4, 5].

The Franka arm
AFrankaThe arm the policy was trained for.
The Kinova Gen3 arm
BKinova Gen3Only ever runs through the adapter.

P0Original policyGR00T exactly as NVIDIA released it [2].

more training on Robot A

P1Fine-tunedP0 after that training. Robot B gave it no data.

The fixed adapter

The adapter translates between the policy and Robot B. It’s fixed rules with nothing trained, in three parts:

  • Kinematic bridgeTurns the Kinova’s joint angles into the ones a Franka in the same pose would have, and the policy’s Franka moves into the same hand moves on the Kinova. Each move is held for 12 control steps so B’s slower gripper can finish closing.
  • Cross-paintingEvery time the policy looks, the outside camera image shows it a Franka where the Kinova is. The idea comes from a paper called Mirage [1]. Finding cross-painting was super fun and interesting.
  • 15 mm liftThis one was my idea. Watching the early painted runs, I instantly noticed the banana hitting the edge of the bowl, so I proposed lifting the arm. Now, while B carries the banana, its hand rises 15 mm so the banana clears the rim.
The simulator camera: Robot B, a Kinova, holding the banana
The camera sees a Kinova
painting
The same moment as the policy sees it: a Franka in the Kinova's place
The policy sees a Frankain the same pose, painted in every time it looks
to GR00T
GR00T N1.7 plans 40 Franka movesand sends the first 8
bridge + lift
Robot B a few seconds later, carrying the banana over the bowl
Robot B makes the same hand moveseach held 12 steps, 15 mm higher while carrying

The policy also reads the arm’s joint angles, and the bridge hands it the Franka version of those too, so the numbers match the picture. Every 8 moves, the loop runs again.

The exact rules

Policy

GR00T N1.7, DROID checkpoint. P0 as released; P1 fine-tuned on Franka wins.

Takes an exterior image, a wrist image, Franka joint and gripper state and the instruction; returns Franka joint targets and a gripper command, replanning every 8 actions.

←↑ to the policy
  • Kinova joints → gripping-frame pose → IK on a virtual Franka → Franka joint state
  • Exterior camera: Kinova hidden, Franka rendered at those joints
  • Wrist camera remounted to the Franka’s pose, not painted
to the Kinova →↓
  • Franka joint targets → Franka FK → gripping-frame pose → Kinova IK → 7 joint targets
  • Each action held for 12 control steps at 15 Hz, at most 0.04 rad per step
  • Hand raised 15 mm once a close is held past 24 control steps, unless it began on or in the bowl (a simulator check)
  • Abort if an IK solve fails or a joint leaves its soft limits

Kinova Gen3

7 joints, Robotiq 2F-85 gripper, in Isaac Sim 5.1 and Isaac Lab 2.3.2 on RoboLab’s banana-in-bowl task.

RoboLab’s functional model of the arm, not a calibrated twin of a physical one.

Fixed, rule-based adapter · frozen before testing · no trained weights

How it got there

  1. BridgePaintingLiftSteered B away from the bananaeven with clean joint readings
  2. BridgePaintingLiftCarried it to the bowl, 3 of 3but the banana kept slipping out on the rim
  3. BridgePaintingLiftOpened over the bowl, banana stayed in!one run, so it can’t prove the lift did it
  4. Frozen 23 OctNo more changesbefore any test run

Watch the progression

Development recordings, before the frozen test. Choose a scene to compare the first two stages; the lift was tried once. These clips show the progression, not a controlled proof of each change.

Bridge only

Without painting, these three runs never completed a grasp and placement.

Robot B · actual exterior view · 12×

Bridge + cross-painting

All three reached the bowl, but lost the banana before the open command.

Robot B · actual exterior view · 12×

Bridge + cross-painting + 15 mm lift

One development run: the gripper opens while holding the banana, which settles in the bowl.

Layout 2002 · seed 0 · only recorded lift trialRobot B · actual exterior view · 6×
Same practice scene, same moments. Both panes show the simulator camera; only the image sent to the policy differs. Painted, the banana is grasped, lifted and carried, then slips onto the bowl from the closed gripper. Unpainted, it never leaves the table. 3× speed.
Implementation details: rendering, timing and the lift

Cross-painting

A rendering copy of the Franka keeps its colliders, so it stays parked 20 m above the cell whenever physics advances. Before each policy request it is moved to the Franka’s base position and posed at the virtual joints. The Kinova’s visuals are hidden, the exterior camera renders, and the scene is restored. This is ground-truth-assisted simulator rendering, not image inpainting, so the policy also sees whatever the Kinova would hide. A real robot would need Mirage’s mask-and-inpaint step [1], which this project does not test.

Timing

In these simulator assets, the Franka’s gripper reaches 95% closure in 2 control steps and the Kinova’s in 23. Holding each policy action for 12 steps gives the slower gripper time to close. The cost is pace: a Kinova episode may run 600 s of simulation where the Franka gets 50 s for the same 750 policy actions.

Lift

Once the policy has held a close command for more than 24 control steps, on a grasp that began with the banana touching neither the bowl nor inside it, the adapter raises the commanded hand 15 mm over 24 steps and lowers it again when the policy opens. That eligibility check uses privileged simulator information: banana–bowl contact and the simulator’s geometric in-bowl test, both from the previous control step. A real Kinova would need its own sensing for both. The lift is a fixed rule, not learned; it was tuned on one development scene and tested once before the freeze.

What the camera-swap checks showed

A matched check held robot state fixed and swapped one input at a time. Its predeclared tilt measure was negative. An exploratory analysis instead found that changing the exterior image moved the 8-step target by 19–116 mm, compared with 4–12 mm repeat noise; changing the wrist image or mapped state stayed within that range. With painting, the target discrepancy was 7.11 mm, against 6.38 mm repeat noise and 74.38 mm unpainted. These checks motivated the intervention; they do not establish that appearance explains every failure.

Watch the adapter at work

With the bridge, cross-painting and lift now in place, this is Robot B carrying out the task. The two views below show the same simulated Kinova run: the outside camera and the image supplied to the policy. The latter replaces the Kinova with a Franka; it does not change the physical robot.

This is the original policy, P0, on test layout 4003. Next, I compare all twelve test layouts on both arms.

Left (top on a phone): simulator camera. Right (bottom): cross-painted policy input. P0 on Robot B, layout 4003, at 3× speed. The policy view refreshes when new actions are requested.

The test: P0 on both robots

With the adapter frozen, I ran the original policy, P0, on 12 layouts it had never seen. A layout is one starting arrangement of the banana and bowl. The same 12 on Robot A and Robot B.

A win means a real release: the robot lets go on purpose, and the banana comes to rest in the bowl. A scoring script, the scorer, judges every run by that rule.

7/12Robot A, Franka
7/12Robot B, Kinova via the adapter

This confirms the first part of my hypothesis: through the fixed adapter, the Franka policy works on the Kinova.

B matched A: 7 wins each! The adapter working was a great moment of relief. They didn’t win on the same layouts, though: only three were wins for both.

Robot A’s seven wins

Robot B’s seven wins

Scorer history and independent AI review

The rule was written after earlier traces had been seen. Its parent rule, v5, agrees with all 21 earlier reviewed verdicts, against 17 of 21 for the older v4 gate; that is consistency, not held-out accuracy. The live v4 gate, which also ends each episode on success, is reported beside it. v4 credits an open only when the banana is already inside the bowl’s volume, so it rejects drops from a few centimetres above the rim.

Before fine-tuning and in checkpoint selection, every v5.1 pass and every flagged fail went to an independent AI reviewer, a Claude agent working from videos, frames and traces under declared rules. It knew whether each episode was a scorer pass or a flagged fail. After fine-tuning, Codex reviewers judged all 24 P1 runs from sampled video frames and event traces, not blinded and not from continuous playback. Their counts are reported next to the locked headline, never pooled with it.

All the numbers: both result tables

Before training (P0)

Robot, policy Locked headlinev5.1 first rest, Wilson 95% AI reviewer Live v4 gate Safety aborts
Franka, P0 7/120.32–0.81 8/12 4/12 —no limit check
Kinova via adapter, P0 7/120.32–0.81 7/12 1/12 4

After training (P1)

Robot, policy Locked headlinev5.1 first rest, Wilson 95% AI reviewer Live v4 gate Safety aborts
Franka, P1 2/120.05–0.45 3/12 1/12 —no limit check
Kinova via adapter, P1 0/120.00–0.24 1/12 0/12 3
Before-test scoring notes
  • Equal counts on 12 layouts mean matched, not proven equal. Read at the end of the episode instead of at the first rest, the counts are 7/12 and 6/12: on Kinova layout 4010 the banana later left the bowl.
  • The reviewer confirmed all 14 scorer wins and found one the scorer missed: on Franka layout 4000 the banana’s lower end kept brushing the rim, so v5.1 never armed.
  • Live v4 is low on both robots for one reason: it rejects an open made more than a short distance above the rim. Five of the six Kinova wins without an abort released 2.4–4.0 cm above the rim; the same rule cost the Franka three wins.
  • The grasp sensors differ, one finger on the Franka and either of two pads on the Kinova. Cross-robot stage rates lean toward the Kinova. Within each robot, P0 and P1 go through the same measurement pipeline; if P1 behaves differently, the scorer’s known blind spots could still bias the measured change.
  • Median time to the opening command among winners, on the policy’s own clock: 8.53 s on the Franka, 8.47 s on the Kinova (descriptive only).
Safety aborts and how they were counted

Safety aborts

Four of the Kinova’s twelve episodes ended on a safety abort. Three (4004, 4005, 4007) were failed IK solves in the adapter’s action map, all with one mechanism: joint 6, a wrist joint, pinned at its lower bound of −2.09 rad with small residuals. That is the solver stuck at a joint limit, not an unreachable target. The fourth, 4006, left a soft joint limit after it had already won. Aborts are task outcomes, scored on the saved partial trace and kept in ΔB, so 4006 counts as a win and the other three as fails. The Franka has no target-limit check, so a target that ends a Kinova episode would not end a Franka one. The completed P1 half had three IK aborts (4000, 4010 and 4011), all retained as failures; the consecutive-abort stop rule did not halt the batch.

Training P0 into P1

Does fine-tuning on one robot carry over to another through a frozen adapter?

Now the second part of my hypothesis. If the policy learns more on Robot A, does Robot B get better too? B gave no training data, and the adapter stayed frozen.

I ran P0 on 32 practice layouts, kept its 27 wins as training demos and fine-tuned it on them once, about 23 minutes of GPU time. Training saved four snapshots of the policy along the way, and the first warning came early: on 8 separate practice layouts, none of them beat P0. The best one became P1 anyway. Then the same 12 test layouts.

Each dot is one test layout, 4000 to 4011, in the same order on every row.

So did B get better? No. P1 got worse on both robots, so there was no improvement on A to carry over to B.

Training settings and checkpoint selection

P1 is P0 fine-tuned on 27 Franka wins approved by the reviewer (it kept 5 other scorer wins out of training), 6,367 frames from 32 practice layouts over two policy seeds. A layout won under both seeds appears twice, and a winning episode keeps its failed sub-attempts. Fine-tuning ran 2,000 steps at batch 32 and learning rate 1e-4 on the projector and diffusion head. The locked selection rule ran P0 and the checkpoints saved at 500, 1,000, 1,500 and 2,000 steps on 8 validation layouts (3000–3007). After the reviewer’s adjudication they won 6, 0, 1, 3 and 3 of 8. No fine-tuned checkpoint beat P0. The rule takes the most wins, ties to the earlier checkpoint, so P1 is checkpoint 1,500, labelled “P1, no A-validation improvement”: the selected fine-tuned checkpoint, not an improved policy. Its 3 of 8 is selection-biased. The after test completed; all 24 P1 episodes and two P0 canaries were copied and verified locally.

Paired statistics, repeat checks and scorer replay
Pre-registered comparison Δ, layoutsP1 − P0 DiscordantP1 only / P0 only Exact McNemar p
ΔA, Franka −5 0 / 5 0.0625
ΔB, Kinova −7 0 / 7 0.01562

Two-sided exact McNemar over the paired layouts. P0 won 7 of 12 on each robot, so P1 can gain at most 5 layouts; 5 to 0 gives p = 0.0625, and only a decline can reach p < 0.05. The after test ran in a separate session from the before test; checks included full pins and a rerun of Franka P0 on layouts 4000–4001, which gave 0/2 v5.1 wins, matching the before half layout by layout. All 12 pairs per robot were scored. The canary trajectories differed, so matching failure outcomes do not rule out drift. A later CPU replay of the locked scorer over all 48 saved before and after episodes reproduced every verdict, with matching scorer and trace hashes, so the automated grading was the same before and after.

Why it got worse

P1 still got the banana to the bowl. What it lost was letting go on purpose.

Did P1 still get the banana to the bowl?

Robot B, runs out of 12

8P08P1

Yes, just as often. Resting on the bowl for 1 s or more, rim included, released or not.

Did it drop the banana mid-carry?

Robot A, runs out of 12

3P06P1

Twice as often. A lifted banana slipped out of the closed gripper.

Did training practise letting go?

The 27 training demos

2of 27

Barely. In only 2 of the 27 demos did the gripper opening ever land in the 8 actions the robot actually runs.

Why would training break letting go?

The policy plans 40 actions ahead, but the robot only runs the first 8, then asks again. So those first 8 are what training most needs to get right. Training learns from 40-action slices of each recording, and my data loader only cut complete slices. So no slice could start in the last 39 actions of a recording, which is right where the release happens. In 25 of the 27 demos, the gripper opening never landed in the first 8 actions of any slice.

My hypothesis: the sampling gap may have contributed to P1’s release failures. A candidate sampling change brings that coverage to 27 of 27 demos, but I ran out of time and credit before I could retrain with it. The cause is not established, and this is not a proven repair.

ABBA 🍌 Alpha Bravo, Bananas Away

By this point I was down to about $2 of GPU credit, with the deadline close. I topped up $3: enough for one more Kinova run, not another training round.

Then I noticed something. Rewatching the last P1 clips, I saw Robot B carry the banana over the bowl on layout 4003 and just hover there, ready to let go, for almost a minute. It never let go. I checked more footage myself to be sure.

P1 on Robot B before ABBA, layout 4003: the banana held over the bowlThe same moment from the wrist camera: the banana right above the bowl
P1 on Robot B, layout 4003, on its own. The banana sat right over the bowl for about 53 seconds. In the end it slipped; it was never let go on purpose.

So carrying wasn’t the problem. Letting go was. What if Nemotron got the right camera views, at the right moment, and the power to make that one call instead of the policy?

That’s ABBA. Nemotron 3.5 Super VL, running on Nebius Token Factory, watched Robot B’s outside and wrist cameras while the gripper was closed. It said WAIT 27 times. Then it said READY, and the arm held still. It looked again at fresh views, confirmed, and the gripper opened.

Nemotron never drives the robot. P1 does all the moving, the whole run. Nemotron overrides it at one moment only, the release: when it says READY the controller freezes the arm, and when it confirms, the controller opens the gripper and keeps it open, whatever P1 wants to do.

ABBA on layout 4003, one assisted run. P1 drives Robot B through the frozen adapter. Left to rightTop to bottom: the simulator camera, the painted image P1 gets, and the wrist camera. Nemotron saw the first and the last. Pick-up 4×, checks 3×, the hold slowed ×10, the release at 1×. The labels burned into the footage are the run’s own: the painted pane always says “P0”, but the policy here was P1.

The earlier unassisted B/P1 run on layout 4003 reached bowl support through a slip and failed the controlled-release criterion. In the separate ABBA run, Nemotron triggered a commanded release that passed the unchanged scorer. This demonstrates the assisted-release mechanism once; it does not establish a repeatable improvement or isolate Nemotron’s contribution from the controller’s hold and latched-open behavior.

When I saw the footage that it worked, I was super stoked. 29 Nemotron calls, $0.0223 in total.

I wish I’d had time for a sturdier way to tell when the banana is over the bowl, like a QR code on the bowl, or depth sensing. I’d brought that up with Dhruv during my Seoul presentation, and a depth version was built and tested locally, but there was no credit left to run it, and truly no time to get it to a level I’d be happy with.

Layout 4003 was picked, not drawn: it was the only P1 Kinova run with a long, centred carry over the bowl.

Run timing, vision checks, evidence and limitations

How it ran. The Kinova ran P1 through the unchanged painted adapter on layout 4003, policy seed 0, for 3,600 controls (240 simulated seconds). While the gripper was closed, Nemotron looked at the Kinova’s real exterior camera and its wrist camera; the simulation paused for each call, and P1 kept acting between checks. Counting the runner’s ticks from 0, it said WAIT 27 times, every 12 ticks from the first gripper close at tick 672 to tick 984. At tick 996 it said READY and the controller held the arm. At tick 1005 it confirmed READY from fresh views, and the open command executed at control 1006; the controller kept the gripper open from then on. The 29 calls cost $0.0223 from returned token counts, with 56.5 s of model wait.

The unchanged v5.1 scorer, the rule behind every result above, scores a PASS at control 1071, with the banana still on the bowl at the end. At the open, the banana’s root was 4.98 cm from the bowl centre, measured horizontally, and its centre 10.5 cm above the bowl top; Nemotron never saw these evaluation-only numbers. The runner’s older live v4 checker reported no success: it ruled the open ineligible. v5.1 stays the primary rule because the before and after results were scored with it.

Why a vision check first. Instead of the intent demo’s robot run (see “Before ABBA”, below), I proposed DROP: a Nemotron vision model watching P1 carry the banana on the Kinova and deciding when to let go. The vision model, Nemotron 3.5 Super VL, had named the banana and the bowl in 12 of 12 start frames, an easy test with only two objects on the table. On saved frames from the P1 Kinova runs, it passed a small screen of held, approaching and already-resting cases after two failed prompt rounds, but near the rim it still said “ready to release” in 4 of 4 cases with the banana 5–8 cm off the bowl’s centre and 2 of 4 at 8–12 cm (69 calls, $0.0522). That was not selective enough to trust with the gripper on its own.

  • One assisted run on one selected layout. It is not a success rate, not a controlled or paired comparison, and not a repair of training; the results above stand.
  • Picked, not drawn. 4003 was the only P1 Kinova layout with a long, centred carry over the bowl in the after test. That earlier run is not a matched pair: the intervention changes everything after the hold.
  • “Central” is not a measurement. Nemotron called the banana central; it was about 5 cm off.
  • The controller did part of the work. The hold and the latched open are controller behaviour around the model’s decisions.
  • What P1 alone would have done is unknown. After the forced open, P1’s own gripper command also turned to open from control 1096, after 90 controls of the latched open; why it switched isn’t known.

Before launch, the package had 43 CPU tests and an implementer review, but no independent review of the final runner. Afterward, an independent AI review re-hashed all 298 copied evidence files, reproduced the frozen score and checked the cost ledger. The RGB-D capture and intent-control robot experiments never ran. Across all Nemotron experiments, 439 calls totalled $0.1441 at prices applied to returned token counts; this is not a provider billing receipt.

Before ABBA: what else I tried with Nemotron

Nemotron’s job here is to turn a plain request into a structured task spec a program can check. NVIDIA Nemotron 3.5 Lightning (nvidia/Nemotron-3_5-Lightning) on Nebius Token Factory takes a request such as “put the fruit away” and returns the object and the target, named from the scene’s own objects, where the object should end up, and the conditions a success has to meet, such as whether the gripper must be opened on purpose and whether the bowl’s rim counts.

The parsing ran; the robot run did not. The spec also carries the one sentence the robot’s policy should get and whether this robot should try at all, and a fixed local rule has to agree before anything moves. Each request was asked three times, and the robot would only get an answer given every time. With my first prompt, Nemotron declined “put the fruit away” as naming an object not in the scene, refused to move the bowl as expected, and its three repeats split on “put the banana beside the bowl, on its left”. A second prompt, written after seeing those answers and disclosed as such, gave the same answer on all three repeats of all three requests. The planned run of the unchanged policy (P0) on the Franka with those specs was never performed; 87 offline tests are all the checking it got.

An earlier version of the compile step, the intent contract, was tested on its own: 11 instructions, three runs each, from RoboLab’s own wording and paraphrases to five adversarial ones. On the adversarial five, all 42 field checks matched a faithful reading: “the apple” came back as not in the scene, “don’t let go of it” turned off the release requirement, and “the edge of the bowl” became the rim. It also exposed a real gap: it read “in the bowl” literally, so the rim didn’t count in any of the 18 runs on the six ordinary instructions, while the project’s win rule counts it.

Is a bigger model better here? Not on this test. I sent the same 11 instructions, five of them traps like “put the banana in the bowl but don’t let go of it”, three times each to four Nemotron models on Token Factory, with the rule for picking a winner written down before the first call. Lightning, Super (120B) and Ultra (550B) got every trap right and gave the same answer on every repeat; Nano ignored “don’t let go” all three times. On a tie the cheapest wins, so Lightning stays: 33 calls for a fifth of a cent. Five traps can’t tell the top three apart, so this doesn’t show the bigger models are no better on harder requests.

I also tried using Nemotron to grade runs from their text logs; on 24 runs it did no better than always guessing “success”, so the locked scorer and an independent reviewer do the grading. The 178 Nemotron calls before the comparison cost $0.02, per the Token Factory usage page.

Nemotron’s second job, deciding when the Kinova lets go, did reach the robot: that’s ABBA, above.

The experiment at a glance

  1. What the policy sees: a Franka painted where the Kinova is
    Build the adapterRules that translate between the policy and Robot B, plus the painted Franka from the video.
  2. Robot B, the Kinova, winning on one of the twelve
    Test it on both armsTwelve setups the policy had never seen, the same on both arms. It wins 7 of 12 on each.First part: confirmed
  3. Robot B's wrist camera after the extra training: the banana held over the bowl, never let go
    Train it more on Robot AI trained the policy on 27 of its own wins on Robot A. Both arms got worse: A won 2 of 12, B none. B often still carried the banana to the bowl, but none of its twelve runs passed the locked controlled-release score.Second part: not confirmed
  4. Robot B's wrist camera: gripper open, banana in the bowl
    Alpha Bravo, Bananas AwayOut of credits and time, I let a language model, Nemotron, make one decision: when to let go. It worked, once!

Limits

This is one small experiment. Everything ran in simulation: 12 test layouts per robot, one training run, one ABBA run. Painting and the lift use simulator information a real robot wouldn’t have. So it doesn’t show the adapter working on a real robot, that fine-tuning can’t help, or that ABBA works every time.

With more time, or more Nebius credits, I’d have loved to explore this further and come back with results you can actually rely on.

Full limitations and measurement caveats
  • Simulation only. I didn’t have access to a physical robot arm (see What I’d do next), so everything here runs in simulation. The Kinova is a separately simulated 7-joint arm with its own kinematics and gripper drive, not a re-skinned Franka, but RoboLab’s model is functional rather than a calibrated twin.
  • The adapter is fixed and frozen; nothing in it is learned. Its three parts are a kinematic bridge, exterior cross-painting and a 15 mm lift. Two of them use privileged simulator information: painting renders from simulator state, including what the Kinova occludes, and the lift’s eligibility check reads banana–bowl contact and the simulator’s geometric in-bowl test. The live v4 gate that ends episodes on both robots also reads simulator object and contact state; it stops episodes but does not steer them. The wrist camera was remounted to match the Franka’s.
  • Twelve layouts give wide intervals, 0.32–0.81 for 7/12. Equal counts are a match, not proof of equality.
  • The grasp sensors differ between the robots, which biases cross-robot stage rates toward the Kinova. Within each robot, P0 and P1 use the same measurement pipeline, but if P1 behaves differently, the scorer’s known blind spots could still bias the measured change. One example: the Kinova’s two pads stay in contact through a set-down, so a set-down can reach a scorable open. None of the seven Kinova P0 wins was a set-down; if P1 sets down more often, ΔB could count wins the Franka’s sensor would not.
  • AI review is supplementary, not human adjudication. Reviewers were not blinded. Before-test review covered scorer passes and flagged failures; after-test review covered all 24 P1 runs using sampled frames and event traces. Disagreements are reported separately.
  • One training run and one policy seed per test layout. These results describe this experiment, not fine-tuning in general. The sampling issue is an untested explanation, and repeated trajectories differed even when outcomes matched.
  • Rules shaped by earlier data. The win rule was written after earlier traces had been seen; the 15 mm lift was tuned on one scene; the rule that a drop counts was formalised after the one lift run had been seen. A second practice pass at policy seed 1 was made unconditional after the first pass’s win count was known, and is logged as a deviation. The test layouts were untouched by all of it.
  • Scorer noise. On the Franka, the banana’s reported angular speed at rest sits near the scorer’s 0.3 rad/s stillness limit, which can delay or block a win; the Kinova’s floor has not been measured. P0 and P1 on one robot go through the same check, but if P1’s rests differ, the noise could still shift Δ, and absolute win rates may be undercounted. An exploratory pose-based variant, declared 12 minutes after the before half started and before any outcome was inspected, matched the headline on it.

What I’d do next

Honestly? Start again from scratch, with everything I learned. I figured this out as I went, and that wasn’t efficient or accurate.

Two things pushed it that way. Time and money: with the deadline close and the credits running out, there was never room to stop and redo things properly. My agents: Claude and Codex, the AI coding tools I worked with. To make the deadline, they did most of the hands-on work in the second half, and while I directed them at every step, I don’t know the ins and outs the way I’d like to.

For real research I’d do much more of it myself: dig into the adapter and other adapter methods, understand every piece, and solve the problem the way I think it should be solved. The open threads from this round come with me: test the proposed training-data sampling repair, and repeat ABBA across many layouts.

There was a bigger plan too, and it never got started. We ran out of resources and time. The idea was to keep P1 fixed and train one shared adapter, a learned one this time, on Robot B and three more arms, C, D and E, then test it on three arms it never practised on, F, G and H. Does an adapter learn something that carries over to robots it has never seen?

It stays in simulation for now. I asked about my university’s Kinova arms, the exact model I’d need, but they’re booked for coursework while the course runs.

What I learned

This was my first hands-on project in machine learning and robotics. I started on 4 October with this notebook, and page one was a list of “What is…?” questions. I did the setup myself, step by step, until the commands and ideas made sense.

What I learned

My biggest lesson was how much research and planning goes into robot learning before training even starts. This project made me want to pursue a career in robotics and machine learning. I’d love the opportunity to keep working on this problem.

The “What is…?” questions on page one, I understand better now. But I didn’t know yet what there was to learn. Roughly, it turned out to be this:

Cloud and infrastructure
Setting up a VM and GPU storage on Nebius, security groups, SSH and what’s under it (ed25519 keys, sha256 fingerprints, TOFU), CIDR, tenants and projects, and a lot more computing and networking in general.
How robots learn
What a neural network is and how it works. A policy vs a neural network vs an actor. Five kinds of policy, a neural network being one of them. PPO, the actor and critic, and the environment actually pulling it off. Training vs play, observation groups and corruption, rsl-rl.
Simulation
Linux commands, Isaac Sim and Isaac Lab, joint stiffness, damping, velocity and effort limits, and how my whole project fits together: the Python environment, the Isaac Lab source and my own files.
The one this project is about
A fixed adapter vs a learned one.

The first policy I trained was far too simple: move the hand to a target, no banana, no grasp. It proved the setup worked. On 21 October I switched to the banana-and-bowl task and GR00T N1.7.

My notes stop around 21 October. As the deadline got closer, I moved from doing every setup step myself to directing Claude and Codex, watching the results and deciding what to try next.

What to remember

  • A fixed adapter was enough to start. Rules and a painted-in Franka let a Franka policy drive a Kinova: 7 of 12 on both arms, with no Kinova training.
  • The painting mattered. With the bridge alone, the policy steered the Kinova away from the banana. Once it saw a Franka, it carried the banana to the bowl, 3 of 3 in practice.
  • More training made it worse. Fine-tuning on 27 Franka wins took Robot A from 7 to 2 and Robot B from 7 to 0. The audit found a possible sampling gap around letting go; it has not been proven to explain the decline.
  • A language model can patch one decision. Nemotron timed the release once, for $0.0223.

References and credits

  1. [1]L. Y. Chen, K. Hari, K. Dharmarajan, C. Xu, Q. Vuong, K. Goldberg. Mirage: Cross-Embodiment Zero-Shot Policy Transfer with Cross-Painting. Robotics: Science and Systems (RSS), 2024. arXiv:2402.19249. Project page.
  2. [2]NVIDIA. GR00T N1.7, DROID checkpoint, served and fine-tuned with Isaac-GR00T.
  3. [3]A. Khazatsky et al. DROID: A Large-Scale In-The-Wild Robot Manipulation Dataset. arXiv:2403.12945, 2024.
  4. [4]NVIDIA. RoboLab: the banana-in-bowl task, the DROID Franka and Kinova Gen3 configurations, and the GR00T client.
  5. [5]NVIDIA. Isaac Sim 5.1 and Isaac Lab 2.3.2.

Compute: GR00T N1.7 and Isaac Sim ran on a Nebius AI Cloud VM with one NVIDIA RTX PRO 6000 Blackwell. NVIDIA Nemotron 3.5 Lightning handled task specifications; Nemotron 3.5 Super VL handled saved-frame vision checks and ABBA, both through Nebius Token Factory. Simulation footage is from this project’s own runs.

Tools and assistance

This is my solo project. I chose the direction, watched the footage, shaped the experiments and made the scope and budget decisions. I used Claude and Codex for research assistance, implementation, experiment operation, analysis, drafting and review. From around 21 October they did much of the implementation under my direction. Reviewers named in the results are separate AI agents, not human experts; their findings and the locked scores remain distinct. The technical report records the detailed provenance. No institutional affiliation or sponsorship is claimed.

Thank you to NVIDIA, Nebius, Tavily, and Bloom Korea for the opportunity to participate. Dhruv Diddi’s Seoul kickoff presentation introduced the robot-transfer problem that inspired this project.