naishashetty/milo_benchmark

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. 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. 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. 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. 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 (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):

{
  "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 (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) and this dataset version (milo_benchmark v1.0).

---

MILO Benchmark v1.1

v1.1 extends v1.0 (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.:

{
  "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 SingleTasks, 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) and this dataset version (milo_benchmark v1.1).