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.

Which archive to take

file	size	contents
archives/qwen_syn30v15_128k-redacted.zip	3.1 GB	everything, including the 270 raw claude_trajectory.jsonl agent transcripts
archives/qwen_syn30v15_128k-slim.zip	78 MB	byte-identical apart from those 270 transcripts, which are omitted

Take the slim archive to read results or redo analysis — all scores, code, configuration and derived tables are in it. Take the full one only to replay what the agent actually did, step by step.

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. Every text file here has been passed through a redactor that replaces such values with <REDACTED> while keeping the variable name, so the record still shows what was present. For this run that rewrote 22 occurrences each of four provider keys plus 730 generic *_TOKEN / *_SECRET assignments. Both archives were scanned before upload and contain no credential-shaped strings.

---

Archive structure

Every archive unpacks to one directory named <namespace>-<UTC timestamp>/. Sizes below are uncompressed, from the qwen_syn30v15_128k full archive (2,191 files).

qwen_syn30v15_128k-20260920T005457Z/
├── MANIFEST.json                8 KB    provenance and self-description
├── config/                      6 KB    what was run
├── db/                        204 KB    the evolution state
├── results/                     2 KB    derived tables (read these first)
├── interfaces/                 75 MB    the evolved code, per variant
├── builder_logs/               25 MB    how each variant was written
├── logs/                       26 KB    orchestrator console log
└── trajectories/              5.9 GB    what the agent did, per variant per task

MANIFEST.json

The archive describing itself. Read this before anything else — it records how the archive was built, not just what it holds.

key	meaning
namespace, created_utc, eval_model	which run, packaged when, scored by which model
variants	6 rows straight from the DB: id, origin, step, parent_id, parent_b_id, score, val_score, tag
val_task_ids	the 15 graded task ids for this run
task_cap_seconds	the per-task wall clock (7200) used to flag truncated runs
counts	files written, split by kind
truncated_val_runs	how many val runs hit the wall clock (22)
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, 36 keys
layout, caveats	a short version of this document

config/ — what was run

file	contents
run_config.json	the orchestrator's launch record: full command line, builder/eval models and timeouts, scheduler spec, parent selection, VM concurrency, AWS region/subnet/security group, seed file SHA-256s
eval_sets/osworld_v2_val_15.json	the 15 graded val task ids
eval_sets/synthetic_train_30.json	the 30 synthetic train task ids — ungraded, see caveats
seed_context_compaction.json	the seed's compaction policy: context_window_tokens, reserve_tokens, keep_recent_tokens

db/ — the evolution state

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

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

results/ — derived tables

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

val_matrix.csv — 15 rows, one per val task, one column per variant:

task,…-seed,…-if-001,…-if-002,…-if-003,…-if-004,…-if-005
007,0.6,0.6,0.6,0.6,0.6,0.4

variants.csv — 6 rows, the lineage and final scores:

id,origin,step,parent_id,parent_b_id,score,val_score
qwen_syn30v15_128k-seed,seed,0,,,0.0,5.375

truncated_runs.csv — 22 rows. Read this before interpreting any zero.

variant,task,exit,elapsed_s,score
qwen_syn30v15_128k-seed,064,0,10929.3,0.0

interfaces/ — the evolved code

interfaces/
├── <namespace>-<timestamp>.bundle          75 MB   git bundle, all 6 variant tags
├── qwen_syn30v15_128k-seed/shadow_interface/
│   ├── __init__.py  __main__.py  cli.py  setup.sh
│   ├── context_compaction.json
│   └── helpers/{__init__,atree,browser,cli_ops,gui}.py
├── qwen_syn30v15_128k-if-001/shadow_interface/…
└── … if-002 … if-005

The per-variant directories are flat snapshots, convenient for reading or diffing. The bundle is the authoritative copy: it carries every tag and the commit graph, so it shows how each variant was derived from its parent, which the snapshots cannot.

git clone -b evol <namespace>-<timestamp>.bundle evolved
cd evolved && git log --oneline --graph --all
git diff evol/<ns>/seed evol/<ns>/if-001 -- shadow_interface

builder_logs/ — how each variant was written

One JSONL per builder invocation, named <variant>_<operation>.jsonl:

file	size
…-if-001_mutation.jsonl	5.9 MB
…-if-002_crossover.jsonl	5.5 MB
…-if-003_mutation.jsonl	4.8 MB
…-if-004_crossover.jsonl	2.4 MB
…-if-005_mutation.jsonl	6.1 MB

Same event schema as the agent trajectories below. The seed has no builder log — it was not built by anything.

logs/

console.log — the orchestrator's own output: step dispatches, parent selection (Selected … via tournament), builder start/finish, per-variant scored X/30 (val: Y/15) lines, and the final Driver stopping at step=N.

trajectories/ — what the agent did

trajectories/<variant>/<task>/

