---
license: mit
pretty_name: RoboQuest Tool-Call
task_categories:
- robotics
- image-text-to-text
tags:
- robotics
- tool-calling
- agents
- vlm
- mobile-manipulation
- robocasa
configs:
- config_name: puzzle_box
  data_files:
  - split: train
    path: puzzle_box/episodes.jsonl
---

# RoboQuest Tool-Call

Tool-call training data for vision-language agents on [RoboQuest](https://github.com/declare-lab/RoboQuest), built
from the released demonstrations in [declare-lab/RoboQuest](https://huggingface.co/datasets/declare-lab/RoboQuest).

Each episode is an expert trajectory in the format of a tool-calling agent: a multi-turn conversation in which the
user turns are observations (three camera images and the robot's proprioception as JSON), and each assistant turn is
one tool call (`arm`, `base`, `wait`). It comes in two forms: `trajectories.jsonl`, one full conversation per
episode, and `rows.jsonl`, one row per decision holding exactly the chat request the RoboQuest API evaluation harness
sends to a model at that step and the tool call it should return. A model trained on it can be evaluated directly in
the RoboQuest harness.

## Tasks

| Task | Episodes | Rows (decisions) | Images | Status |
|---|---|---|---|---|
| `puzzle_box` | 500 | 32,669 | 98,007 | released |

(Rows = assistant turns: one per decision.)

More tasks will be added as separate folders with the same layout.

## Layout (per task)

```
make_rows.py             trajectories -> per-step rows with any image horizon (standard library only)
<task>/
├── trajectories.jsonl   one full expert conversation per episode, images on every observation
├── rows.jsonl           one row per decision, as the eval harness sends it (two-image horizon)
├── episodes.jsonl       one line per episode (metadata for filtering; join on instance_id)
├── images/              256x256 PNG camera frames, referenced by relative path
└── stats.json
```

There is no train/validation split; split by `instance_id`.

### A trajectory (`trajectories.jsonl`)

One line per episode: the whole multi-turn conversation of the expert solving the task.

- `id`, `task`, `instance_id`, `n_decisions`.
- `tools`: the four tool schemas.
- `messages`: system prompt (with the goal), then per decision: the observation (user turn: proprio JSON + three
  camera images, **all images kept**), the expert's tool call (assistant turn) and the tool result (tool turn). It
  ends with the last assistant tool call.
- `turns`: one entry per assistant turn, in order: `k`, `tier`, `subtask`, `subtask_kind` (as in the rows below).

Train on it directly (loss on every assistant turn), or turn it into per-step rows with any image horizon:

```bash
python make_rows.py --trajectories puzzle_box/trajectories.jsonl --out rows_h4.jsonl --image-horizon 4
python make_rows.py --trajectories puzzle_box/trajectories.jsonl --out rows_all.jsonl --image-horizon all
```

`--image-horizon 2` reproduces `rows.jsonl` byte for byte. Note that the RoboQuest evaluation harness sends the
images of the two newest observations only; a model trained with more images sees fewer at test time unless the
harness's image window is raised to match.

### A row (`rows.jsonl`)

- `id`, `task`, `instance_id`, `k`: decision number within the episode (1-based).
- `messages`: the chat request at this decision, in OpenAI chat format. The system prompt (with the goal), then for
  each earlier decision the observation (proprio JSON + three camera images: left, right, wrist), the assistant tool
  call and the tool result (`{"command_accepted": true, "step": N, "error": null}`). As in the harness, only the two
  newest observations keep their images. Image parts are `{"type": "image", "image": "images/<ab>/<sha256>.png"}`,
  relative to the task folder.
- `tools`: the four tool schemas (`arm`, `base`, `wait`, `stop`).
- `target`: the assistant message to learn: one tool call, no text.
- `tier`: simulator check of this call (see below): `"A"`, `"B"`, or `null` (failed a limit).
- `subtask`: the demonstration's step caption covering this decision, e.g. "try the second red slider from the left
  on the front side". Caption text only; the outcome of a try is never included.
- `subtask_kind`: task-specific step kind. For `puzzle_box`: `slide` (a part whose lock is visibly free), `probe`
  (a part whose lock is hidden: it may come out, stay held or spring back), `open` (the lid), `pick`, `place`,
  `submit`.

### An episode (`episodes.jsonl`)

`instance_id`, `task`, `factors` (for `puzzle_box`: `cover` none / partial / full, `chain_length` 4 / 5 / 6,
`kitchen_layout`, `kitchen_style`), `n_decisions`, `tiers` (A / B / failed counts), `step_kinds` (steps of each kind),
`demo_ticks`, `api_ticks`, `final_submit`, `goal`.

## How the labels were made

The released demonstrations are 20 Hz action streams from scripted oracles. They were converted to tool calls as
follows:

- Each tool call is the demonstrator's intended move (waypoint), re-timed to the published tool limits (arm up to
  15 mm per tick, base inputs within ±0.5).
- Every call was executed by the unmodified RoboQuest executor from the demonstration's exact simulator state at that
  decision, and compared with the demonstration state where the next decision's frame was taken (teacher-forced).
- `tier` `A`: hand within 10 mm / 0.05 rad and moved objects within 10 mm of the demonstration; `B`: within 25 mm /
  0.10 rad; `null`: a limit was missed, most often the base was nudged more than 5 mm during an arm move. Mask or
  drop `null` rows if you want only verified targets.
- Images are the original demonstration frames (256x256); `step` in the tool results follows the re-timed ticks.
- Base calls are full-speed inputs whose tick count sets the distance (the simulated base barely moves below an
  input of about 0.27), so base ticks are exact integers, not rounded.

The `puzzle_box` demonstrator is observation-only for the puzzle: it never reads the secret release order, the
decoys or the hidden-lock holders, and finds the order by probing parts. It does read geometry and joint states from
the simulator instead of from images.

## Numbers (`puzzle_box`)

- 500 episodes; decisions per episode: mean 65.3, median 65, range 48–88.
- Tiers: A 31,519 (96.5%), B 736 (2.3%), failed 414 (1.3%).
- Covers: none 173, partial 164, full 163 episodes; every covered episode contains probing.
- Rows by subtask kind: slide 12,210, probe 10,034, open 3,654, place 2,782, submit 2,017, pick 1,972.

## Caveats

- Teacher-forced: a call's real end state differs from the next frame by a few millimetres (median 2.9 mm for arm
  calls).
- The final Submit succeeds in every episode when run from the demonstration state; the full call sequence has not
  been replayed open-loop from reset.
- Calls follow the demonstrator's move granularity (many short, precise moves), not a particular API model's style.

## Usage

```python
import json
from huggingface_hub import snapshot_download

root = snapshot_download("declare-lab/RoboQuest-Tool-Call", repo_type="dataset", allow_patterns=["puzzle_box/*"])

# one full expert conversation per episode
with open(f"{root}/puzzle_box/trajectories.jsonl") as f:
    traj = json.loads(next(f))
print(len(traj["messages"]), "messages,", traj["n_decisions"], "tool calls")

# or one training row per decision
with open(f"{root}/puzzle_box/rows.jsonl") as f:
    row = json.loads(next(f))
print(row["target"])               # the tool call to learn
for m in row["messages"]:
    if isinstance(m.get("content"), list):
        for part in m["content"]:
            if part.get("type") == "image":
                path = f"{root}/puzzle_box/{part['image']}"   # PNG frame
```

## License

MIT, like the RoboQuest release.