Datasets:

TobyYang7
/

evo-exp

---
license: other
tags:
  - osworld
  - agent-evaluation
  - interface-evolution
---
# evo-exp — Shadow Interface Evolution experiment archives

Complete, self-contained records of OSWorld-V2 interface-evolution runs: the
evolved interface code, every agent trajectory, the builder logs, the evolution
database, the run configuration, and derived result tables. Each archive is
meant to be readable by someone with no access to the machine that produced it.

Three experiments are archived here. They differ in **exactly one intended
variable each**, and the differences are listed before the numbers because most
of the numbers are not comparable across them.

---

# Which archive to take

| file | size | contents | status |
|---|---|---|---|
| `archives/qwen_syn30v15_128k_scratch-step50-20261001T183408Z-redacted.zip` | 19.55 GiB | **scratch Evo complete through step 50**, 51 versions, 2,293 available raw transcripts; see coverage caveats | **current** |
| `archives/qwen_sb_syn50v15-step30-redacted.zip` | 2.8 GiB | **ScienceBoard evolution, no scratch VM, complete through step 30**, 31 variants (seed + if-001…if-030), tournament selection: evolved interface code, builder logs, evolution DB, config, all 1,953 agent transcripts (63 per variant: 48 synthetic + 15 val) | **current** |
| `archives/qwen_syn30v15_128k-step30-redacted.zip` | 14.3 GiB | **no scratch VM complete through step 30**, 31 variants (seed + if-001…if-030): evolved interface code, builder logs, evolution DB, config, all 1,393 val + synthetic agent transcripts (45 per variant, 2 missing); held-out test transcripts are in `result/` | **current** |
| `archives/qwen_syn30v15_128k-step15-slim.zip` | 95 MiB | no scratch VM, 16 variants, steps 0–15 — scores, code, config, derived tables | superseded by `step30` |
| `archives/qwen_syn30v15_128k-step15-redacted.zip` | 13.8 GiB | the same plus all 5,630 raw agent transcripts | superseded by `step30` (numbering predates the 2026-10-01 renumber) |
| `archives/qwen_syn30v15_128k_scratch-step10-slim.zip` | 94.9 MiB | **with scratch VM**, 11 complete variants | historical snapshot |
| `archives/qwen_syn30v15_128k_scratch-step10-redacted.zip` | 5.6 GiB | the same plus transcripts, **plus a partial 12th variant** (see below) | historical snapshot |
| `archives/qwen_syn30v15_128k-bare-redacted.zip` | 1.0 GiB | **no shadow interface at all** — the baseline floor | **current** |
| `archives/upstream_qwen_108-20260925T020227Z-keyframes.zip` | 138 MiB | **upstream harness, no shadow interface** — all 108 tasks, every attempt's full transcript, key screenshots only | **current** |
| `archives/upstream_qwen_108_merged_vol60fill-20260925T164249Z-keyframes.zip` | 96 MiB | **upstream harness, merged row** — the 108 above with its 10 unscored tasks filled by a `--volume_size 60` rerun; one counted attempt per task, key screenshots only | **current** (mixed conditions, see Run 5) |
| `archives/if007_scratch_merged_108_20260925-redacted.zip` | 1.3 GiB | **held-out + val eval of one evolved variant** — `qwen_syn30v15_128k_scratch` if-007 on all 108 tasks; one counted episode per task, full transcripts, no recordings | **current** (5 tasks re-run, see Run 6) |
| `archives/qwen_syn30v15_128k-step12-redacted.zip` | 10.6 GiB | no scratch VM, steps 0–12 | superseded by `step15` |
| `archives/qwen_syn30v15_128k-step12-slim.zip` | 96 MiB | no scratch VM, steps 0–12 | superseded by `step15` |
| `archives/qwen_syn30v15_128k-redacted.zip` | 3.3 GiB | no scratch VM, steps 0–5 | superseded by `step15` |
| `archives/qwen_syn30v15_128k-slim.zip` | 81 MiB | no scratch VM, steps 0–5 | superseded by `step15` |

The superseded archives are kept for link stability. `step30` covers the whole no-scratch-VM run (steps 0–30) and uses the current variant numbering: the run was renumbered on 2026-10-01, so the variant published as `if-017` (commit 347206d) is `if-015` there. `step15` is a strict
superset of both `step12` and the unsuffixed pair — same namespace, same
config, more steps. Take `step15` unless you need a byte-identical copy of what
an earlier analysis read.

Take a **slim** archive to read results or redo analysis: all scores, code,
configuration and derived tables are in it. Take a **redacted** (full) archive
only to replay what the agent actually did, step by step.

### Integrity