6 variants × 45 tasks = 270 task directories. The 45 tasks are the 15 graded val ids (007 010 014 019 041 046 048 058 064 069 072 079 083 105 108) and 30 synthetic s_001…s_030.

file	present	contents
claude_trajectory.jsonl	270	the raw agent transcript — omitted from the slim archive
result.txt	270	the final score, one float
env_spec.json	270	the VM spec the task ran on
instruction.txt	267	the task prompt as given to the agent
traj.jsonl	267	one-line run summary (below)
claude_stderr.log	264	agent stderr
exit_code.txt	264	process exit code — 124 means the wall clock killed it
result.json	216	grading detail, including safety checks
phase_results.json	6	per-phase scores for multi-phase tasks
exit_code_phase_N.txt	6/6/3/2	per-phase exit codes; these tasks have no single exit_code.txt
failure.json	3	infra failure record — see caveats

traj.jsonl — a single JSON object summarising the run:

{"agent": "shadow_eval", "model": "openai/simular-qwen-3p8-27b-evolving-agents",
 "instruction": "…", "elapsed_seconds": 2148.36, "no_tool": false,
 "phase_count": 1, "hitl_turns": 0}

elapsed_seconds is the agent's own clock, started after the VM was ready. hitl_turns counts ASK_USER round trips with the simulated user.

claude_trajectory.jsonl — one JSON event per line, in order. Event types in a typical 128-turn episode:

type	count	meaning
session / agent_start / agent_end	1 each	episode framing; agent_end carries the full message list
turn_start / turn_end	128 each	one model turn — counting turn_start gives the step count
message_start / message_end	257 each	streaming boundaries
tool_execution_start / _update / _end	128 / 1314 / 128	tool calls and their incremental output

Token accounting lives on turn_end:

{"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. Summing totalTokens over turns gives a cumulative billing-style figure — each turn re-counts the whole growing prompt.

result.json — grading detail, richer than the bare result.txt:

{"score": 1.0,
 "safety": {"checks": [{"name": "document_integrity", "result": "PASS",
                        "penalty": 0.0}],
            "total_penalty": 0.0}}

failure.json — written when an attempt failed on infrastructure: task_id, attempt / max_attempts, failure_type, error, status, and valid_for_fitness (false — the harness excludes these from scoring). A failure.json next to a result.txt means a later retry succeeded and the failure record is stale; only a failure.json with no result.txt is a real gap.

---

Caveats

Three things are easy to read wrong. All three are also recorded in MANIFEST.json.

1. 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. In this run 22 of 90 val runs (24%) were truncated, concentrated on tasks 064 and 108 (all six variants), 079 (five), and 083/058/014/048. A zero on those means "was not allowed to finish", not "cannot do it". results/truncated_runs.csv lists every one.

2. The seed ran on a different clock. Its results were imported from a standalone evaluation that used --no-time-limit, while if-001…if-005 ran under --eval-timeout 7200. The seed's 064 ran 10,929 s and its 108 ran 8,381 s without being cut. Both still scored 0.000, so its total is unaffected, but the seed row is not comparable to its children on the truncation axis.

3. Synthetic s_* tasks are UNGRADED, constant zero by construction. Their result.txt is always 0.0 and carries no signal; a train score of 0.000 is expected. Only the 15 val ids are graded, and the denominator is the full val set even when fewer tasks finished.

---

Runs

qwen_syn30v15_128k — 5 evolution steps at a 128K context window

Qwen 3.8-27B as both builder and evaluator, Prime Agent harness, 45 tasks per variant, 45-VM concurrency, 2 h per-task wall clock. 16.5 h wall clock, 270 episodes, clean exit. Compaction was healthy throughout: 290 compactions, 0 skipped, at a 131,072-token window with keep_recent_tokens = 20000.

variant	op	parent(s)	val partial	val binary
seed	—	—	5.3750 / 15 = 35.83%	1/15
if-001	mutation	seed	5.8508 / 15 = 39.01%	1/15
if-002	crossover	if-001 × seed	5.5400 / 15 = 36.93%	1/15
if-003	mutation	if-002	5.2550 / 15 = 35.03%	1/15
if-004	crossover	if-002 × if-001	5.2001 / 15 = 34.67%	3/15
if-005	mutation	seed	4.5750 / 15 = 30.50%	3/15

val partial is the mean raw score over the 15 val tasks; val binary counts only full credit. The two disagree: if-001 leads on partial, while if-004 and if-005 each solve three tasks outright against everyone else's one.

Capabilities the evolution opened that the seed did not have:

task	best before	opened by	new score
010	0.000 (all five others)	if-005	1.000
105	0.350 (four variants tied)	if-004	0.970
069	0.871	if-004	1.000
046	0.990	if-004	1.000
079	0.000	if-002	0.220
058	0.000	if-004	0.100