Physical Agent
Loading the scene
Cyberspace
The two camera views the agent receives this turn
what the agent sees this turn
Turn 1 of 12reasoning

About this film

A real episode, replayed. The 96 targets the arm follows, the reasoning and the camera views are the agent's own. The scene is restyled, and Ninelong the egg is our mascot.

✓Bowl on the plate12 turns · 96 control steps

Physical AgentLearning Manipulation in the Native Distribution Retains Reasoning and In-Context Learning

TL;DR

We post-trained an open 4B general-purpose agent into a physical agent, on four B200 GPUs and about 1k robot demonstrations. After training it does robot tasks on par with a VLA built from the same model and data, and it is still a general agent: it keeps reasoning, keeps answering questions about images, and learns new tasks from demonstrations placed in its context.

On LIBERO it succeeds in 79.2% of rollouts, level with the VLA-style baseline at 80.0%, and it does better when the instruction changes (23.3% against 15.0%). Its general capabilities stay largely intact: 56.8% on MMLU-Pro against 61.8% before training, and 53.7% on MMMU against 46.8%, where the baseline scores zero on both. The key result is in-context learning. Given one robot demonstration in its context and no parameter update, it succeeds more often: from 44.8% to 56.2% over 21 tasks, and from 17.1% to 31.4% on the hard ones, nearly double. The VLA-style baseline cannot do this. With the same demonstration, its success falls to zero. We never trained for it; the ability is inherited from the general-purpose agent.

1What a physical agent is, and how it works

Physical agent

A general-purpose agent that sees with its own vision, reasons in language, and acts through physical tool calls: native tool calls whose arguments are end-effector targets. It learns physical skills through physical post-training, and remains a general agent.

Compared with a VLA and Code as Policies

VLA
pθ( at, …, at+K−1 | I, ot )
LearnsNative interface
→
VLA+ action head
→
atat+1…at+K−1
→
Code as Policies
pLLM( code | I, APIs )
LearnsNative interface
detect()
pick()
place_on()
→
LLMfrozen
→
bowl = detect("black bowl")plate = detect("plate")pick(bowl)place_on(bowl, plate)
→
Skill library 
→
Physical agent
pθ( rt, at | I, o1, r1, a1, …, ot )
LearnsNative interface
→
o seer thinka act
Figure 1. What the model produces, and what it conditions on. The top two lanes are schematic; some VLAs also take history. The bottom lane replays a recorded episode.

Like a VLA, it learns from robot data. Unlike a VLA, its action is a native tool call rather than an added action head, so reasoning, history and in-context learning carry over.

Like Code as Policies, it acts in the model's native interface. Unlike Code as Policies, the model is trained, and it perceives and controls by itself instead of calling perception APIs and a skill library.

Code as Policies: Liang et al., 2023. VLA examples: OpenVLA (Kim et al., 2024) and π0.5 (Black et al., 2025).

The agent loop

The instruction is given once. In each turn the agent receives two camera views, writes a short reasoning paragraph and one tool call, and gets back a tool response that only says the call ran. Whether a grasp held, or the task is done, it has to judge from the next views.

The agent receives

User, once at the start
pick up the black bowl between the plate and the ramekin and place it on the plate
Observation · turn 1 of 12
Agent view and wrist view for the selected turnagent viewwrist view

The agent writes

Agent reasoning
Agent tool call
Tool response, then the next views
Figure 2. The 12 turns of the episode shown at the top of the page. The text is the model's verbatim output. Each tool call carries eight targets; the code shows the first and the chart plots all eight.

Physical post-training

DataDemonstrations to agent interactions

About 1k demonstrations become 21,267 decisions. Each is a tool call of up to eight targets, with reasoning added by a teacher model.

Stage 1 · 16 epochsSingle-turn training

Instruction and current views in, reasoning and tool call out.

Stage 2 · 2 epochsHistory-conditioned training

Whole conversations, so each decision also sees the earlier turns.

All parameters are updated, including the vision encoder, with next-token cross-entropy.

2Learning physical skills from a general-purpose agent

Physical Agent performs close to the Qwen4B-OFT baseline on the original tasks, and better under task and position perturbations.

Qwen4B-OFT is the baseline: the same Qwen3.5-4B and the same 1k demonstrations, with a continuous action head instead of tool calls.

Success rate (%)

