Hugging Face's logo

Datasets:
Gyubeum
/
AndroidFlux_Evaluation_Output

Languages:
English
Tags:
android
gui-agents
failure-recovery
evaluation-results
benchmark
Dataset card Files
xet
 Community
AndroidFlux_Evaluation_Output / README.md
davis901's picture
davis901
AndroidFlux evaluation outputs
02039a4
preview code
|
Raw History Blame Contribute Delete
26.7 kB
---
pretty_name: AndroidFlux Evaluation Output
language:
- en
tags:
- android
- gui-agents
- failure-recovery
- evaluation-results
- benchmark
---
# AndroidFlux — Evaluation Output
Scored results for every number reported in the AndroidFlux paper, in one place.
This repository holds **results only**: success counts, per-episode outcomes, and the
provenance needed to tell one run from another. It does not hold the benchmark inputs
(source trajectories, VM snapshots, screenshots) — those live in the input repositories
listed under [Related repositories](#related-repositories).
**Every table in the paper can be regenerated from this repository alone:**
```bash
python3 scripts/reproduce.py --check # recount every cell and compare with its header
python3 scripts/score_tables.py --root . --all # regenerate the paper tables
```
How to run them is described in [`scripts/README.md`](scripts/README.md).
If a number printed by that script disagrees with the paper, the script is right and the
paper has a typo. Known disagreements are listed in [KNOWN ISSUES](#known-issues).
---
## Layout
```
androidworld/<run>/ sr_summary.json per_task.json MANIFEST.json
human_verified/
replay_65/<condition>/<model>/ validation.json per_episode.json MANIFEST.json
episodes/<task>/
snapshot_15/<condition>/<model>/ "
llm_verified/
replay_312/<condition>/<model>/ "
t_plus_1/ entry-set definition of the LLM-verified t+1 arms (no cells)
supplementary/
t_plus_1_65/t_plus_1/<model>/ 65-entry t+1 cells (not used in the tables; see KNOWN ISSUES 7)
llm_verified_subsets/t/<model>_lv177 177- and 254-episode subset cells (see KNOWN ISSUES 6)
replicate_runs/ an independent replicate of one cell, for run-to-run variation
_inputs/manifests/ the run manifests the cells were produced from
scripts/score_tables.py
scripts/scratch_80_tasks.txt
README.md
```
`<condition>` is one of:
```
clean t_minus_5 t_minus_3 t_minus_1 t t_plus_1_pos t_plus_1_neg
```
Not every (axis, subset, condition, model) combination exists. `score_tables.py`
reports missing cells rather than silently skipping them.
### Per-cell files
| File | Contents |
| --- | --- |
| `validation.json` | The scored cell: `success_count`, `result_count`, per-episode `rows`, contract-check `issues`, `valid`. |
| `per_episode.json` | One row per episode: `shard`, `episode`, `source_model`, `task_name`, `is_successful`, `success`, `exception`. |
| `MANIFEST.json` | Provenance: which run this is, what it was run against, what is wrong with it. See [`MANIFEST_SCHEMA.md`](MANIFEST_SCHEMA.md). |
| `episodes-<i>-of-<n>.parquet` | Per-episode artifacts, one row per episode, payload in a `files` column. See [Episode payload parquet](#episode-payload-parquet). Cells whose run left outcomes only carry no such file — see KNOWN ISSUES #4. |
Two notes on the layout:
- **Shards are an execution detail and are flattened away.** The producing harness writes
`shards/shard_0N/<task>/`; here that is `episodes/<task>/`. The original shard assignment
is preserved in `validation.json:shard_counts` and in `per_episode.json:shard`.
- **`app_data_cache/` is excluded.** It is emulator scratch state, not a result.
---
## Episode payload parquet
Screenshots and step records ship as parquet, not as loose files: a cell holds thousands of
PNGs, and uploading them one by one runs into the hosting API's request limits.
```
<axis>/<subset>/<condition>/<model>/episodes-00000-of-00001.parquet
```
**One row per episode.** Identity columns (`cell_id`, `axis`, `subset`, `condition`,
`model_key`, `task_name`, `entry_id`, `source_model`), the verdict as scored
(`is_successful`, `score`), and the artifacts in
```
files list<struct<name: string, kind: string, size_bytes: int64, sha256: string, bytes: binary>>
kind: screenshot_png · step_json · jsonl · action_audit_png · action_audit_json
· replay_debug_png · replay_debug_json · episode_json
```
`name` is the path the file had inside its episode directory, so the original tree can be
restored exactly. `sha256` is taken over the bytes AS PUBLISHED — absolute paths and machine
names are scrubbed out of the text payloads first — so verification passes on the files as
they stand here.
**What the format guarantees**
- **Every file is under 5GB**, the hosting limit. A cell that would exceed it is split, and
the parts are named `-00000-of-00003`, `-00001-of-00003`, … The reader reads a cell as the
union of its parts.
- **Every row group is at most 240MB.** This is what makes partial reads cheap: a reader
pulling one episode loads that group, not the file. It is the row group size, not the file
size, that bounds the memory a reader needs. The largest single part here is 3.3GB.
- **`app_data_cache/` is excluded** (emulator scratch state), and so are preserved partial
runs — directories whose name begins with a dot (`.stopped_*`, `.enginedead_*_partial`).
Only the leading character decides, so a cell like `qwen3vl_8b.dup1` is unaffected.
**`entry_id` is the episode directory name, verbatim.** Its shape follows the campaign that
produced the cell, and it is not normalised — normalising it would break the correspondence
with the source tree:
| Subset | `entry_id` |
| --- | --- |
| `snapshot_15` | `<source_model>__<task>__t<NNNN>` |
| `replay_65` | `<source_model>__<task>` |
| `t_plus_1_pos` / `t_plus_1_neg` | `<source_model>__<task>__tplus1_positive` / `__tplus1_negative` |
The key is `(cell_id, entry_id)`; it only has to be unique within a cell. **Polarity is read
from the path, never from the row.** In a `t_plus_1` cell the stored `condition` is
`t_plus_1` for both arms, and the two arms share the same `(source_model, task_name)` pairs —
only `cell_id` (and, for these campaigns, the `entry_id` suffix) separates them.
**Reading it**
```bash
python3 scripts/read_episodes.py <cell>/episodes-00000-of-00001.parquet # what is in here
python3 scripts/read_episodes.py <cell>/episodes-00000-of-00001.parquet --extract <entry_id> --out DIR
python3 scripts/read_episodes.py <cell>/episodes-00000-of-00001.parquet --verify # recompute every sha256
```
---
## Condition names ↔ paper notation
The paper uses compact math notation; the repository uses filesystem-safe names.
| Repository | Paper | Meaning |
| --- | --- | --- |
| `clean` | Scratch | Task run from step 0. No replay, no primed history. |
| `t_minus_5` | $t{-}5_{\text{rep}}$ | Replay through $t_{\mathrm{err}}-5$, then the policy acts. |
| `t_minus_3` | $t{-}3_{\text{rep}}$ | Replay through $t_{\mathrm{err}}-3$. |
| `t_minus_1` | $t{-}1_{\text{rep}}$ | Replay through $t_{\mathrm{err}}-1$. |
| `t` (in `replay_65`, `replay_312`) | $t_{\text{rep}}$ | Replay through the first-error step. |
| `t` (in `snapshot_15`) | $t_{\text{snap}}$ | VM snapshot restored to the first-error step. |
| `t_plus_1_pos` | $t{+}1^{+}$ | Inject the first action of a recovery rollout that eventually **succeeded**. |
| `t_plus_1_neg` | $t{+}1^{-}$ | Inject the first action of a recovery rollout that eventually **failed**. |
Superscripts describe the outcome of the rollout that *supplied* the action, not a claim
that the single action is sufficient.
Three paper columns are **derived** and have no directory of their own:
| Paper | Definition |
| --- | --- |
| $t_{\text{all}}$ | $(\texttt{replay\_65/t} + \texttt{snapshot\_15/t}) / 80$ |
| $t{+}1_{\text{all}}$ | $(\texttt{t\_plus\_1\_pos} + \texttt{t\_plus\_1\_neg}) / 104$ |
| Scratch (80) in `tab:aw-vs-recovery` | The same AndroidWorld 116-task run restricted to the 80 recovery tasks in `scripts/scratch_80_tasks.txt` |
The 80 recovery tasks are exactly `replay_65` (65) ∪ `snapshot_15` (15); the two sets are
disjoint and their union is a subset of the AndroidWorld 116.
Source-name mapping, for anyone cross-referencing the older input repositories:
| Repository | Original condition name |
| --- | --- |
| `clean` | `clean` / `snapshot_clean` |
| `t_minus_1` | `pre_error_t_minus_1` / `snapshot_pre_error_t_minus_1` |
| `t_minus_3`, `t_minus_5` | `pre_error_t_minus_3`, `pre_error_t_minus_5` |
| `t` | `error_t` / `snapshot_error_t` |
| `t_plus_1_pos`, `t_plus_1_neg` | `t_plus_1_positive`, `t_plus_1_negative` |
---
## Scoring: two rules, and why
**The two result formats in this repository are scored differently. This is deliberate,
and the difference is visible only where a partial score of 0.5 exists.**
| Format | Field read | Success means | 0.5 counts as |
| --- | --- | --- | --- |
| `validation.json` (human-verified, LLM-verified) | `rows[].score` | `score > 0` | **success** |
| `sr_summary.json` (AndroidWorld) | `["total"]["successes"]` | `score >= 1` | **failure** |
Why they differ: the two numbers are produced by two different harnesses, and each paper
table reports the figure its own harness reported. AndroidWorld's `sr_summary.json` counts
a task correct only on full completion, which is the convention that benchmark's published
numbers use. The recovery harness records partial credit and treats any progress as a
recovery success, which is the quantity the recovery tables are about. Rescoring one to the
other's rule would make our numbers incomparable with published AndroidWorld results.
`score_tables.py` applies the rule that matches the file it is reading, and every
`MANIFEST.json` records both `success` (its own rule) and `success_alt_rule` (the other
rule) so the gap is never hidden. Worked examples, all from cells in this repository:
```
human_verified/replay_65/t/qwen3vl_2b scores {0.0:57, 0.5:1, 1.0:7}
score>0 -> 8/65 = 12.3 <- paper
score>=1 -> 7/65 = 10.8
human_verified/replay_65/t_plus_1_pos/ma3_32b scores {0.0:29, 0.5:1, 1.0:22}
score>0 -> 23/52 = 44.2 <- paper
score>=1 -> 22/52 = 42.3
androidworld/ma3_7b_4env_gen1 score points total 78.5
score>=1 -> 78/116 = 67.2 <- paper
score>0 -> 79/116 = 68.1
```
Two further traps that cost us real time:
- **Read `d["total"]["successes"]`, not the top-level key and not `score_points`.**
`score_points` is the sum of partial scores (78.5 above), not a count.
- **Recompute from `rows`, never trust the header.** Five LLM-verified subset cells carry a
`result_count` and `success_rate` from before a denominator correction while `rows` is
already corrected — three different numbers in one file. See KNOWN ISSUES #6.
`score_tables.py` recomputes from `rows` and asserts agreement with the header, failing
loudly on mismatch.
---
## Denominators
Denominators are **fixed constants**, not derived from how many result rows happen to be
present. A cell with a missing episode is a defect to be reported, not a smaller denominator.
| Axis | Subset | Conditions | n |
| --- | --- | --- | ---: |
| AndroidWorld | `aw_116` | — | **116** |
| AndroidWorld | `aw_116` restricted | Scratch (80) | **80** |
| Human-verified | `replay_65` | `clean`, `t_minus_5`, `t_minus_3`, `t_minus_1`, `t` | **65** |
| Human-verified | `replay_65` | `t_plus_1_pos`, `t_plus_1_neg` | **52** |
| Human-verified | `snapshot_15` | `clean`, `t_minus_1`, `t` | **15** |
| LLM-verified | `replay_312` | `clean`, `t` | **312** |
| — | derived | $t_{\text{all}}$ | **80** |
| — | derived | $t{+}1_{\text{all}}$ | **104** |
**AndroidWorld is 116 including the 6 exception episodes.** They are failures, not
exclusions.
**$t{-}3$ and $t{-}5$ also have denominator 65.** When the source trajectory is too short to
admit the requested offset, the task is *retained* and that condition is mapped to a clean
start — it is not dropped. This keeps all conditions paired over the same 65 cases, at the
cost of mixing true offset starts with clean starts:
| Condition | Offset | Feasible | Clipped | Feasible share |
| --- | ---: | ---: | ---: | ---: |
| `t_minus_1` | 1 | 65 | 0 | 100.0% |
| `t_minus_3` | 3 | **39** | 26 | 60.0% |
| `t_minus_5` | 5 | **21** | 44 | 32.3% |
The feasible-only figures are carried per cell in `validation.json:t_minus_n` and in
`MANIFEST.json:score.t_minus_n`. The paper reports the 65-case aggregate; treat the
feasible-restricted score as a secondary diagnostic, and never compare a 65-aggregate
against a feasible-only figure.
---
## `scripts/score_tables.py`
```bash
# every paper table
python scripts/score_tables.py --all
# one table
python scripts/score_tables.py --table tab:hvlvcomparison
python scripts/score_tables.py --table tab:aw-vs-recovery
python scripts/score_tables.py --table tab:instreason
# one cell, with the full derivation printed
python scripts/score_tables.py --cell human_verified/replay_65/t_plus_1_pos/ma3_32b --explain
# machine-readable
python scripts/score_tables.py --all --format json > tables.json
python scripts/score_tables.py --all --format latex
# fail the build if any cell disagrees with its MANIFEST, or any manifest is incomplete
python scripts/score_tables.py --verify
```
`--explain` prints the numerator, denominator, scoring rule, score histogram, and the
`MANIFEST.json` fields that identify the run:
```
human_verified/replay_65/t_plus_1_pos/ma3_32b
rule score > 0 (validation.json:rows[].score)
scores 0.0 x29 0.5 x1 1.0 x22
success 23 / 52 = 44.23 % -> tab:hvlvcomparison t+1^+
alt rule 22 / 52 = 42.31 % (score >= 1)
valid false issues: memory_prefix 14, start_state_contract 14, +4
accepted true
input rev Gyubeum/AndroidFlux_tplus1_inputs @ 0360552
known issues coord_mode_from_source_traj (affects score)
memory_prefix_short_by_one (affects score)
```
`--verify` is the gate to run before publishing: it recomputes every cell from `rows`,
checks it against the header fields and against `MANIFEST.json`, checks that denominators
match the table above, and checks that every cell has a manifest. It exits non-zero on any
disagreement.
### Identifying a cell
**Do not identify a cell by `model_key`, and do not identify it by its score.** Both fail:
**`model_key` is not unique.** Across the 321 published cells, five keys are shared by more
than one model directory. In four of the five, the variant suffix is silently dropped:
| `model_key` | directories that share it |
| --- | --- |
| `gemma_31b_improved` | `gemma_31b_improved`, `gemma_31b_improved_think_on` |
| `gemini_3_0_flash_preview_qwen_prompt` | `gemini_3_0_flash_preview_qwen_prompt`, `..._think_on` |
| `gemma_4_31b_it_0716_improved_m3a` | `gemma_4_31b_it_0716_improved_m3a`, `gemma_4_31b_it_improved_m3a_think_off` |
| `mobile_run_gf30` | `gemini_3_0_flash_preview_qwen_prompt`, `..._think_off` |
| `guiowl15_8b_think` | `guiowl15_8b_think`, `yemo_guiowl15_8b_think` |
So `gemma_31b_improved_think_on` (148/312) and `gemma_31b_improved` (139/312) are two
different cells reporting the same `model_key` — and thinking-enabled and thinking-disabled
rows of `tab:instreason` are exactly the pair that key cannot distinguish.
**`dir_name` is not reliable either.** Five directories carry *different* `model_key` values
in different cells, so the mapping is not even a function in the other direction:
| directory | `model_key` values observed |
| --- | --- |
| `gemini_3_0_flash_preview_qwen_prompt` | `gemini_3_0_flash_preview_qwen_prompt`, `mobile_run_gf30` |
| `gemini_3_0_flash_preview_qwen_prompt_think_off` | `gemini_3_0_flash_preview_qwen_prompt_think_off`, `mobile_run_gf30` |
| `gemma_4_31b_it_improved_m3a_think_off` | `gemma_4_31b_it_0716_improved_m3a`, `gemma_4_31b_it_improved_m3a_think_off` |
| `mai_ui_8b` | `mai_ui_8b`, `mai_ui_8b_history` |
| `mai_ui_2b` | `mai_ui_2b`, `mai_ui_2b_history` |
**Matching on the score value is worse still** — it crosses model boundaries. Searching for a
`15/52` cell finds `t_plus_1_pos/qwen3vl_2b` when the target was `t_plus_1_neg/qwen3vl_4b`.
Fix the (model, condition) pair first, then read the value; never the reverse.
The identifier is therefore the **path**, `MANIFEST.json:identity.cell_id`. `dir_name` and
`model_key` are both recorded, separately, precisely because they disagree with each other.
---
## KNOWN ISSUES
These are defects we have confirmed and chosen to publish rather than quietly fix. Each is
recorded per cell in `MANIFEST.json:status.known_issues[]` with an `affects_score` flag, so
a consumer can filter programmatically.
### 1. LLM-verified `t`: 21 cells, 20 contract issues each, on the same 5 episodes
All 21 full-set LLM-verified `t` cells were run **before the 2026-09-07 metadata
regeneration**. Each reports `valid: false` with an identical signature:
```
executed_prefix 5 + memory_prefix 5 + skipped_replay 5 + history_or_budget_contract 5 = 20
```
That is **four checks failing on the same five episodes** — the "20" is an issue count, not
a cell count or an episode count. The five failing episodes are the same five in all 21
cells, with zero variation in the key set:
```
gemini_flash_4env | FilesMoveFile
gemini_flash_4env_gen2 | ExpenseAddMultipleFromGallery
qwen3vl_2b_4env | Do_I_have_any_events_October_28...
qwen3vl_30b_a3b_4env | What_incomplete_tasks...
qwen3vl_8b_think_4env_gen1 | RecipeDeleteSingleWithRecipeWithNoise
```
Because the failing episodes are identical across models, this is an input-side defect:
row-to-row comparison within the table still holds, absolute values do not. Some cells carry
additional per-model issues on top of the shared 20 (`agent_rollout_error`,
`shard_result_sizes`); those are model- or run-specific and are listed per cell in
`MANIFEST.json:status.issues_by_type`.
**Do not read `valid: false` here as "a minor 5-episode problem."** The underlying defect is
larger than what `validation.json` catches: `replay_metadata`'s `memory.steps` is empty for
**103 of 312 entries (33.0%)**, concentrated in four source trajectories
(`gemma_31b_m3a_gemma31b_improved_0716_4env` 49, `gemma_31b_m3a_gemma_31b_m3a_4env` 42,
`ui_tars_7b_sft` gen3/gen4 6 each). The contract check catches five of them. The two numbers
come from different checks and are not comparable.
The cause for the Gemma sources is confirmed: the metadata's `image_name` values
(`step_000.png`) do not match the files on disk (`screenshot_N.png`), so every image
reference resolves to nothing and `memory.steps` is built empty. The original trajectories
are intact — this is a metadata build failure, not missing data, and it is regenerable
without GPU. The `ui_tars` sources have a different, still-unidentified cause: their images
are all present.
*Checking this yourself: read `len(m["memory"]["steps"])`. `len(m["memory"])` is the number
of keys (8) and will look fine.*
### 2. `llm_verified/replay_312/t/gemma_31b_improved_think_on`: 142/312 rollout errors
**45.5% of this cell's episodes ended in `agent_rollout_error`.** Its reported success rate
of 47.44% is a measurement failure, not a performance figure.
This cell is marked `canonical: false` in its manifest. It is published because the paper's
`tab:instreason` LLM-verified Reasoning column (47.4) rests on it, and suppressing the cell
would hide that.
### 3. `t_plus_1` 32B cells: run before the `replay_utils.py:747` fix
Six cells — `t_plus_1_pos` and `t_plus_1_neg` for `gui_owl_32b`, `ma3_32b`, and
`qwen3vl_32b` — were produced on a tree that predates the `replay_utils.py:747` fix
(`extract_action_payload` was missing its AndroidWorld-native `action_type` branch, so t+1
candidate actions could not be extracted). All six report `issues: 32`:
```
negative arm memory_prefix 16 + start_state_contract 16
positive arm memory_prefix 14 + start_state_contract 14 (+ 4 unrelated)
```
The failing episode keys are **identical across all three models** within an arm (16/16 and
14/14 intersection), which places the cause on the input side, not the model. The mechanism
is a memory prefix one step short of expected; 11 of the 13 start-state contract checks
still pass, with only `history_prefix_exact` and `history_last_is_live_target` failing.
Root cause, recorded in the cells' own notes: the input revision
(`AndroidFlux_tplus1_inputs @ 03605523705a59dce1e1b3b0ba5e30881cfa5e5f`) predates the
`candidate_coord_mode` split, so `coord_mode` was assigned from the source trajectory rather
than from the recovery action. The evidence is that the positive and negative arms have an
*identical* coord_mode distribution (pixel 14, normalized_1000 38) when they should differ.
This applies uniformly to every model evaluated on that input.
`gemma_31b_improved/t_plus_1_neg` used the same input revision but had its 16 zero-length
episodes re-run after applying commit `ff747bd`; the first-pass output is preserved in that
cell rather than deleted. Whether those 16 episodes are the same 16 is **unverified**.
### 4. Older cells carry outcomes only
Cells produced before the artifact-retention change have **no intermediate step records and
no screenshots** — `episodes/<task>/` holds the episode outcome and nothing else.
`MANIFEST.json:status.artifacts` reports per cell which of `action_audit`, `agent_rollout`,
and `replay_debug` are present. Analyses that need step-level evidence must filter on those
flags; there is no way to recover the missing artifacts from these runs.
### 5. `MarkorTranscribeVideo` fails structurally in the positive arm
`actuation.py` has no `input_text` branch, so the action dispatches as
`long_press(None, None)`. This reproduces across five models, occurs **only in the
`t_plus_1_pos` arm**, and is unrelated to agent capability. The episode is retained and the
denominator stays 52 — it is a harness limitation counted as a failure.
### 6. Five LLM-verified subset cells: header and rows disagree
`gemini_flash_lv177`, `gemini_flash_lv254`, `guiowl15_8b_lv177`, `ma3_7b_lv177`, and
`ui_tars_1_5_7b_lv177` were published between a denominator correction and a header fix.
Their `rows` are correct; their `result_count` and `success_rate` header fields are from the
pre-correction 312-entry state, and the `success_rate` field does not even equal
`success_count / result_count` within the same file. Three different numbers are readable
from one file:
| Cell | Header | `success_rate` field | Recomputed from `rows` |
| --- | --- | ---: | ---: |
| `guiowl15_8b_lv177` | 81/312 | 31.41% | 45.76% (81/177) |
| `gemini_flash_lv177` | 90/312 | 49.36% | 50.85% (90/177) |
| `gemini_flash_lv254` | 131/312 | 49.36% | 51.57% (131/254) |
| `ma3_7b_lv177` | 85/312 | 45.83% | 48.02% (85/177) |
| `ui_tars_1_5_7b_lv177` | 43/312 | 19.23% | 24.29% (43/177) |
`score_tables.py` uses the `rows` recomputation and `--verify` fails on these until the
headers are corrected.
### 7. `t_plus_1` exists as two different sets — check `entry_set`
There is a `t_plus_1` condition with **65 entries**, produced on a different machine, that is
distinct from the 52-task `t_plus_1_pos` / `t_plus_1_neg` arms. **The paper tables use the
52-task arms.** Seven models (`gui_owl_7b`, `ma3_7b`, `mai_ui_8b`, `qwen3vl_2b`,
`qwen3vl_4b`, `qwen3vl_8b`, `ui_tars_7b_sft`) have both, so a lookup by model and condition
name alone will pick the wrong one. Split on `MANIFEST.json:identity.entry_set`, or on
`validation.json:expected_entries` (65 vs 52).
### 8. Reproducibility caveats that are not defects in any single cell
- **Rollout failures are counted in the denominator.** An episode where the model emitted
unparseable output is a failure, not an exclusion. This is intentional — excluding them
would reward models that fail loudly — but it means a cell's score mixes "the agent tried
and failed" with "the measurement failed." `issues_by_type` in each manifest lets you
separate the two.
- **Rollout failures re-run selectively would bias results.** Where the cause is the model's
own output (truncated tool-call JSON, hallucinated element indices), re-rolling until a
cell passes advantages that cell. Those episodes are accepted as failures and the reason
is recorded in `accepted_rationale`. Only harness and infrastructure failures were re-run.
- **`mobilerun_gemini_flash_3.0` does not honour the step budget.** MobileRun runs its own
agent loop at a flat 160 framework steps and ignores per-task `recovery_max_steps`
(`inference/android_world_agents.py:95`). 23/65 episodes exceeded their task budget and 11
of those succeeded. Applying the standard rule gives 31/65 rather than the recorded 42/65.
These cells carry `step_budget_policy: mobilerun_flat_160`; **do not difference them
against harness-enforced rows.** For comparison, across the other 26 `replay_65/t` cells
there were 568 budget-exhausted episodes and 0 successes.
- **Serving reachability was observed differently from different hosts at the same time**,
and flipped within 13 minutes on one host. Reachability claims in the manifests are
qualified by host and time for that reason.
---
## Related repositories
| Repository | Contents |
| --- | --- |
| `Gyubeum/AndroidFlux_Failure_Recovery_Eval_Agent` | Human-verified and LLM-verified inputs, VM snapshots, and the $t{+}1$ candidate-action inputs (`human_verified_set/t_plus_1`, `llm_verified_set/t_plus_1`) |
Cells whose `MANIFEST.json` names `Gyubeum/AndroidFlux_tplus1_inputs` as their input were
run from an earlier packaging of the human-verified $t{+}1$ inputs; that content is now
`human_verified_set/t_plus_1` of the input repository.
### 9. Seven cells carry header fields corrected during migration
Five LLM-verified subset cells (`supplementary/llm_verified_subsets/t/*`) were published with
`result_count` and `expected_entries` of 312 and a `success_rate` copied from the parent
312-entry run; they now read 177 / 254 and the rate recomputed from their own rows. One
human-verified cell (`replay_65/t_minus_1/guiowl15_8b_think`) had a `success_rate` field that
did not equal `success_count / result_count` (both are 0). No `success_count` changed. The
original values are kept in each cell's `MANIFEST.json:corrections`.
---
## Citation
See the paper. If you use a single cell rather than a table, cite the cell by its
`MANIFEST.json:identity.cell_id` and quote its `known_issues` — several cells in this
repository are published *because* they are defective and a paper number rests on them.