```
a770ca267c38f5216d72bac2616f2adf8ba848428040994732e462cb0159cee5  qwen_sb_syn50v15-step30-redacted.zip
a1911880db32f3fe08a05507e75fd07372711114603094ee2e30da55f65220ec  qwen_syn30v15_128k-step30-redacted.zip
5ccfa693ba3e37d2122e32f6fffe2d3eb0573d4623cdffc763132afcbc832b9f  qwen_syn30v15_128k-step15-redacted.zip
3f97ecd726d0c38a61aa1b6d795c74c53a070594d865fdc484114617174c82a9  qwen_syn30v15_128k-step15-slim.zip
bbc2b8258d64cda3c0167e826bf3c512f52fa99ec81dc837e3395a71676997f9  qwen_syn30v15_128k_scratch-step10-redacted.zip
8a31ac3f19cd00d2668c1456f62fb92088135aea3ebc7b228fe67fe260209f38  qwen_syn30v15_128k_scratch-step10-slim.zip
095c08ab479f0efaf1235db50186a693275369fe12e63698d0e4696d6d897c48  qwen_syn30v15_128k-bare-redacted.zip
```

> **Credentials are redacted.** An OSWorld agent explores the VM it is given,
> and one that runs `env` records the harness's API keys into its own
> transcript. This is not an occasional accident: grounding runs as a *tool*,
> so the agent's model credentials are deliberately readable by any bash action
> it takes. Every text file here has been passed through a redactor that
> replaces such values with `<REDACTED>` while keeping the variable name. For
> `step15` that rewrote 4,099 generic assignments, 2,367 Hugging Face tokens,
> 109 Anthropic / 99 OpenRouter / 99 LiteLLM-proxy / 98 Parasail keys, and 55
> private-key blocks or headers. Every archive was scanned before upload with a
> detection list wider than what the redactor rewrites, and none contains a
> credential-shaped string.

---

---

# Scratch Evo update — complete through step 50 (2026-10-01)

[Download the full redacted archive](archives/qwen_syn30v15_128k_scratch-step50-20261001T183408Z-redacted.zip). This extends the Run 2 evolution snapshot to seed plus all 50 steps. The older step-10 downloads remain historical snapshots and also contain separate held-out material; this archive contains evolution evaluations only. Earlier descriptions below describe their original snapshots.

This archive contains all 51 interface versions: seed and if-001 through if-050.
Each version covers 30 synthetic training tasks and 15 validation tasks (2,295 task pairs).
There are 2,293 available raw `claude_trajectory.jsonl` transcripts, including inline screenshots.

Two task pairs did not generate a raw transcript: **if-034 / s_026** and **if-040 / s_021**.
Their `failure.json`, `env_spec.json`, `result.json`, and `result.txt` are retained.
A result file beside a failure record does not establish a successful attempt.

All five versions absent from the current database are included from their cached evaluations
and tagged interface code; `MANIFEST.json` lists them under `db_orphan_variants`.
The database has 46 variant rows; the archive has 51 versions.
Separate held-out evaluations and MP4 recordings are excluded from this evolution archive.

The recorded evaluation timeout is 7,200 seconds. `results/truncated_runs.csv` flags
exit 124 or elapsed time above the cap; an elapsed-time flag alone is a heuristic.
Synthetic training tasks are ungraded, so their zero scores are expected.

SHA-256: `18f6202a7acbc2f8b0fdb58848589538a7d73b0382c5ac8606744e258f53c833`

Includes tagged interface snapshots and the Git bundle, builder logs, database, run configuration, combined orchestrator logs, task results and validation matrices. Credentials are redacted. The archive includes `COVERAGE.json` and `COVERAGE.md`.

## Version lineage and cached validation scores

Scores below are sums over the full 15-task validation denominator; consult failure and timeout evidence before interpreting capability.