Qwen4B-OFTPhysical Agent
80.0
79.2−0.8
15.0
23.3+8.3
0.0
5.8+5.8
Originalas trained
Task perturbationsame scene, new instruction
Position perturbationsame instruction, objects moved
Figure 3. Average success rate over 120 rollouts per bar. Perturbations are from LIBERO-PRO; the images show one LIBERO-Object scene under each condition.
OriginalTask perturbationPosition perturbation
SuiteQwen4B-OFTOFTPhysical AgentOursQwen4B-OFTOFTPhysical AgentOursQwen4B-OFTOFTPhysical AgentOurs
Spatial76.783.340.040.00.013.3
Object100.0100.010.010.00.03.3
Goal80.073.33.323.30.06.7
Long63.360.06.720.00.00.0
Average80.079.215.023.30.05.8
Published averages reported by LIBERO-PRO, for context only
π0 (3B)92.30.00.0
π0.5 (3B)96.50.820.8

On the original tasks the two are within one point. Under task perturbation, Physical Agent reaches 23.3% against 15.0%, with the gains in Goal and Long. Position perturbation remains hard for both.

3Still a general agent

Two models with the same manipulation score end up very different as general models.

Original Qwen3.5-4BPhysical AgentQwen4B-OFT
61.8
56.8
0.0
46.8
53.7
0.0
13.3
20.0
0.0
MMLU-Pro280 questions
MMMU900 questions
AIME30 questions, one sample
Figure 4. Accuracy (%) before and after physical post-training. Unparsed answers count as wrong. The OFT MMLU-Pro entry is derived from an existing 16K-token run. AIME is a single sample per question and several answers are unresolved, so treat it as indicative.

Physical Agent updates every parameter on robot data, with no general-data co-training and no frozen modules, and still answers general questions: 56.8% on MMLU-Pro, down five points from the original model. The action-head model, which keeps its language head, produces no parseable correct answers.

4In-context learning

Language agents pick up a new task from an example in the prompt. We study whether a physical agent can do the same, and find that it can.

Show the agent one demonstration of a task it has not been trained on, and it succeeds more often. We never trained it to do this.

We test on LIBERO-PRO task perturbations, with no parameter updates. A task demo shows the evaluated task from another initial state; a distractor demo shows a different task in the same scene.

What goes into the first turn

systemtool schema
in-context demonstrationno demonstration
Demonstration observation 1: scene view and wrist viewtool call8 targets
Demonstration observation 2: scene view and wrist viewtool call8 targets
Demonstration observation 3: scene view and wrist viewtool call8 targets
userCurrent observation: scene view and wrist view“put the wine bottle in the bowl”
agentreasoningtool call8 targets
Figure 5. A demonstration is three observations, each followed by the eight targets the expert executed, placed before the current observation.

Success rate (%)

All 21 tasks105 rollouts per bar

44.8
no
demo
56.2+11.4
task
demo
36.2
distractor
demo

Physical Agent

31.4
no
demo
0.0
task
demo
1.0
distractor
demo

Qwen4B-OFT

Hard 7 tasks35 rollouts per bar

17.1
no
demo
31.4+14.3
task
demo
14.3
distractor
demo

Physical Agent

2.9
no
demo
0.0
task
demo
0.0
distractor
demo

Qwen4B-OFT

Figure 6. Success rate with and without an in-context demonstration. The dashed line marks each model's no-demo level. Both models start from the same Qwen3.5-4B and the same 1k training demonstrations.

A task demo helps and a distractor demo hurts. Across all 21 tasks a task demo raises success from 44.8% to 56.2%. A distractor demo lowers it to 36.2%. That 20-point gap between the two shows the agent is reading what the demonstration does, not just benefiting from more context. On the hard subset, a task demo nearly doubles success, from 17.1% to 31.4%.

The action-head model cannot act with the longer context at all. Qwen4B-OFT solves 31.4% of the tasks with no demonstration and essentially none with either kind. It was trained only on current observations; Physical Agent was trained to act on its own history, and a demonstration is just more history in the same format.

“put the wine bottle in the bowl”

Final views without a demonstrationno demo

0 / 5never grasps the bottle

Final views with a task demonstrationtask demo

3 / 5bottle in the bowl

“pick the alphabet soup and place it in the basket”

Final views with a distractor demonstrationdistractor demo

0 / 5reaches for the cream cheese

Final views with a task demonstrationtask demo

5 / 5soup in the basket

Figure 7. Final observations (scene view left, wrist view right) and successes out of five trials.

5Four GPUs, a 4B model

We fine-tune a 4B model on four B200 GPUs, in under 50 GPU-hours.

