About the Archive

An AI Assisted Speedrun is one continuous attempt by one agent to reach a stated goal in one game, played through exactly three tools (<game>_documentation, <game>_screenshot, <game>_exec), with every decision logged on one timeline and the run recorded. What a published run must contain and how runs may be compared is defined in the AAS specification, draft 0.45.

Each run declares a value for each of the seven category axes (game, build, goal, observation, input, timing, human). Runs can only be compared when they match on every axis except the agent. The two clocks are real time (recording start to end, summed over segments) and in-game time (the game's own clock, summed over the playbacks). All time between playbacks is thinking time.

Published by the tooling from its main branch: last changed in commit d066e0f on 2026-10-11 03:16 +02:00.

In every run here, a language model tries to reach a goal in as little in-game time as possible. It is ranked against other AI runs in the same category. As in a tool-assisted speedrun, the game waits while the model works out its next inputs. In-game time is what counts. Real time shows how long the model took, most of it spent thinking. For now the models are far slower than human players, and the Archive keeps the evidence to show whether that changes.

Across the 4 runs on the site: 8.01M tokens in total, the smallest run 158.7K, the largest 3.41M. A run states what it used; what it cost is the operator's own.

The tooling keeps three things apart, and so does this Archive:

• The run directory stays on the machine that made the run. It holds the complete private log, the game's saves and the recording as it came out of the recorder: everything, including what should never leave that machine. It is never uploaded and never shown.
• The public zip, <run_id>-public.zip, is the bundle and nothing else: the agent's log, summary.json, timeline.json, the chapters, the exact tools, instructions and configuration the agent had, and manifest.json with a sha256 of every file. Its manifest says what it is (bundle.kind is aas-public) and which run it is; this Archive reads nothing without that marker. It carries no video and no link to one. The log is not the raw one: it strips what it recognises: images, the model's thinking, the runtime's host context, paths under a user's home folder, e-mail addresses, credentials in known forms, IP addresses and web addresses other than loopback, and session identifiers (the list is in the specification, §5). Everything else the model read or wrote is in it verbatim, and so are AGENTS.md and the goal prompt, which the runner wrote; that is why the runner reads the public zip before sharing it.
• The upload zip, <run_id>-upload.zip, is for the Archive alone: the same bundle, a note that says so (UPLOAD-ONLY.txt) and, for a run recorded with proof, a private part with the raw logs. The Archive takes only this zip. It reads the note and the private part and stores neither: what it keeps, checks and serves is the public zip's contents, and the private part is deleted once the submission is decided. Offered the public zip, it names the upload zip to send; a zip with a private part but no note is refused as neither.

• It runs the tooling's own check, a pinned copy of aas check: that this is a published bundle and every file matches its hash; that the timeline, the summary and the tool definitions can be read; that the goal was reached and every input came from a tool call; that the game, its version and its mods are stated; that a model played it, which the hash of the runtime plugin shows; that its scan recognised nothing from the machine it was played on; and that the proof of when it was played holds. The result of each point is shown with the run.
• It reads every figure from the bundle (timeline.json totals, summary.json, manifest.json). The Archive calculates no numbers of its own. The only recalculation is done by the in-browser verifier, which exists precisely to check them.
• It scans every text file in a bundle for machine paths, e-mail addresses, credentials and tokens, and refuses a bundle with a finding without keeping it. A scan finds what it knows to look for; what it did not recognise is published with the run, which is why the runner reads the bundle first.
• Where the runner had the Archive confirm when the run was played, the Archive holds every hash it signed against the bundle, and makes the public log and timeline again from the runner's raw logs. Those logs are used for that alone and deleted as soon as the submission is decided.
• A recording is never part of a bundle. The submitter says where it is published, and the verification code in the recording's description, or in its title, is what binds the two: only the owner of a recording can write it there, so a link to someone else's video cannot carry it.

• Goal reached: the run's timeline carries the victory at its declared goal, and the summary names that moment.
• Goal not reached: the run ended before its goal, for example on a usage limit or a turn budget. It is kept as an attempt and is not ranked.
• Example: published to show what an entry looks like and how it can be checked, not as a submitted run.

Publishers submit runs from the submit page while signed in, or straight from the tooling with aas upload once aas login has signed it in. The Archive checks each submission again when it arrives, and a reviewer reviews it before the run is published. A submission is only refused for a technical reason: the file cannot be read as a bundle, it contains video or data from the submitter's machine, a script played it instead of a model, or its proof of when it was played does not hold.

Inspired by cozyblaze's Portal run. The tool interface and the log format follow his design, and the broker, the process hardening, the log sanitising and the privacy scan build on his code from portal-agent.

The code of this site is licensed under the GNU General Public License, version 3. Game names belong to their publishers.