| Variant | Operation | Parents | Partial credit | Full credit |
|---|---|---|---|---|
| seed | seed | — | 5.375/15 | 1/15 |
| if-001 | mutation | seed | 5.485/15 | 1/15 |
| if-002 | crossover | if-001 × seed | 6.125/15 | 3/15 |
| if-003 | mutation | if-001 | 4.375/15 | 1/15 |
| if-004 | crossover | if-001 × seed | 6.561/15 | 3/15 |
| if-005 | mutation | if-004 | 5.790/15 | 4/15 |
| if-006 | crossover | if-001 × if-004 | 6.220/15 | 3/15 |
| if-007 | mutation | if-001 | 7.197/15 | 3/15 |
| if-008 | crossover | if-005 × if-007 | 5.050/15 | 0/15 |
| if-009 | mutation | if-006 | 4.895/15 | 1/15 |
| if-010 | crossover | if-005 × if-002 | 5.150/15 | 2/15 |
| if-011 | mutation | if-002 | 6.395/15 | 3/15 |
| if-012 | crossover | if-011 × if-004 | 4.300/15 | 2/15 |
| if-013 | mutation | if-004 | 3.720/15 | 1/15 |
| if-014 | crossover | if-006 × if-004 | 3.915/15 | 1/15 |
| if-015 | mutation | if-002 | 4.471/15 | 1/15 |
| if-016 | crossover | if-006 × if-005 | 6.506/15 | 2/15 |
| if-017 | mutation | if-007 | 4.455/15 | 2/15 |
| if-018 | crossover | if-007 × if-004 | 7.141/15 | 2/15 |
| if-019 | mutation | if-016 | 6.480/15 | 3/15 |
| if-020 | crossover | if-016 × if-007 | 7.286/15 | 3/15 |
| if-021 | mutation | if-004 | 5.155/15 | 3/15 |
| if-022 | crossover | if-006 × if-020 | 6.035/15 | 3/15 |
| if-023 | mutation | if-007 | 5.067/15 | 1/15 |
| if-024 | crossover | if-002 × if-006 | 7.534/15 | 4/15 |
| if-025 | mutation | if-007 | 5.790/15 | 4/15 |
| if-026 | crossover | if-011 × if-024 | 6.708/15 | 2/15 |
| if-027 | mutation | if-019 | 6.249/15 | 3/15 |
| if-028 | crossover | if-002 × if-007 | 5.005/15 | 2/15 |
| if-029 | mutation | if-004 | 6.520/15 | 4/15 |
| if-030 | crossover | if-018 × if-007 | 5.250/15 | 3/15 |
| if-031 | mutation | if-020 | 3.000/15 | 2/15 |
| if-032 | crossover | if-002 × if-030 | 5.745/15 | 3/15 |
| if-033 | mutation | if-005 | 5.720/15 | 3/15 |
| if-034 | crossover | if-012 × if-002 | 5.165/15 | 3/15 |
| if-035 | mutation | if-007 | 5.365/15 | 3/15 |
| if-036 | crossover | if-002 × if-023 | 5.496/15 | 1/15 |
| if-037 | mutation | if-024 | 7.588/15 | 3/15 |
| if-038 | crossover | if-020 × if-037 | 5.759/15 | 1/15 |
| if-039 | mutation | if-038 | 6.110/15 | 4/15 |
| if-040 | crossover | if-030 × if-002 | 5.020/15 | 3/15 |
| if-041 | mutation | if-011 | 3.125/15 | 2/15 |
| if-042 | crossover | if-022 × if-027 | 5.101/15 | 2/15 |
| if-043 | mutation | if-004 | 5.990/15 | 3/15 |
| if-044 | crossover | if-024 × if-018 | 6.740/15 | 4/15 |
| if-045 | mutation | if-006 | 4.015/15 | 1/15 |
| if-046 | crossover | if-019 × if-001 | 5.337/15 | 2/15 |
| if-047 | mutation | if-002 | 5.198/15 | 3/15 |
| if-048 | crossover | if-019 × if-044 | 3.875/15 | 2/15 |
| if-049 | mutation | if-023 | 4.590/15 | 1/15 |
| if-050 | crossover | if-017 × if-042 | 3.145/15 | 2/15 |

# The settings

All three runs share this. Deviations are called out per run.

| | value |
|---|---|
| harness | Prime Agent (`--builder-harness prime_agent`, `evaluator_harness=prime_agent`) |
| builder model | `openai/simular-qwen-3p8-27b-evolving-agents` (self-hosted Qwen 3.8-27B) |
| eval model | the same deployment — a variant is written and graded by one model |
| **grounding model** | **also the same deployment.** The evaluator exports `SHADOW_GROUNDING_MODEL=<eval model>`, so the interface's UI-grounding helper calls the island's own model. There is no separate grounding model. (Earlier project runs used Parasail UI-TARS; `PARASAIL_API_KEY` survives in the tool allowlist.) |
| context window | **131,072 (128K)**, declared in `shadow_interface/context_compaction.json` with `context_window_source = interface` |
| train set | `synthetic_train_30.json` — 30 synthetic `s_*` tasks, **UNGRADED** |
| val set | `osworld_v2_val_15.json` — 15 graded tasks: `007 010 014 019 041 046 048 058 064 069 072 079 083 105 108` |
| selection signal | `val` |
| parent selection | `tournament` |
| scheduler | `deterministic:0,2,0` (alternating mutation / crossover) |
| elimination count | 5 — **no elimination event was ever recorded**; every variant stays in the pool |
| per-task wall clock | 7,200 s builder, 7,200 s eval |
| max agent steps | 300 |
| env concurrency | 45 |
| region | `us-east-1`, public IP |
| website deployment | `52.91.237.94.nip.io` — a **self-hosted substitute**, not the pinned `site.hku.icu` |
| egress proxy | `allow_placeholder_proxy=1` — the proxy config holds placeholder credentials |

### Two settings that bound what these numbers can support

**The proxy is not configured.** With placeholder credentials, 6 train tasks
(`037 055 062 075 098` and `056`) and 2 test tasks (`036 050`) fail for lack of
an egress proxy. Those failures are indistinguishable from genuine interface
failures, so they bias every selection step. The orchestrator says so itself on
every launch: *"This run is a diagnostic, not a reportable result."*

**The websites are a substitute stack.** 40 of the tasks are website-backed.
Scores on them are comparable only to other runs on this same substitute
deployment — not to any run measured against the pinned `site.hku.icu` host.

---

# Run 1 — `qwen_syn30v15_128k`: no scratch VM

