--- 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`).