Agent-as-Policy/agent-as-policy-robodojo

Agent as Policy — RoboDojo Simulation Episodes

Paper · Project page · Code · RoboDojo submission (XPolicyLab PR #182) · Real-robot dataset

Summary

2,100 simulated episodes of the RoboDojo benchmark in which an LLM agent acts directly as the policy of a dual-arm ARX X5 robot: gpt-6-astra, running in codex at reasoning effort high, sees the official RGB cameras and the arms' state through MCP tools, measures points in the images, sends multi-step motion programs and judges its own completion. There are no trained weights. The release is the complete seed 0 of the official evaluation as it was scored: 42 tasks × 50 episodes (the 12 Generalization tasks as 25 standard + 25 randomized layouts) — exactly the episodes behind the official summary below. One row per episode, and the row replays it: every message of the agent, every tool call with its arguments and its result, and a key for every image the model received. The accompanying paper is Agent as Policy for Robotic Manipulation.

Beside the 944.8 MiB table: the three official camera recordings of every episode (10.51 GiB), 108,987 images the model received as WebDataset shards (36.65 GiB), the complete event stream of every episode (17.8 MiB), the prompts and the tool interface, and the official result files.

Results

The official RoboDojo summary, produced by the summarize script over these episodes (results/seed0/_summary.md).

	Generalization	Precision	Long-Horizon	Memory	Open	Average
success rate (%)	54.67	44.00	28.75	91.00	62.25	56.13
score	59.79	50.90	49.48	92.22	65.75	63.63

The Generalization dimension merges each task's 25 standard and 25 randomized (_random) layouts: standard 58.00 % / 62.67, randomized 51.33 % / 56.92. Score is RoboDojo's partial-credit score (0–1 per episode, ×100 here); success counts only complete success.

The 2,100 episodes took 300.6 h of wall clock from episode start to official end: 92.6 h inside tool calls (simulation, rendering, motion planning and measurement) and 208.0 h outside them (model inference and codex); the simulated robot time was 14.30 h.

Per task (the tasks config holds the same 42 cells, with the median and total wall clock):

task	dimension	n	success	SR (%)	score	median wall s	SR standard / random
align_blocks	Open	50	50	100	100.00	108
arrange_largest_number	Generalization	50	46	92	93.50	428	100 / 84
build_tower	Precision	50	34	68	73.80	751
classify_objects	Long-Horizon	50	46	92	94.40	480
classify_objects_by_language	Open	50	30	60	73.00	590
cover_blocks	Memory	50	48	96	96.00	383
deposit_coin	Precision	50	10	20	33.20	319
fasten_screws	Precision	50	45	90	94.40	521
fill_egg_holder	Long-Horizon	50	0	0	12.30	431
fill_pen_holder	Long-Horizon	50	1	2	31.20	852
fold_clothes	Generalization	50	37	74	78.80	294	84 / 64
general_pickup	Open	50	48	96	96.00	81
hang_mugs	Generalization	50	3	6	22.00	793	12 / 0
imitate_sorting_sequence	Memory	50	40	80	87.30	650
insert_key	Precision	50	0	0	15.00	331
insert_tubes	Precision	50	22	44	60.80	408
make_kong	Long-Horizon	50	1	2	2.00	483
make_toast	Generalization	50	4	8	12.00	1394	12 / 4
match_and_pick_from_conveyor	Memory	50	48	96	96.00	239
organize_table	Long-Horizon	50	16	32	74.50	796
pack_objects_into_box	Generalization	50	12	24	45.30	955	24 / 24
pick_from_conveyor_by_image	Open	50	28	56	56.00	659
play_Xylophone	Precision	50	45	90	90.00	270
play_stacking_toy	Long-Horizon	50	3	6	45.80	876
play_tic_tac_toe	Long-Horizon	50	31	62	77.00	503
plug_in_charger	Precision	50	2	4	4.00	384
pour_balls_into_vase	Precision	50	18	36	36.00	376
pour_by_language	Open	50	1	2	7.20	660
pour_liquid_into_cup	Generalization	50	7	14	14.00	467	12 / 16
press_by_number	Memory	50	42	84	84.00	229
push_T	Generalization	50	50	100	100.00	158	100 / 100
put_bottles_into_dustbin	Long-Horizon	50	17	34	58.60	506
solve_equation	Open	50	45	90	90.00	131
sort_nesting_dolls_by_size	Generalization	50	37	74	74.00	689	80 / 68
stack_blocks	Generalization	50	50	100	100.00	273	100 / 100
stack_blocks_by_language	Open	50	47	94	94.80	264
stack_bowls	Generalization	50	44	88	89.50	366	88 / 88
store_laptop_and_headphones	Generalization	50	0	0	12.40	832	0 / 0
store_tools_in_toolbox	Open	50	0	0	9.00	798
swap_T	Memory	50	47	94	94.00	244
swap_blocks	Memory	50	48	96	96.00	374
sweep_blocks	Generalization	50	38	76	76.00	594	84 / 68

How seed 0 was assembled

• Layouts. RoboDojo evaluates each task on fixed layouts of seed 0: layouts 0–49, and for the 12 Generalization tasks layouts 0–24 of the standard configuration and 0–24 of its _random configuration.
• Refills. As the official evaluator does, an episode found unstable is not counted, and its layout is replaced by the next layout after the evaluation range (50, 51, …). 16 episodes were unstable — 10 failed the layout stability check before starting, 6 were marked unstable after running — and the 15 refill episodes that replaced them are rows of the table (layout_role = refill); the 16 unstable episodes are kept aside in unstable/, with the same columns.
• One released attempt per configuration and layout. An episode that ended in an infrastructure failure was run again; only the re-run is released, and every attempt not released is listed with its reason in EXCLUDE_s0.csv; RELEASE_s0.csv lists the released episodes.

The episodes table

One split, evaluated: 2,100 rows, ordered by layout then task. 27 columns; the media come right after the identity columns so the Viewer opens on them.

group	columns	what a value is
identity	episode_id, task, layout_id	s0_l<layout:03d>_<task>; the RoboDojo task configuration (e.g. stack_blocks_random); the layout
media	frame_first, frame_last, video_preview	the first and last frame of the official head recording (JPEG, 640×480), and that recording re-encoded 480 px wide at its own 25 fps — a frame is an official action
condition	seed, base_task, variant, category, layout_role, model, backend, effort	seed 0; the task without _random; standard / random for the Generalization tasks; the official dimension; eval or refill; gpt-6-astra, codex, high
result	outcome, score, total_wall_s, official{take_action_cnt, action_budget, ended_by}	the official verdict (success / fail) and score (0–1); the episode's wall clock in seconds, from its start to the official end (the simulator's boot before the episode is not counted); the actions the evaluator counted, the task's action budget, and how the episode ended
counts	timing{start_epoch_s, end_epoch_s, total_wall_s, agent_s, sim_s, sim_clock_s}, tokens{input, cached_input, output, reasoning}, tools{calls, observe, measure, run, step, assess, action_status, errors}	start and end (Unix seconds); total_wall_s split into sim_s, the wall time spent inside tool calls (simulator stepping, rendering, motion planning, measurement), and agent_s, everything outside them (model inference, codex) — agent_s + sim_s = total_wall_s; sim_clock_s, the simulated seconds (0.04 s per action); the session's token totals; tool calls by name
the run	agent_messages, traces[]	the agent's messages in order, and the episode step by step — see below
documents	instruction, prompt_text	the official task instruction of the episode, and the full prompt the agent was given
files	videos[camera, url, bytes], trace_url	the three official recordings, and the complete event stream