`--no-scratch-vm`: the builder writes the interface without a VM to try it in.
`--max-steps 30`, so **this archive is a mid-run snapshot at step 15**, not a
finished run.

16 variants. `val partial` is the summed raw score over the 15 val tasks;
`val binary` counts only full credit.

| step | variant | op | parent(s) | val partial | val binary |
|---|---|---|---|---|---|
| 0 | seed | — | — | 5.375 / 15 = 35.8% | 1/15 |
| 1 | if-001 | mutation | seed | 5.851 / 15 = 39.0% | 1/15 |
| 2 | if-002 | crossover | if-001 × seed | 5.540 / 15 = 36.9% | 1/15 |
| 3 | if-003 | mutation | if-002 | 5.255 / 15 = 35.0% | 1/15 |
| 4 | if-004 | crossover | if-002 × if-001 | 5.200 / 15 = 34.7% | 3/15 |
| 5 | if-005 | mutation | seed | 4.575 / 15 = 30.5% | 3/15 |
| 6 | if-006 | crossover | if-001 × seed | 5.600 / 15 = 37.3% | **4/15** |
| 7 | if-007 | mutation | if-001 | 7.045 / 15 = 47.0% | 2/15 |
| 8 | **if-008** | crossover | if-001 × seed | **7.180 / 15 = 47.9%** | 3/15 |
| 9 | if-009 | mutation | if-008 | 6.070 / 15 = 40.5% | 3/15 |
| 10 | if-010 | crossover | if-001 × if-009 | 5.965 / 15 = 39.8% | 3/15 |
| 11 | if-011 | mutation | if-002 | 6.731 / 15 = 44.9% | **4/15** |
| 12 | if-012 | crossover | if-001 × if-010 | 4.738 / 15 = 31.6% | 2/15 |
| 13 | if-015 | mutation | if-012 | 5.607 / 15 = 37.4% | 3/15 |
| 14 | if-016 | crossover | — | 6.645 / 15 = 44.3% | 3/15 |
| 15 | if-017 | mutation | — | 6.673 / 15 = 44.5% | 3/15 |

**`if-013` and `if-014` do not exist.** On 2026-09-22 an expired AWS SSO token
made VM allocation fail for all 45 tasks of both variants. The harness wrote
those retry-exhausted tasks as real `0.000` scores with
`infrastructure_failed: 0`, so they entered the DB as legitimate worst-in-pool
individuals. They were purged and the two steps re-dispatched; the `if-`
counter did not rewind, so step 13/14/15 carry `if-015/016/017`.

Other facts for this run: 5,630 trajectory files, 4,186 held-out files across
101 held-out tasks / 671 runs / **42 rerun pairs**, and **65 of 240 val runs
(27.1%) truncated** by the 2 h wall clock.

---

# Run 2 — `qwen_syn30v15_128k_scratch`: with scratch VM
Identical to Run 1 **except** that the scratch VM is enabled (the builder gets
a VM to try the interface in while writing it) and `--max-steps 15`. Every
other flag matches, which makes these two runs a clean A/B on the scratch VM.
`dispatch_log` records steps 1–10 complete. The `variants` table holds only 6
rows: **seed, if-003, if-008, if-009, if-010 and if-011 were evaluated but
their DB rows never landed.** Their trajectories, git tags and builder logs are
all present, so they are fully auditable; their lineage below was recovered
from each tag's commit subject, and they are listed in
`MANIFEST.json → db_orphan_variants`. Their `step` and `val_score` fields are
empty in the DB-derived tables — the real scores are in
`results/val_matrix.csv`, computed from `result.txt`.

| step | variant | op | parent(s) | val partial | val binary | DB row |
|---|---|---|---|---|---|---|
| — | seed | — | — | 5.375 / 15 = 35.8% | 1/15 | missing |
| 1 | if-001 | mutation | seed | 5.485 / 15 = 36.6% | 1/15 | ✅ |
| 2 | if-002 | crossover | if-001 × seed | 6.125 / 15 = 40.8% | 3/15 | ✅ |
| — | if-003 | mutation | if-001 | 4.375 / 15 = 29.2% | 1/15 | missing |
| 4 | if-004 | crossover | if-001 × seed | 6.561 / 15 = 43.7% | 3/15 | ✅ |
| 5 | if-005 | mutation | if-004 | 5.790 / 15 = 38.6% | **4/15** | ✅ |
| 6 | if-006 | crossover | if-001 × if-004 | 6.220 / 15 = 41.5% | 3/15 | ✅ |
| 7 | **if-007** | mutation | if-001 | **7.197 / 15 = 48.0%** | 3/15 | ✅ |
| — | if-008 | crossover | if-005 × if-007 | 5.050 / 15 = 33.7% | **0/15** | missing |
| — | if-009 | mutation | if-006 | 4.895 / 15 = 32.6% | 1/15 | missing |
| — | if-010 | crossover | if-005 × if-002 | 5.150 / 15 = 34.3% | 2/15 | missing |