~1,000×fewer training GPU-hours than PEAR, a physical-agent-like model.
Robot-Use RL (PEAR)27B · RL in simulation · no demos
≈ 50,000
Physical Agent4B · two-stage SFT · 1k demos
< 50
1101001k10k100k1M
Figure 8. Training compute in GPU-hours, log scale. Ours is on four B200 GPUs; PEAR's is in H100-equivalent hours as reported by its authors, so read the ratio as an order of magnitude.
Physical AgentRobot-Use RL (PEAR)
Starting modelQwen3.5-4BQwen3.8-27B
SupervisionAbout 1k demonstrationsTask success only
Training16 + 2 epochs of SFT340 RL steps
Hardware4 GPUsH100, H200 and GB300 nodes
GPU-hours< 50≈ 50,000
LIBERO79.2% 120 rollouts74.4% 2,000 episodes
LIBERO-PRO, task perturbation23.3%57.4%
Real robotNot evaluated60% of 30 trials

PEAR numbers are quoted from its project page; evaluation protocols differ.

6Reflection and recovery from execution errors

Every demonstration it learned from is a success. Nobody showed it a failed grasp, or what to do after one. In natural rollouts it still recovers from some of its own grasp failures.

Three natural rollouts

The gripper closes on a ketchup bottle The gripper has lifted and the bottle is still on the floor The gripper lowers onto the bottle again The bottle is lifted with the gripper 1Attempt
  1. 1

    Attemptclose and test the lift

    Closes on the bottle and lifts.

  2. 2

    Mismatchmodel reflection

    “The previous lift did not give me confirmed grasp evidence …”

  3. 3

    Correctcorrective action

    “I open the fingers and lower back toward the target to re-establish a better alignment.”

  4. 4

    Verifyobject follows the gripper

    The bottle lifts with the gripper.

15 of 80 rollouts had a failed grasp.

8 recovered
5 not recovered
2 unresolved

Reflection after the first failure, in 14 of them.

2 explicit recognition
8 expressed uncertainty
4 no recognition
Figure 9. Three natural rollouts in which Physical Agent recovers from a failed grasp. Quotes are its own reasoning; frames are re-rendered from a closer camera.

7Limitations and future directions

This is a first version, trained on four GPUs. Here is where it stands today and where we are taking it next.

EmbodimentReal-robot deployment
Now
LIBERO and LIBERO-PRO in simulation, with one Franka arm.
Next
Real hardware and more embodiments, behind the same tool call.
ScaleLarge-scale reinforcement learning
Now
About 1k successful demonstrations and no practice of its own. Perturbed tasks reach 23.3% and shifted positions 5.8%.
Next
Large-scale reinforcement learning on the agent's own rollouts.
ContextIn-context learning
Now
One demonstration in the prompt lifts success from 44.8% to 56.2%, with no parameter update.
Next
  • Context to start RL. Where the zero-shot success rate is zero, reinforcement learning has no signal. A demonstration in context can make it non-zero, and then RL can begin.
  • On-policy self-distillation (OPD). The agent with a demonstration in context teaches the same agent without one, on its own rollouts, so what context unlocks ends up in the weights.
EfficiencyInference speed and reasoning efficiency
Now
Every turn writes a paragraph of reasoning and eight targets, one token at a time, which is slower than real-time control.
Next
  • Multi-token prediction. Predict several action tokens in one step instead of one at a time.
  • Efficient thinking. It reasons more than it needs to today. Think only when the situation calls for it.
  • Epistemic reasoning. Sometimes act first. Test a guess with an action instead of speculating in text, and update beliefs from what happens.

Work with us

Everything on this page was trained on four GPUs. The next step needs many more.

We want to take physical agents from supervised post-training to large-scale reinforcement learning, where the agent improves from its own experience instead of demonstrations. That takes far more compute than we have today: we are short on GPUs.

We are looking for collaborators. If your lab is at a U.S. university and you work on robot learning, agents or large-scale RL, or you have GPU capacity to put behind this direction, we would like to hear from you.

Contact: ryan91@gatech.edu

BibTeX

@misc{xu2026physicalagent,
  title        = {{Physical Agent}: Learning Manipulation in the Native Distribution
                  Retains Reasoning and In-Context Learning},
  author       = {Xu, Junxiao and Yan, Rui and Zhao, Ye},
  year         = {2026},
  howpublished = {\url{the address of this page}},
  note         = {Project website}
}