README.md

---
pretty_name: MILO Benchmark
language:
  - en
license: mit
task_categories:
  - robotics
tags:
  - embodied-ai
  - ai2thor
  - task-planning
  - robotics
  - synthetic
size_categories:
  - n<1K
configs:
  - config_name: v1.0
    data_files: tasks.json
    default: true
  - config_name: v1.1
    data_files: v1.1/tasks.json
---

# MILO Benchmark

A small, versioned dataset of `(scene, instruction, ground-truth task
spec)` triples for evaluating embodied task planning in AI2-THOR,
built for the [MILO vision-language-robotics
project](https://github.com/NaishaShetty/MILO). A companion Space —
leaderboard + episode replay, static/pre-recorded since AI2-THOR needs
a GPU/Unity this Space's free tier doesn't have — is live at
[huggingface.co/spaces/naishashetty/milo_benchmark_companion](https://huggingface.co/spaces/naishashetty/milo_benchmark_companion).
Every task pairs a natural-language instruction with a structured
goal/object/target spec and a machine-checkable success predicate,
against real AI2-THOR scenes.

**This is a synthetic, AI2-THOR-derived dataset, not a human-collected
one.** Every instruction was authored by a human against a live scan
of each scene's real object inventory (`get_metadata()`), not
generated by an LLM and not crowd-sourced — see each version's
"Collection methodology" section below for exactly how, so nobody
mistakes this for naturalistic human instruction data.

## Versions in this repository

This repository hosts two dataset versions side by side — **neither
replaces the other**, and both are fully documented below:

| Version | Tasks | Scenes | Tiers | Status | Data file |
|---|---|---|---|---|---|
| **`v1.0`** | 25 | 5 | 3 (`tier1_locate`/`tier2_pickup`/`tier3_store`) | Frozen — task IDs, scenes, and success predicates will never change | `tasks.json` (repo root) |
| **`v1.1`** | 54 | 9 | 4 (adds `tier4_multi_step`) | Frozen (as of this version) — extends `v1.0` rather than mutating it | `v1.1/tasks.json` |

`v1.1` is additive: every one of `v1.0`'s 25 tasks is carried into
`v1.1` unchanged on every scoring-relevant field (`task_id`, `scene`,
`goal`, `object`, `target`, `instruction`) — a score computed against
either file's copy of a `v1.0` task_id is directly comparable. Use the
config selector above (or
`load_dataset("naishashetty/milo_benchmark", "v1.0")` /
`load_dataset("naishashetty/milo_benchmark", "v1.1")`) to pick which
version's `tasks.json` loads.

---

## MILO Benchmark v1.0

A small, versioned dataset of `(scene, instruction, ground-truth task
spec)` triples for evaluating embodied task planning in AI2-THOR,
built for the [MILO vision-language-robotics
project](https://github.com/NaishaShetty/MILO). A companion Space —
leaderboard + episode replay, static/pre-recorded since AI2-THOR needs
a GPU/Unity this Space's free tier doesn't have — is live at
[huggingface.co/spaces/naishashetty/milo_benchmark_companion](https://huggingface.co/spaces/naishashetty/milo_benchmark_companion).
Every task pairs a natural-language
instruction with a structured goal/object/target spec and a
machine-checkable success predicate, across 5 real AI2-THOR scenes
spanning all 4 iTHOR room types. `v1.0` is frozen (see "Versioning"
below) — for a larger, 9-scene extension with a fourth difficulty
tier, see [`v1.1`](#milo-benchmark-v11) (below, same page).

**This is a synthetic, AI2-THOR-derived dataset, not a human-collected
one.** Every instruction was authored by a human against a live scan
of each scene's real object inventory (`get_metadata()`), not
generated by an LLM and not crowd-sourced — see "Collection
methodology" below for exactly how, so nobody mistakes this for
naturalistic human instruction data.

### What's in it

25 tasks across 5 scenes:

| Scene | Room type | Tasks |
|---|---|---|
| `FloorPlan1` | kitchen | 5 |
| `FloorPlan5` | kitchen | 5 |
| `FloorPlan201` | living room | 5 |
| `FloorPlan301` | bedroom | 5 |
| `FloorPlan401` | bathroom | 5 |

Three difficulty tiers, 5 tasks/scene (2 tier1, 2 tier2, 1 tier3):

| Tier | What it exercises | Example |
|---|---|---|
| `tier1_locate` | Single-step object resolution (no manipulation). | "Find the mug." |
| `tier2_pickup` | Navigate + pick up a named object. | "Pick up the apple." |
| `tier3_store` | Pick up an object, navigate to a receptacle, open it if needed, place the object, close it if it was opened. | "Put the bread away in the fridge." |

Each row (see `tasks.json`):

```json
{
  "task_id": "milo-v1-fp1-t3a",
  "scene": "FloorPlan1",
  "room_type": "kitchen",
  "difficulty_tier": "tier3_store",
  "instruction": "Put the bread away in the fridge.",
  "goal": "store",
  "object": "bread",
  "target": "fridge",
  "notes": "fridge is a confirmed openable container in this scene."
}
```

`goal`/`object`/`target` map directly onto this project's
`schemas.task.SingleTask` (`goal` is a canonical verb like `find`/
`pick_up`/`store`; a planner unrelated to MILO can just as easily
treat them as generic action/argument fields). `notes` is
non-scoring, human-readable context — for a handful of tasks it
documents a **known, real limitation** the task deliberately keeps
rather than hides (see below).

### Success predicate

A task is scored `goal_success = True` iff its goal condition holds
against **live** AI2-THOR object state after execution (not just "did
every planned action dispatch without an error" — those are two
different claims; both are reported separately by the reference
runner):

| Goal | Live predicate |
|---|---|
| `find`/`locate`/... | An object of the named type exists in the scene. (See "Known limitations" — this is necessarily weaker than a real perception check.) |
| `pick_up`/`fetch`/`deliver` | The named object's live `isPickedUp` is `True`. |
| `store`/`place`/`put_away` | The named object is not held, and its live `parentReceptacles` includes the target's `objectId`. |
| `open` / `close` | The named object's live `isOpen` is `True` / `False`. |

Reference implementation: `backend/planning_evaluation/live_state.py`'s
`check_goal_live()` in the [MILO
repository](https://github.com/NaishaShetty/MILO) (this dataset's origin repo).

### Baselines (v1.0, real runs, all four planners)

| Planner | Goal success | tier1_locate | tier2_pickup | tier3_store | Notes |
|---|---|---|---|---|---|
| `rule_based` | 24/25 (96%) | 10/10 | 10/10 | 4/5 | Deterministic, no LLM. One failure is a real AI2-THOR placement/geometry limit, not a planner defect. |
| `behavior_tree` | 24/25 (96%) | 10/10 | 10/10 | 4/5 | Same task/plan-step outcomes as `rule_based` (shares its goal-handler templates); same single failure. |
| `htn` | 24/25 (96%) | 10/10 | 10/10 | 4/5 | A real Hierarchical Task Network engine (compound tasks, a state-conditional method library, recursive decomposition) — not a second implementation of `rule_based`'s control flow. Matches `rule_based`/`behavior_tree` exactly, including the identical single failure, at comparable latency (~647ms/episode avg vs. ~620–633ms). Slice 1 only: covers `tier1_locate`/`tier2_pickup`/`tier3_store`, not this project's `tier4_multi_step` tier (see `v1.1`'s card below). |
| `react` (`qwen2.5:7b`, Q4_K_M, via Ollama, local) | 20/25 (80%) | 10/10 | 10/10 | 0/5 | `goal_success`/`execution_success`/`plan_success` agree on every episode — no predicate artifact. All 5 failures are genuine multi-step reasoning failures (the model proposes an action before its precondition chain is satisfied, e.g. `pickup` before navigating close enough), not infrastructure. Run on an RTX 4050 Laptop GPU (6GB VRAM, 82%/18% GPU/CPU split), zero rate-limit retries needed (fully local, no quota). Reconfirmed unchanged (identical 20/25, identical per-task failures) after later detection-threshold/prompt fixes described below — those fixes don't touch this planner's LLM-proposal path. |

`react` was also attempted against Gemini's free tier
(`gemini-flash-latest`) first; that attempt is **not** a valid
baseline and is excluded from the table above — the free tier's daily
quota (20 requests/day) was exhausted after 2 of 25 episodes, and a
raw success-rate computed from that run would have been actively
misleading (most of its apparent "successes" were `tier1_locate`
episodes where the LLM call had already failed outright — the
predicate can't distinguish "the agent found it" from "the object was
already sitting in the scene regardless of what the agent did"). See
the origin repository's `experiments/reports/
phase_e_milo_benchmark_report.md` (Addendum 2 for the Gemini attempt
and why it doesn't count, Addendum 3 for the `qwen2.5:7b` run this
table reports) for full methodology, exact commands, and reproduction
steps.

**Reproducing the `react` row**: any OpenAI-API-compatible local
server works (Ollama, vLLM, ...) — set `LANGUAGE_LLM_PROVIDER=qwen`,
`LANGUAGE_LLM_MODEL=qwen2.5:7b` (or your chosen model/quantization),
`LANGUAGE_LLM_BASE_URL` to your server's `/v1` endpoint, and
`QWEN_API_KEY` to any placeholder value if your server doesn't enforce
auth, then run
`RUN_SIMULATOR_TESTS=true python -m planning_evaluation.run_benchmark`
from the origin repository's `backend/` directory.

### Difficulty tiers and why they were chosen this way

Tier boundaries were chosen to exercise structurally different code
paths in MILO's own rule-based planner (object resolution only, vs.
navigate+pickup, vs. the full open/place/close container logic) — not
an arbitrary linguistic complexity scale. This is a deliberate design
choice: the project's own bug history showed these three code paths
fail independently (a closed-receptacle bug and a non-openable-target
bug both lived specifically in the `tier3_store` code path, never in
`tier1_locate`/`tier2_pickup`) — see "Known limitations" below for the
two specific, currently-still-open bugs this dataset intentionally
keeps as ground truth.

### Known limitations — kept deliberately, not hidden

When this section was first written, two `tier3_store` tasks were
**known, currently reproducible failures** against the reference
planner, kept in v1.0 on purpose as honest negative examples rather
than removed to inflate a headline number:

- `milo-v1-fp301-t3a` ("Put the book away in the drawer.") fails at
  execution due to a real AI2-THOR physics/geometry limit — the
  drawer opens correctly, but AI2-THOR cannot find room for this
  particular book inside this particular drawer's real interior
  volume. Not a planner defect. **Still failing** — this is the one
  remaining failure in the Baselines table above, reproduced
  identically by `rule_based`, `behavior_tree`, and `htn`.
- `milo-v1-fp401-t3a` ("Put the spray bottle away on the shelf.") used
  to fail because the reference rule-based planner tried to `open` the
  shelf before placing — a shelf is a valid receptacle but is not
  openable, and `_deposit()` didn't check `openable` before deciding
  to open. **Fixed since this section was first written**: `_deposit()`
  now checks the target's `is_openable` before inserting an `open`
  step (see `backend/planner/rule_based.py`). This task now passes for
  every planner in the Baselines table above — it is not the source of
  any of their current failures.

A different, honest limitation of the success predicate itself:
`tier1_locate`'s live check (existence of an object of the named
type) cannot verify the agent actually *perceived* the object — only
that the plan named a real object. A perception-grounded check would
need a vision pipeline wired into the scoring harness; this dataset's
reference runner does not do that yet (see the origin repo's Phase C
vision-grounding work, which is not yet connected to this benchmark).

#### Addendum — perception-grounded `tier1_locate` check added (partially addresses the limitation above)

The limitation above is now **partially addressed, not resolved**: the
reference runner (`backend/planning_evaluation/run_benchmark.py`) now
also runs a second, stricter `tier1_locate` signal,
`perceived_by_agent`, alongside the original existence-only check
(now called `exists_in_scene` when reported side by side — see
`live_state.py`'s `check_goal_live_grounded()`). `perceived_by_agent`
is backed by a real vision perception call
(`GroundingDINODetector`/`SAM2Segmenter`, via `agents.vision_agent.
VisionAgentWrapper.perceive()`) against the live simulator's current
camera frame after execution, fed through Phase C's
`planner.grounding.ground_world_state()` to answer "did the agent's
vision actually register a detection for this object."

Both signals are kept separate on purpose — `goal_success` for
`tier1_locate` tasks still reports `exists_in_scene` (unchanged, so
every prior baseline number stays comparable); `perceived_by_agent` is
additional, informational, and never silently merged into
`goal_success`. This is a deliberate scope decision, not an oversight:
collapsing them into one number would hide exactly the gap this check
exists to measure.

**Real numbers from the first run this was exercised against** (see
`experiments/reports/phase_e_milo_benchmark_report.md`'s Addendum 5 for
full methodology, root-cause investigation, and per-episode detail):

```
rule_based:         exists_in_scene 10/10   perceived_by_agent 6/10
behavior_tree:      exists_in_scene 10/10   perceived_by_agent 6/10
react (qwen2.5:7b):  exists_in_scene 10/10   perceived_by_agent 5/10
```

So the assumption above ("should always pass in practice") was wrong
for `perceived_by_agent`, even though it remains true for
`exists_in_scene`: real, repeated divergence on 4-5 of 10
`tier1_locate` tasks per planner. Investigated, not just counted — the
measured cause was a genuine sim-to-real domain gap in
`GroundingDINODetector`, not a camera-framing bug or a label-vocabulary
mismatch: on a reproduced frame where AI2-THOR's own ground truth says
the target object is visible and within 0.7m, the detector's real
confidence for it peaked at 0.275, below the project's production
`box_threshold=0.35` cutoff. This dataset's `goal_success` metric is
unchanged by this finding (`tier1_locate` still scores on
`exists_in_scene`, by design — see the report addendum for why); this
is reported as a new, separately-tracked perception-accuracy finding,
not a dataset or predicate change.

This remains a partial fix, not a full one: `perceived_by_agent`
depends on the camera actually facing the object after the planner's
`navigate` step completes, on the detector's confidence threshold
relative to AI2-THOR's synthetic rendering style, and (in this
project's current environment) on a CPU-only vision inference path
(`torch.cuda.is_available()` is `False` on this machine despite a
present RTX 4050 GPU) — see the report addendum for exactly which of
these were observed to matter in practice, not assumed.

Lowering `GroundingDINODetector`'s confidence threshold (0.35 → 0.15)
recovers most of the missed detections in the reproduced case, but
this was **not** adopted as a fix — it is reported only as a
root-cause data point. Its effect on false-positive rate elsewhere in
the pipeline was not measured, so the production threshold is
unchanged pending real validation. In short: `goal_success` describes
planner-level task success (unchanged by any of this); `perceived_by_agent`
describes the vision system's own, currently limited, detection
reliability on AI2-THOR's synthetic renders — a different, still-open
question this dataset now measures separately instead of conflating
with the first.

#### Second addendum — detection threshold properly validated and changed (0.35 → 0.25)

The root-cause data point above (0.15 recovers detections but was
never validated for false positives) has since been followed up
properly, not left open: a dedicated validation set (8 real AI2-THOR
scenes, 9 true positives, 14 confirmed-absent true negatives) swept
real precision/recall at `box_threshold` 0.15/0.20/0.25/0.30/0.35
(two independent runs, consistent). **0.25 was adopted as the new
default** (`GroundingDINODetector`'s default `box_threshold`, changed
from 0.35): same recall as 0.15 (77.8%) with meaningfully better
precision (63.6% vs. 53.8%), and better recall than the old 0.35
(77.8% vs. 55.6%) with equal-or-better precision. This is a real
config-default change to the detector this dataset's `perceived_by_agent`
signal depends on, not a re-measurement of the numbers above — the
`perceived_by_agent` counts reported in the first addendum
(`rule_based`/`behavior_tree` 6/10, `react` 5/10) were measured at the
old 0.35 threshold and have not been re-run at 0.25; treat them as
historical, not current, if reproducing this check. `goal_success` is
unaffected either way (it has never depended on vision detection for
any tier). See the origin repository's `docs/roadmap.md` for the full
validation methodology and a methodology bug this pass also caught and
fixed (`GroundingDINODetector` sometimes merges adjacent prompt phrases
into one compound label, which naive exact-string matching missed).

### Collection methodology

1. For each of the 5 candidate scenes, a live AI2-THOR
   `Controller.step()`/`last_event.metadata` scan was taken to list
   every real object's `objectType`, `pickupable`, `receptacle`, and
   `openable` flags.
2. Task objects/targets were chosen only from that confirmed live
   list — never guessed from AI2-THOR documentation or an LLM's
   assumption about what "should" be in a kitchen/bedroom/bathroom.
3. Instructions were hand-written in natural language to match each
   task spec (not generated by an LLM, not templated beyond the
   tier's basic sentence shape).
4. `tier3_store` targets were chosen to include both confirmed real
   containers (fridge/cabinet/drawer) and one confirmed non-container
   receptacle (shelf) deliberately, once a first sweep run (this
   project's own "Phase D" floor-plan generalization sweep) surfaced
   the non-openable-target bug — see "Known limitations" above.

This is the same authoring discipline the origin repository already
used for its `FloorPlan1`-only real-AI2-THOR task sets
(`real_scenarios.py`), extended across scenes.

### What this dataset does not cover

- Only 5 of iTHOR's ~120 scenes (one per room type, plus a second
  kitchen) — not a claim of full scene coverage.
- Only single-object, single-goal tasks — no multi-object, multi-step,
  or conditional instructions.
- No adversarial/ambiguous instructions (Language-layer clarification
  behavior is out of scope here).
- English only.

### Versioning

`v1.0` is frozen — task IDs, scenes, and success predicates in this
version will not change. Future versions extend rather than mutate
(e.g. `v1.1` adding scenes/tasks would live in a sibling `v1.1/`
directory with its own `tasks.json`), so a score reported against
`v1.0` stays reproducible indefinitely.

### License

MIT, matching the origin repository. AI2-THOR scene assets themselves
are licensed separately by their own maintainers (Allen Institute for
AI) — this dataset contains no scene assets, only task
specifications/instructions referencing public AI2-THOR scene IDs.

### Citation

This is a research-adjacent project artifact, not a peer-reviewed
publication. If referencing it, cite the origin repository
([github.com/NaishaShetty/MILO](https://github.com/NaishaShetty/MILO))
and this dataset version (`milo_benchmark v1.0`).

---

## MILO Benchmark v1.1

`v1.1` extends [`v1.0`](#milo-benchmark-v10) (above, same page) rather than replacing it --
`v1.0` stays frozen and unchanged per its own versioning policy (see
that card's "Versioning" section, and this project's
`experiments/reports/phase_e_milo_benchmark_report.md` for the full
methodology `v1.0` was built with, which this card assumes as
background and does not repeat). Everything in `v1.0`'s card
(collection methodology, success predicates, known limitations, the
perception-grounded `tier1_locate` addendum) still applies unchanged
to every task `v1.1` carries over from `v1.0`. This card documents only
what is new.

### What's new in v1.1

- **4 more iTHOR scenes** (9 total, up from 5), chosen to extend room-type
  coverage rather than duplicate it: `v1.0` already had 2 kitchens, 1
  living room, 1 bedroom, 1 bathroom, so the 4 new scenes are 1 more
  living room, 1 more bedroom, 1 more bathroom, and 1 more living room
  again (living room ends up with 3 total; no third kitchen was added).
  This is a meaningful extension, not an exhaustive sweep of iTHOR's
  ~120 scenes -- see `v1.0`'s "What this dataset does not cover" for
  why full scene-coverage was never this dataset's goal.
- **A new `tier4_multi_step` difficulty tier** -- see below.
- **29 new tasks**: 20 flat `tier1_locate`/`tier2_pickup`/`tier3_store`
  tasks (5 per new scene, same 2/2/1 split `v1.0` uses) + 9
  `tier4_multi_step` tasks (1 per scene, all 9 scenes -- the 5 original
  `v1.0` scenes get a `tier4_multi_step` task added here too, since
  `v1.1` is additive over `v1.0`'s task set, not just its scene list).
  **Total: 54 tasks across 9 scenes** (`tasks.json`).
- Every `v1.0` task_id, scene, goal/object/target, and instruction is
  carried into `v1.1` with those **scoring-relevant fields identical**
  (regression-tested, see `backend/tests/test_planning_evaluation.py`'s
  `test_v1_1_frozen_v1_0_tasks_scoring_fields_match_v1_0`) -- a score
  on `v1.0`'s 25 tasks stays directly comparable whether computed
  against `dataset/v1.0/tasks.json` or `dataset/v1.1/tasks.json`'s
  first 25 rows. **This is not a byte-identical-JSON claim**: the
  free-text, non-scoring `notes` field was deliberately edited on 2 of
  the 25 carried-over tasks when `v1.1` was authored --
  `milo-v1-fp301-t3a`'s note gained a cosmetic "(and here, unchanged)"
  clause, and `milo-v1-fp401-t3a`'s note was **substantively
  rewritten**: `v1.0`'s text says the `_deposit()` non-openable-target
  bug is still unfixed ("expected to fail this task until that bug is
  fixed"), while `v1.1`'s text says that bug has since been fixed and
  the task is now expected to succeed. Both files' `goal`/`object`/
  `target`/`instruction`/`scene` for this task are unchanged either
  way -- only the human-readable annotation was updated to stay
  accurate.

  This scene table also reflects an honest, not a data-driven,
  balancing choice: `v1.0` had 2 kitchens and 1 each of living room/
  bedroom/bathroom; `v1.1` adds 1 more scene to living room, bedroom,
  *and* bathroom, landing on 3 living rooms rather than a 3rd kitchen.
  A 3rd kitchen (`FloorPlan7`) was live-scanned during collection and
  confirmed available/usable -- it was set aside in favor of living
  room getting the 4th new scene with no principled reason beyond
  needing to pick one room type to move toward parity with. iTHOR has
  roughly 30 scenes per room type, so this was a real choice among
  many available options, not a constraint.

| Scene | Room type | Tasks | New in v1.1? |
|---|---|---|---|
| `FloorPlan1` | kitchen | 6 (5 + 1 tier4) | tier4 task only |
| `FloorPlan5` | kitchen | 6 (5 + 1 tier4) | tier4 task only |
| `FloorPlan201` | living room | 6 (5 + 1 tier4) | tier4 task only |
| `FloorPlan301` | bedroom | 6 (5 + 1 tier4) | tier4 task only |
| `FloorPlan401` | bathroom | 6 (5 + 1 tier4) | tier4 task only |
| `FloorPlan202` | living room | 6 | scene + all 6 tasks |
| `FloorPlan302` | bedroom | 6 | scene + all 6 tasks |
| `FloorPlan402` | bathroom | 6 | scene + all 6 tasks |
| `FloorPlan203` | living room | 6 | scene + all 6 tasks |

Room-type totals: kitchen ×2, living room ×3, bedroom ×2, bathroom ×2.

### `tier4_multi_step`: what it's designed to exercise

`tier3_store`'s hardest task is still a **single-object** chain
(locate -> navigate -> pickup -> locate target -> navigate ->
(open) -> place -> (close)) -- every step serves one object reaching
one destination. `tier4_multi_step` is a different, harder axis:
**two independent single-object sub-goals in one instruction**, e.g.
*"Put the mug in the cabinet and the spoon in the drawer."* Both
sub-goals must be satisfied for the task to count as a success --
completing only one is a partial result, not a pass. This is designed
to probe **cross-object sequencing/planning depth**: does a planner
(especially an LLM-driven one) correctly treat this as two separate
goals to satisfy in sequence, or does it conflate them, drop one, or
apply one sub-goal's object/target to the other?

Concretely, each `tier4_multi_step` row's `goal`/`object`/`target`
fields are `null`; instead it carries a `subtasks` list of two
`{"goal", "object", "target"}` dicts, e.g.:

```json
{
  "task_id": "milo-v1.1-fp1-t4a",
  "scene": "FloorPlan1",
  "room_type": "kitchen",
  "difficulty_tier": "tier4_multi_step",
  "instruction": "Put the knife away in the drawer and the cup away in the cabinet.",
  "goal": null, "object": null, "target": null,
  "subtasks": [
    {"goal": "store", "object": "knife", "target": "drawer"},
    {"goal": "store", "object": "cup", "target": "cabinet"}
  ],
  "notes": "..."
}
```

**Why two independent `SingleTask`s, not a nested `MultiTask`**: this
project's schema layer (`schemas.task.MultiTask`) already models an
ordered decomposition into subtasks, but no planner in the origin
repository (`RuleBasedPlanner`, `BehaviorTreePlanner`, `ReActPlanner`)
implements a `MultiTask`-level `plan()` -- every one of them takes a
`SingleTask`. Rather than build new multi-task planning machinery
across all three planners (a materially larger, riskier change than
this dataset extension calls for), the reference runner
(`run_benchmark.py`) executes `tier4_multi_step`'s two `subtasks` as
two sequential `TaskRunner.run()` calls against the *same* live
simulator/episode (one Unity process, not restarted between
sub-goals) -- each sub-goal's `WorldState` is freshly re-seeded from
live metadata immediately before it plans, so the second sub-goal's
planner sees the real post-first-sub-goal world. This is "sequencing
across two independent sub-goals" implemented at the benchmark-harness
level, not inside any planner. See `loader.BenchmarkTask.to_single_tasks()`
and `run_benchmark._run_multi_subtask_episode()`.

### Success predicate for `tier4_multi_step`

`goal_success` is `True` iff **both** sub-goals' `check_goal_live()`
result is `True` against **one** metadata snapshot taken after both
sub-goals have been planned and executed, in order
(`live_state.check_goal_live_multi()`, `MultiGoalResult.all_succeeded`).
A planner that completes only one sub-goal, or that undoes the first
sub-goal while pursuing the second, is scored a failure -- this is a
genuinely stricter, conjunctive predicate, not an average or "best of
two." `plan_success`/`execution_success` are likewise the AND across
both sub-goals; both sub-goals are always attempted regardless of
whether the first one's plan/execution succeeded (mirroring a real
agent continuing to the next sub-goal rather than aborting the whole
instruction over one failed part), and `failure_cause` records every
sub-goal that failed, tagged by its own object/target.

### Collection methodology (identical discipline to v1.0)

Every new scene (`FloorPlan202`, `FloorPlan302`, `FloorPlan402`,
`FloorPlan203`) and every `tier4_multi_step` task's two sub-goals
(including the ones added to the 5 original `v1.0` scenes) were chosen
the same way `v1.0`'s collection methodology section describes: a live
AI2-THOR `Controller.step()`/`last_event.metadata` scan of each
candidate scene's real object inventory (`objectType`, `pickupable`,
`receptacle`, `openable`) was taken first; every task object/target
was chosen only from that confirmed live list, never guessed. The 5
original `v1.0` scenes were re-scanned for this pass (rather than
reusing `v1.0`'s own recorded inventory) specifically to confirm the
*new* `tier4_multi_step` objects/targets for those scenes actually
exist live, since `v1.0`'s own scan only ever confirmed the objects
`v1.0`'s own tasks use.

`tier4_multi_step` targets were deliberately split between confirmed
openable containers (Drawer, Cabinet, Fridge, Box, Safe) and confirmed
non-openable receptacles (Shelf, SideTable, Sofa, CoffeeTable) across
the 9 tasks -- exercising `_deposit()`'s `is_openable is False`
carve-out (see `v1.0`'s card, "Known limitations" -- this bug is now
fixed, see the origin repo's `phase_e_milo_benchmark_report.md`
addendum) on both of a `tier4_multi_step` task's independent sub-goals
in several cases (`FloorPlan202`, `FloorPlan402`'s second sub-goal,
`FloorPlan401`), not only single-object `tier3_store` tasks.

### Baselines (v1.1, real runs, all four planners)

| Planner | Goal success | tier1_locate | tier2_pickup | tier3_store | tier4_multi_step | Notes |
|---|---|---|---|---|---|---|
| `rule_based` | 50/54 (92.6%) | 18/18 | 18/18 | 7/9 | 7/9 | Both `tier3_store` failures are the same real AI2-THOR placement-geometry limit `v1.0` already documents (`FloorPlan301`, now also `FloorPlan203` -- same task shape, independently reproducing). Both `tier4_multi_step` failures are a real, newly-surfaced harness gap (not a planner defect): a failed `place` in sub-goal 1 leaves the object physically held, and `WorldState` re-seeding between sub-goals has no signal for that, so sub-goal 2's plan assumes an empty hand and AI2-THOR rejects it. See "`tier4_multi_step` investigation update" below for the current, precise per-episode status. |
| `behavior_tree` | 50/54 (92.6%) | 18/18 | 18/18 | 7/9 | 7/9 | Same task/plan-step outcomes as `rule_based` (shares its goal-handler templates); same failures for the same reasons. |
| `htn` | 43/45 (95.6%)¹ | 18/18 | 18/18 | 7/9 | not attempted¹ | A real Hierarchical Task Network engine (compound tasks, a state-conditional method library, recursive decomposition) -- not a second implementation of `rule_based`'s control flow. ¹Slice 1 only: does not yet support `tier4_multi_step`'s multi-subtask decomposition, so those 9 tasks were deliberately not attempted, not scored as failures -- goal success is out of 45, not 54. Both `tier3_store` failures (`milo-v1-fp301-t3a`, `milo-v1.1-fp203-t3a`) are the identical placement-geometry limit `rule_based`/`behavior_tree` hit on the same pair -- no new failure mode across the 4 additional scenes, i.e. `v1.0`'s 5-scene result generalizes. |
| `react` (`qwen2.5:7b`, Q4_K_M, via Ollama, local) | 36/54 (66.7%) | 18/18 | 18/18 | 0/9 | 0/9 | `tier4_multi_step`'s 0/9 is the arithmetically expected composition of `tier3_store`'s already-0% rate (a tier requiring two consecutive successful `store` sequences cannot score above a planner's single-`store` success rate) -- confirmed by inspecting each failure, not assumed: every one shows the same precondition-mis-sequencing pattern `v1.0`'s Addendum 3 already documents. `goal_success`/`execution_success`/`plan_success` agree on every episode; 0/54 episodes needed a retry. |

See the origin repository's `experiments/reports/
phase_e_milo_benchmark_report.md`'s Addendum 7 for full methodology,
per-failure root-cause detail, cost/latency, and exact reproduction
commands.

#### `tier4_multi_step` investigation update

The `WorldState`-reseeding gap noted in the `rule_based`/`behavior_tree`
row above has since been investigated in depth (not fixed and
re-benchmarked -- the table above is still the original publish run).
Two distinct causes were found behind the two known-failing episodes:

- **`milo-v1.1-fp302-t4a`**: the engine-crash *symptom* (the planner
  blindly issuing a doomed action once a hand is already occupied) is
  fixed and verified -- re-seeding `robot_holding` with one detection
  call per object name (rather than one joint multi-phrase prompt) at
  a validated `box_threshold=0.25` correctly detects the held object
  and lets the planner correctly *decline* to plan the second sub-goal
  instead of crashing AI2-THOR. This fix is demonstrated via a targeted
  investigation script, not yet merged into the production benchmark
  harness's `_seed_initial_state_from_live_metadata()` path -- the
  table above does not yet reflect it. The task's `goal_success` is
  still `False` either way, now solely because sub-goal 1 hits the same
  real placement-geometry limit `tier3_store` already has, unrelated to
  this bug.
- **`milo-v1.1-fp201-t4a`**: still open. Per-name detection queries do
  find the held object, but at a measured depth (0.853m) outside the
  held-object heuristic's `HELD_OBJECT_MAX_DEPTH_M=0.5m` cutoff --
  calibrated against smaller held objects (0.347m-0.459m) than this
  one. A separate, nearer, *not*-held object was also wrongly preferred
  by the heuristic's "closest wins" tie-break. The concrete next step
  identified (seeding `robot_holding` from AI2-THOR's own live
  `isPickedUp`/`inventoryObjects` metadata, sidestepping both the
  detection-prompt and depth-calibration dependencies) has not been
  implemented.

A related, broader finding surfaced during this investigation: Grounding
DINO's confidence measurably drops under multi-phrase joint prompts
(confirmed on 2 independent objects/frames) -- this does not affect
`goal_success` for any tier in this dataset or `perceived_by_agent`'s
`tier1_locate` check (both already query one object name at a time),
but does affect some manual demo scripts in the origin repository. Full
chain, exact numbers, and regression tests: the origin repository's
`docs/roadmap.md`.

### Second local model for `react`: `qwen2.5:3b` comparison

A second small local model was run through the identical `react`
harness/instrumentation against this same 54-task set, to see how
model size trades off against accuracy/latency:

| Model | Goal success | tier1_locate | tier2_pickup | tier3_store | tier4_multi_step | Avg latency/episode | Hardware |
|---|---|---|---|---|---|---|---|
| `qwen2.5:7b` (Q4_K_M) | 36/54 (66.7%) | 18/18 | 18/18 | 0/9 | 0/9 | 7156ms | RTX 4050 Laptop GPU, 6GB VRAM, 82%/18% GPU/CPU split |
| `qwen2.5:3b` (Q4_K_M) | 36/54 (66.7%) | 18/18 | 18/18 | 0/9 | 0/9 | 3107ms | Same GPU, full GPU residency |

`qwen2.5:3b` matches `qwen2.5:7b`'s goal-success rate **exactly,
task-for-task** (verified via a full 54-row side-by-side comparison,
0 differences) at roughly 2.3x lower average latency and modestly
fewer tokens per episode -- a real cost/latency win with no accuracy
cost observed on this task set.

Investigated why the aggregate scores are identical (rather than
taking the match at face value) by re-running 6 of these failing
episodes (3 per model) with a diagnostic wrapper that captures the
actual raw LLM completions -- reproducing the same outcomes as the
full run. Real finding, verified directly on those 6 episodes (not
re-checked against all 27 originally-classified failures from the
full run): **both models' `tier3_store`/`tier4_multi_step` failures
share a root cause -- neither model's proposals ever include a
`locate` call for the destination/container object, only sometimes
for the primary object being moved.** `qwen2.5:3b`'s proposals stall
immediately at that gap in all 3 episodes checked. `qwen2.5:7b`, in
the 1 of 3 checked episodes that got further, correctly completes
`locate`/`navigate`/`pickup` on the primary object, then fails at
placement by supplying the destination's name to `put_down`/`place`'s
`target` field -- which the action schema defines as the *held
object's* identity, not the destination -- a wrong-value mistake, not
a missing one.

This is treated as a real LLM reasoning/prompting limitation, not a
bug in this dataset's reference planner code -- no precondition
validation was weakened to work around it. See the origin repository's
`experiments/reports/phase_e_milo_benchmark_report.md`'s Addendum 8
for the full real transcripts and methodology, and `docs/roadmap.md`
for the tracked, open finding (including a possible, not-yet-tried
future direction: refining the `react` system prompt to explicitly
require locating both the object and the destination before any
`navigate`/`place` step).

### Versioning

`v1.1` is now itself frozen going forward, following the same policy
`v1.0`'s card states: task_ids, scenes, and success predicates in this
version will not change after this point. A future `v1.2` would extend
again rather than mutate this file.

### License

MIT, matching the origin repository, identical to `v1.0`.

### Citation

Cite the origin repository
([github.com/NaishaShetty/MILO](https://github.com/NaishaShetty/MILO))
and this dataset version (`milo_benchmark v1.1`).