There is no step 3 row in `dispatch_log`'s variant output either; `if-003` is
the step-3 child.

### The full archive holds one extra, incomplete variant

`qwen_syn30v15_128k_scratch-step10-redacted.zip` contains a **12th** variant,
`if-011`, with only **2 of 45** `result.txt` files. It appeared on disk between
the slim and full packaging runs and was picked up mid-evaluation. **Do not read
it as a result.** The slim archive holds the 11 complete variants only. The
archive name reflects the last completed dispatch step (10).

Other facts: 3,932 trajectory files, 458 held-out files across 52 tasks / 133
runs / 0 rerun pairs, and **37 val runs truncated**.

---

# Run 3 — `qwen_syn30v15_128k-bare`: no shadow interface

The floor the whole experiment is measured against. Prime Agent with **nothing
deployed to the VM**: no shadow interface, no `setup.sh`, no eval constraints,
and the stock `NO_TOOL_SYSTEM_PROMPT` instead of `TOOL_SYSTEM_PROMPT`.

Three consequences:

1. `--no_tool` moves the action space, and with it the output directory, to
   `shadow_eval_no_tool/`. A reader that hardcodes the `shadow_eval/` prefix
   reports this run as empty.
2. The leak guard is off. A baseline has no training set to leak from, and the
   point is to cover `val_15` too, so the number is comparable to the 108-task
   denominator.
3. **The proxy is off** for this run, unlike Runs 1 and 2 — the orchestrator is
   already in the US, and a controlled probe showed the proxy changes no score
   while placeholder credentials only force failures.

```
108 held-out tasks | 190 runs | 6 rerun pairs | 935 files
115 runs carry a score: mean 0.3845, 17 at full credit
```

Batches: `osworld_v2_full_108` (55), `osworld_v2_bare_remaining` (92),
`osworld_v2_bare_imputed_rerun` (1), and `_aborted_hku` (42 — an abandoned
attempt against the pinned host, kept and prefixed).

**Read this before claiming the evolution works.** The bare floor's partial
mean of 0.3845 sits inside the 0.29–0.48 band that every evolved variant in
Runs 1 and 2 occupies. The task sets and denominators differ, so this is not a
head-to-head — but `results/heldout_matrix.csv` now carries a bare column, and
aligning on the shared tasks is the comparison that decides whether an evolved
interface beats having no interface at all.

---

# Archive structure

Every archive unpacks to one directory named `<namespace>-<UTC timestamp>/`.

```
<namespace>-<timestamp>/
├── MANIFEST.json            provenance and self-description — read this first
├── config/                  what was run
├── db/                      the evolution SQLite database
├── results/                 derived tables (read these second)
├── interfaces/              the evolved code, per variant, plus a git bundle
├── builder_logs/            one JSONL per builder invocation
├── logs/console.log         the orchestrator's own output
├── trajectories/            <variant>/<task>/ — val + synthetic-train runs
└── trajectories_heldout/    <variant>/<task>/<eval set>__<stamp>/ — held-out runs
```

## `MANIFEST.json`

| key | meaning |
|---|---|
| `namespace`, `created_utc`, `eval_model` | which run, packaged when, scored by which model |
| `variants` | rows from the DB: `id`, `origin`, `step`, `parent_id`, `parent_b_id`, `score`, `val_score`, `tag` |
| `db_orphan_variants` | variants archived from disk that have **no DB row** (Run 2) |
| `val_task_ids` | the 15 graded task ids |
| `task_cap_seconds` | the per-task wall clock (7200) used to flag truncated runs |
| `truncated_val_runs` | how many val runs hit that wall clock |
| `held_out_tasks` / `_runs` / `_rerun_pairs` | held-out coverage; rerun pairs are the only direct measure of harness noise here |
| `redacted`, `redactions` | whether redaction ran, and how many substitutions per rule |
| `slim`, `recordings_included` | which variant of the archive this is |
| `run_config` | the full launch configuration |

## `config/`

`run_config.json` (full command line, models, timeouts, scheduler, parent
selection, concurrency, AWS region/subnet/security group, seed SHA-256s),
`eval_sets/osworld_v2_val_15.json`, `eval_sets/synthetic_train_30.json`, and
`seed_context_compaction.json` (`context_window_tokens`, `reserve_tokens`,
`keep_recent_tokens`).

## `db/`

`shadow_evolution_osworld_v2_<namespace>.db`, SQLite. Tables: `variants`,
`eval_results` (per variant per task), `cost_events`, `dispatch_log`,
`history`, `islands`, `eval_sets`, `val_set`.

```sql
select id, origin, step, parent_id, parent_b_id, round(val_score,4)
from variants order by rowid;
```

`eval_sets` is empty in these runs — that table was never written; the task
sets live in `val_set` and in `config/eval_sets/`.

## `results/`

Generated at packaging time from the trajectories, so they agree with the raw
files by construction.