traces[] — the episode, step by step

81,279 steps over the 2,100 rows (median 36 per episode). Step 0 is the launch: the observation the agent was given before it started (the launch message and the three camera images); then one element per message, tool call and error, in order.

field	meaning
step, item_id	position in the episode (0-based, dense), and codex's own id of the item ('' for the launch and for stream errors)
kind	launch, message (the agent's own words), tool_call, error (a harness error, e.g. a reconnect)
tool, arguments_json	the tool and its arguments as the agent sent them
text	the message, or the error text
output, output_truncated	the tool result as text, every image replaced by <image KEY>; clipped at 2,000 characters (head 70 %, tail 30 %) — the complete result is in traces/<episode_id>.jsonl.gz
ok	true when the call completed, false when the tool reported a failure, null when the call was still running as the episode ended
image_keys	the view keys of the images on this step, in order: the WebDataset keys under views/

Files beside the table

path	files	size	what
episodes/episodes-s0-NNNN.parquet	105	944.8 MiB	the table: 2,100 rows, 105 shards of 20 rows, one row per row group
tasks/tasks-s0.parquet	1	108 KiB	the tasks config: the 42 official per-task cells
unstable/episodes_unstable-s0-0000.parquet	1	327 KiB	the 16 unstable episodes, same columns, beside the table (not a split)
videos/<episode_id>/{head,left_wrist,right_wrist}.mp4 + videos/metadata.csv	6,301	10.51 GiB	the official recordings
traces/<episode_id>.jsonl.gz	2,106	17.8 MiB	the complete event stream of each episode that ran, images replaced by view keys
views/views-s0-NNNN.tar + views/metadata.csv	41	36.65 GiB	WebDataset shards: the images the model received (108,987), PNG
documents/	318	11.1 MiB	every distinct prompt (317) and the MCP tool interface
results/seed0/	3	237 KiB	the official _summary.md, RELEASE_s0.csv, EXCLUDE_s0.csv

Every file is named from the row — videos[].url, trace_url, traces[].image_keys — and every URL resolves under https://huggingface.co/datasets/Agent-as-Policy/agent-as-policy-robodojo/resolve/main/. Details of each folder: docs/SCHEMA.md; how the release was selected, cleaned, encoded and checked: docs/DETAILS.md.

Loading

from datasets import load_dataset

ds = load_dataset("Agent-as-Policy/agent-as-policy-robodojo", "episodes", split="evaluated")
row = ds[0]
row["episode_id"], row["outcome"], row["score"], row["frame_last"].size
row["video_preview"]                       # a torchcodec VideoDecoder; cast with Video(decode=False) for the bytes

# replay the episode
for step in row["traces"]:
    if step["kind"] == "message":
        print("agent:", step["text"])
    elif step["kind"] == "tool_call":
        print(step["tool"], step["arguments_json"][:120], "->", step["ok"], step["image_keys"])

# only the scalar columns
meta = load_dataset("Agent-as-Policy/agent-as-policy-robodojo", "episodes", split="evaluated",
                    columns=["episode_id", "task", "layout_id", "category", "outcome", "score", "official", "tokens"])

# the official per-task cells
tasks = load_dataset("Agent-as-Policy/agent-as-policy-robodojo", "tasks", split="evaluated")

# the images the model received (WebDataset); keys are traces[].image_keys
views = load_dataset("webdataset", split="train", streaming=True,
                     data_files="hf://datasets/Agent-as-Policy/agent-as-policy-robodojo/views/views-*.tar")
next(iter(views))                          # {'__key__': 's0_l000_align_blocks_0000', 'png': <PIL.Image>, 'json': {...}}

# files: one episode's recordings and event stream
from huggingface_hub import snapshot_download
snapshot_download("Agent-as-Policy/agent-as-policy-robodojo", repo_type="dataset",
                  allow_patterns=["videos/s0_l030_align_blocks/*", "traces/s0_l030_align_blocks.jsonl.gz"])

-- DuckDB, straight off the Hub: success rate and median tool calls per dimension
SELECT category, avg((outcome = 'success')::INT) AS sr, median(tools.calls) AS calls
FROM read_parquet('hf://datasets/Agent-as-Policy/agent-as-policy-robodojo/episodes/episodes-*.parquet')
GROUP BY 1 ORDER BY 2 DESC;

-- how often each tool failed
SELECT s.tool, count(*) AS n, count(*) FILTER (WHERE NOT s.ok) AS failed
FROM (SELECT unnest(traces) AS s FROM read_parquet('hf://datasets/Agent-as-Policy/agent-as-policy-robodojo/episodes/episodes-*.parquet'))
WHERE s.kind = 'tool_call' GROUP BY 1 ORDER BY 2 DESC;

The 16 unstable episodes are not a split; read them with load_dataset("parquet", data_files="hf://datasets/Agent-as-Policy/agent-as-policy-robodojo/unstable/*.parquet", split="train").

An episodes row

The scalar columns of one episode (media, messages, traces, prompt and file lists omitted):

{"episode_id": "s0_l030_align_blocks", "task": "align_blocks", "layout_id": 30, "seed": 0, "base_task": "align_blocks", "variant": "", "category": "Open", "layout_role": "eval", "model": "gpt-6-astra", "backend": "codex", "effort": "high", "outcome": "success", "score": 1.0, "total_wall_s": 105.946, "official": {"take_action_cnt": 110, "action_budget": 200, "ended_by": "official_end"}, "timing": {"start_epoch_s": 1792352626, "end_epoch_s": 1792352731, "total_wall_s": 105.946, "agent_s": 89.076, "sim_s": 16.87, "sim_clock_s": 4.4}, "tokens": {"input": 152962, "cached_input": 133888, "output": 1282, "reasoning": 447}, "tools": {"calls": 5, "observe": 0, "measure": 2, "run": 3, "step": 0, "assess": 0, "action_status": 0, "errors": 0}, "instruction": "Use the set square to push the three blocks into a straight, aligned row, then reset the robot arm.", "trace_url": "https://huggingface.co/datasets/Agent-as-Policy/agent-as-policy-robodojo/resolve/main/traces/s0_l030_align_blocks.jsonl.gz"}

Attribution

The tasks, scenes, simulator client and evaluator are RoboDojo's (code MIT, assets Apache-2.0); the recordings, and every camera image and crop the agent received (views/), were rendered in those scenes during the official evaluation. The agent ran through XPolicyLab. The messages, tool calls and event streams were generated by gpt-6-astra through codex.

@article{chen2026robodojo,
  title   = {{RoboDojo}: A Unified Sim-and-Real Benchmark for Comprehensive Evaluation of Generalist Robot Manipulation Policies},
  author  = {Chen, Tianxing and Chen, Yue and Li, Zixuan and Tang, Junyuan and Su, Kailun and Wan, Weijie and Chen, Baijun and Lu, Haoran and Yan, Haowen and Su, Honghao and others},
  journal = {arXiv preprint arXiv:2607.04434},
  year    = {2026}
}

Contributions

Mengzhao Jia (@JillJia) · Yang Lin (@elsannaly) · Xixin Zhang (@XixinZhang)

License and citation

Data: CC BY 4.0. Code: Apache-2.0, at the repository linked above.

@article{jia2026agentaspolicy,
  title   = {Agent as Policy for Robotic Manipulation},
  author  = {Jia, Mengzhao and Lin, Yang and Zhang, Xixin and Zhang, Zhihan and Liu, Xiaobai and Jiang, Meng},
  journal = {arXiv preprint arXiv:2609.12541},
  year    = {2026},
  url     = {https://arxiv.org/abs/2609.12541}
}

@dataset{jia2026agent_as_policy_robodojo,
  title     = {Agent as Policy --- RoboDojo Simulation Episodes},
  author    = {Jia, Mengzhao and Lin, Yang and Zhang, Xixin and Zhang, Zhihan and Liu, Xiaobai and Jiang, Meng},
  year      = {2026},
  version   = {s0},
  publisher = {Hugging Face},
  url       = {https://huggingface.co/datasets/Agent-as-Policy/agent-as-policy-robodojo}
}