| file | contents |
|---|---|
| `val_matrix.csv` | 15 rows, one per val task, one column per variant |
| `variants.csv` | lineage and final scores |
| `truncated_runs.csv` | **read this before interpreting any zero** |
| `heldout_runs.csv` | one row per (variant, run, task) — reruns included |
| `heldout_matrix.csv` | each task resolved to one score per variant, latest run wins |
| `heldout_reruns.csv` | tasks run more than once, with `abs_delta` |

## `interfaces/`

A git bundle carrying every variant tag **and the commit graph**, plus flat
per-variant snapshots of `shadow_interface/`. The bundle is authoritative — it
shows how each variant was derived from its parent, which the snapshots cannot.

```bash
git init evolved && cd evolved
git fetch ../<namespace>-<timestamp>.bundle 'refs/tags/*:refs/tags/*'
git log --oneline --graph --all
git diff evol/<ns>/seed evol/<ns>/if-001 -- shadow_interface
```

The bundles here record a complete history, including the upstream OSWorld
commits the seed was cut from.

## `trajectories/` and `trajectories_heldout/`
Each task directory holds `result.txt` (the score, one float), `result.json`
(grading detail including safety checks), `traj.jsonl` (one-line run summary
with `elapsed_seconds`, `hitl_turns`), `claude_trajectory.jsonl` (**the raw
transcript** — omitted from slim archives), `claude_stderr.log`,
`exit_code.txt` (**124 means the wall clock killed it**), `instruction.txt`,
`env_spec.json`, and sometimes `phase_results.json` or `failure.json`.

Token accounting lives on each `turn_end` event:

```json
{"input": 5179, "output": 137, "cacheRead": 0, "cacheWrite": 0,
 "totalTokens": 5316, "cost": {"input": 0, "output": 0, "total": 0}}
```

`cost` is zero throughout: the model is a self-hosted deployment that declares
zero per-token price. That is structural, not a measurement gap. Counting
`turn_start` events gives the step count.

A `failure.json` next to a `result.txt` can accompany a failed attempt or a later retry.
Inspect the attempt evidence before treating the score as a successful evaluation.

---

# Caveats

Beyond the two setting-level limits above, five things are easy to read wrong.
All are recorded in `MANIFEST.json`.

**1. Synthetic `s_*` tasks are UNGRADED** — constant zero by construction,
`verification: dummy_constant_zero`. Their `result.txt` is always `0.0`, so the
`train` score is `0.000` for every variant in Runs 1 and 2 and carries no
information. Only the 15 val ids are graded, and the denominator is the full
val set even when fewer finished.
**2. A truncated run is not a capability zero.** A task cut off by the 2 h
per-task wall clock exits **124** (or reports `elapsed_seconds` above 7200),
writes a **real score** — almost always `0.000` — and writes **no
`failure.json`**, so infra-failure checks cannot see it. 27.1% of Run 1's val
runs were truncated. `results/truncated_runs.csv` lists every one.

**3. The context window is inside the evolvable interface.** Because
`context_window_tokens` lives in `shadow_interface/context_compaction.json` and
that file is listed as evolvable, **a child variant can change its own context
window.** Neither run is a fixed-window single-variable experiment.

**4. The seed was not re-evaluated.** Its 45 task directories were copied in
from two earlier 128K runs rather than measured again, so the seed row is not
comparable to its children on the truncation axis. Both runs' seeds report the
same 5.375, which is that same cached measurement.

**5. `val` at n=1 cannot resolve this ladder.** Each variant's fitness is one
run of 15 tasks. Across this project's earlier runs the spread between repeated
evaluations of the *same* parent pair reached 1.64 points on the same 15-task
scale — wider than most of the gaps in the tables above. Independent evidence:
in the project's `prime25v15r4` run, the two variants that also received a
68-task held-out evaluation ranked **in the opposite order** on the larger set
(`if-006` 62.4% vs `if-008` 51.7%) from how they ranked on `val_15`. Treat
single-variant val differences here as noise unless a held-out set confirms
them.

---

# Adding a run to this repo

The archives are produced by the `evo-archive` skill in the source repository:
`package_experiment.py` builds the zip from an allowlist of filenames (never a
directory sweep) with redaction on by default, and `upload_experiment.py`
scans the result and refuses to upload if it finds a credential shape.
Archives are keyed by namespace and name, so adding one overwrites nothing.

# Run 4 — `upstream_qwen_108`: the upstream harness, for comparison

The same model under **xlang-ai/OSWorld-V2's own Qwen scaffold**
(`mm_agents/qwen` + `scripts/python/run_multienv_qwen.py`) instead of the Prime
Agent, on the same 108 tasks. It is the reference point the interface rows are
measured against: not "no shadow interface" like Run 3, but *a different
harness entirely*.

| denominator | n | binary | partial |
|---|---|---|---|
| every failure counts 0 — **recommended** | 108 | 6 = **5.56%** | 22.348 = 20.69% |
| drop only failures that were infrastructure in every pass | 102 | 6 = 5.88% | 22.348 = 21.91% |
| … also dropping the 3 unattributable ones | 99 | 6 = 6.06% | 22.348 = 22.57% |

98 of the 108 tasks are graded. Four passes were run; the archive holds all
163 attempts, not just the scoring one.

### Why 10 tasks have no score, and why it counts against this row

Eight died on the host-side screenshot path and two on the model's own
malformed tool XML. The screenshot failure is **deterministic, not
infrastructure noise**: across four passes the crashed set is strictly nested
(108 → 31 → 14 → 10 → 10) and *no task ever entered it*, and 5 of the 8 deaths
are monotonic — the guest serves 9–27 frames, then returns 500 twenty-four
times running and never recovers.

The cause is ENOSPC. All 136 failed `/screenshot` bodies read
`OSError: [Errno 28] No space left on device`. `desktop_env.py:146` expands the
guest partition only for tasks that declare `volume_size`, so these guests sat
at 29.5 GB with ~400 MB free while snapd's boot-time auto-refresh grew
`/var/lib/snapd` to 11–13 GB. Upstream's own `--volume_size 60` fixes it — that
is what the Prime-Agent runs already default to, which is why they are
unaffected (59 GB with 26–28 GB free).

A defect in a component only one architecture depends on is that
architecture's failure: upstream's agent runs on the host and pulls a frame
through `GET /screenshot` every step, while an in-guest agent scores all 10 of
these tasks normally. Hence the flat 108.

### Caveats specific to this run

- **43 of the 98 graded tasks saw at least one screenshot 500 during their
  scoring attempt**, so their episode ran on a guest that reached zero free
  disk even though a score came out (070 and 073 scored 1.0 with four 500s
  each). Exposure tracks episode length — median 144 steps against 112 — so the
  55 unexposed tasks are the *shorter* ones, not a random subsample. "Never saw
  a 500" means "not observed to have hit zero", which is weaker than "ran with
  headroom".
- **The snap auto-refresh runs on every guest of both harnesses**, refreshing a
  varying number of snaps (7, 8, 10 and 11 observed), so which application
  versions a task faces depends on boot time and on the snap store at that
  moment. This is uncontrolled across *every* row in this repository. It is not
  an extra error term — the measured rerun noise floor (mean |Δ| 0.186 per
  task) already operated under it — but it is a plausible mechanism behind it.
- **Agent-side flags are upstream defaults** (`max_steps 500`,
  `max_tokens 32768`, `image_max 20`). Only infrastructure retry budgets were
  patched: HTTP statuses ×8 and `PythonController.retry_times` 3 → 24. All 98
  scores come from patched runs, so the row is homogeneous on that axis.
- **Step budget differs from the Prime rows**: 500 here against 300 there. 12
  of 108 tasks exceeded 300 steps and *none* scored 1.0, so the confound is
  worth at most ≈2.3 pp of partial and nothing on binary.
- **Thinking is on by default** and upstream's `enable_thinking` flag is inert
  on this deployment — only `chat_template_kwargs` is read. Reasoning tokens
  are generated and billed but never returned, so `completion_tokens` is not
  visible text. The deployment's context window is 262144, and no request in
  any pass was rejected for length.

### What `-keyframes` means here

Unlike the `-slim` archives above, **no transcript is omitted**. All 163
attempts carry their full `traj.jsonl`, `runtime.log` and `eval.log`. What is
trimmed is step screenshots: 19,494 PNGs are 7.8 GB against a few tens of MB of
everything else, so the archive keeps every 0-byte PNG plus the last two
non-empty frames of each task. The 0-byte frames are not corruption — they are
the fingerprint of the crash above, since `lib_run_single.py:948` opens the file
`"wb"`, truncating it, before the write raises on a `None` screenshot.

### Redaction note

OSWorld task instructions state credentials in **prose** ("the password is
'…'"), a shape the standard redactor — which matches `NAME=value` — cannot see.
This archive was additionally passed through a prose-aware rule; 1,818 values
are replaced with `<REDACTED>` while the surrounding sentence and account names
are kept, so the trajectories still read as the task the agent was given.

# Run 5 — `upstream_qwen_108_merged_vol60fill`: Run 4 with its 10 gaps filled

Run 4 left 10 of 108 tasks without a score. This archive keeps Run 4's 98
graded tasks exactly as counted there and fills the 10 gaps
(`020 037 041 050 062 074 097 100 103 104`) with a rerun that passes
upstream's own `--volume_size 60`. It holds **one directory per task, the
attempt the row counts**, plus `scores.csv` (task, source, root size, score).

| row | n | binary | partial |
|---|---|---|---|
| Run 4, as run (10 unscored = 0) | 108 | 6 = 5.56% | 22.348 = 20.69% |
| **Run 5, merged** | 108 | **6 = 5.56%** | **23.405 = 21.67%** |

The 10 filled tasks: 104 = 0.45, 103 = 0.25, 097 = 0.25, 020 = 0.1,
062 = 0.008, 037 = 0.0, 041 = 0.0 (hit the 500-step cap), 050 = 0.0,
074 = 0.0, 100 = crash (malformed tool XML, counted 0).

### Why the 10 were unscored

The guest root filled up. snapd auto-refreshes ~10 stale snaps at boot into
`/var/lib/snapd` (11–13 GB), and `desktop_env.py` only grows the root
partition when `volume_size` is set, so these guests stayed at 29.5 GB on a
40 GB disk with ~400 MB free. All 136 failed `/screenshot` bodies in the
diagnostic pass were `OSError: [Errno 28] No space left on device`. With
`--volume_size 60` the guests run 59 GB with ~31 GB free, and the rerun saw
zero screenshot 500s.

### Caveats

- **Mixed conditions.** 98 tasks ran on the unexpanded 29.5 GB root, 10 on
  60 GB. This is neither the as-shipped row (Run 4) nor a uniform
  `--volume_size 60` row; a uniform 108 rerun is in progress.
- 43 of the 98 Run-4 scores came from attempts that hit at least one
  screenshot 500, i.e. the disk reached zero mid-episode.
- 050's website fetches returned HTTP 407 from the egress proxy, so its 0 is
  not a capability measurement.
- The rerun was relaunched once after the LiteLLM proxy's public IP changed;
  unfinished tasks restarted from step 1, and the two tasks graded before
  that were checked for Connection-error endings (none).
- Redaction: 30 `NAME=value` values and 607 prose-form credentials replaced
  with `<REDACTED>`; an independent wider scan found no credential shape.

---

# Run 6 — `if007_scratch_merged_108`: if-007's full 108-task evaluation
The evolved interface `evol/qwen_syn30v15_128k_scratch/if-007` (from Run 2),
run with Prime Agent on `simular-qwen-3p8-27b-evolving-agents` over all 108
tasks: 93 held-out (`heldout_93/`) plus the 15 val tasks the evolution used as
fitness (`val_15/`, taken from the evolution eval cache). **One directory per
task, the episode the row counts**, plus `scores.csv` (score, source run,
harness, replaced score and reason per task), `MANIFEST.json`, and the
interface code (`shadow_interface_if-007/`).

| row | n | binary | partial |
|---|---|---|---|
| as run, no replacements | 108 | 16 = 14.81% | 47.204 = 43.71% |
| strict: only 066 replaced (same harness as seed) | 108 | 17 = 15.74% | 48.204 = 44.63% |
| **merged: all 5 replacements** | 108 | **17 = 15.74%** | **50.286 = 46.56%** |

For reference, Run 1's seed scores 47.121 partial on the same 108 tasks, and
Run 3 (bare) 47.526.

### Which episode each task counts

- Held-out: the latest completed run of `full_minus_val_93` → `remaining_41`
  → `ce_rerun_4` → `499_rerun_1`. The last two re-measure 042 067 094 106,
  whose episodes were cut by infrastructure (a `Connection error` while the
  LiteLLM proxy was resized, then a `499 Client Closed Request` on 042).
- Five tasks count a re-run instead of the original episode:
  - **043 063 080 086** — the original ended on a reply that hit the 32k
    output cap with no tool call (`stopReason=length`), which Prime's loop
    treats as a finished episode, so the task was scored mid-thought (0.0625,
    0, 0, 0). Re-run with `SHADOW_EVOL_LENGTH_CONTINUATIONS=3`: the harness
    resumes the same session after such a reply. Only 043 actually resumed
    (twice); 063, 080 and 086 did not truncate on the re-run.
    New scores 0.6875, 0.7, 0.657, 0.1.
  - **066** — the original ended on `422 No valid tool call after 6
    attempts` (0); plain re-run, 1.0.
### Caveats

- **Harness difference.** The four length-continuation re-runs used a harness
  the seed and bare rows did not. Compare with seed on the strict row.
- **n = 1 per task.** Re-running one variant moves a task by ~0.19 on average
  in this namespace; single-task differences are not findings.
- The length truncation is task-driven, not specific to if-007: 043
  truncates under seed and bare too.
- Recordings omitted. Redaction: 412 `NAME=value` credentials replaced with
  `<REDACTED>`; the wider pre-upload scan found no credential shape.


---

## 108-task result archives (uploaded 2026-10-01)

| Experiment | Tasks | Archive size | URL |
|---|---:|---:|---|
| Evo if-020 | 108 | 1.43 GB | https://huggingface.co/datasets/TobyYang7/evo-exp/blob/main/result/evo_if020_full108_redacted.zip |
| Evo if-024 | 108 | 1.43 GB | https://huggingface.co/datasets/TobyYang7/evo-exp/blob/main/result/evo_if024_full108_redacted.zip |
| Evo if-037 | 108 | 1.47 GB | https://huggingface.co/datasets/TobyYang7/evo-exp/blob/main/result/evo_if037_full108_redacted.zip |
| Linear if-029 | 108 | 1.42 GB | https://huggingface.co/datasets/TobyYang7/evo-exp/blob/main/result/linear_if029_full108_redacted.zip |

See [result/README.md](result/README.md) for coverage, verification and checksums.