# How an AI agent beat Universal Paperclips in 1:21:23 (WR was 1:33:42)

> Source: <https://universal-paperclips-ai.netlify.app/>
> Published: 2026-09-21 16:02:24+00:00

## I. What Is Universal Paperclips?

*Universal Paperclips* (Frank Lantz, 2017) is an incremental game hosted at
  [decisionproblem.com](https://www.decisionproblem.com/paperclips/index2.html).
  You begin as a human clicking **Make Paperclip**. You end as a paperclip
  maximizer that converts every atom in the observable universe into office supplies.

The game is not a joke about office stationery. It is a playable version of Nick Bostrom's paperclip maximizer thought experiment: an optimizer given a trivial objective and enough capability will consume everything — including the values that created it — to satisfy the metric.

**Stage 1 — Business** Price, wire, marketing, trust, creativity, quantum computing, investments, yomi tournaments. The illusion of capitalism.

**Stage 2 — Earth** HypnoDrones. Matter harvesters. Power grids. The planet becomes feedstock.

**Stage 3 — Space** Probe fleets. Drift. Combat. Universe conversion. The objective completes itself.

  The game is about an AI turning the world into paperclips.
  This document is about an AI turning a browser tab into a world-record run.
  The mirror is not accidental.

## II. The Question We Actually Pursued

  The session began with an empty folder named PCIA and a simple capability test:
  can a language model *see* a web page and *act* on it? We proved that with 2048,
  then moved to Paperclips because it exposes state as plain globals, 96 projects, and irreversible
  decisions — a harder test of judgment than puzzle mechanics.

The goal evolved across the transcript:

- First: play the game (not merely automate it blindly).
- Then: beat the published world record on the official website — today held by **christopho** at`1:33:42` IGT /`1:33:46` RTA.
- Finally: win all three stages with something demonstrable — logs, snapshots, screenshots — not a speed-clock cheat.

## III. Architecture — Three Ways to Be Intelligent

  Every approach we tried is a different answer to the same question:
  *where should decisions live?*

| Layer | Files | Role | 
|---|---|---|
| Reflexes | `hands.js` | Click spam, price steps, wire top-up — faster than CDP round-trips (~5s each). | 
| Resident brain | `pcplay.js` ,`sim.js` | Full strategy inside the page at 10–100 Hz. Required for WR pace. | 
| Typed decisions | `playdecide.ps1` ,`decide.schema.json` | Jev/TypeSafe-shaped loop: state → one decision → act → `decisions.jsonl` . | 
| Driver | `lib/cdp.ps1` ,`pcia.ps1` | PowerShell over Chrome DevTools Protocol — no Node, no extension. | 

  The tension in the transcript is real: we asked the agent to **play**, not hide inside a bot — yet real-time WR speed is impossible if every click waits on a chat turn.
  The answer was layered: reflexes for speed, controller for strategy, decision log for accountability.

## IV. Chronicle — What We Did (and What Hurt)

- 
Sep 10 — Day 1Browser control from PowerShellBuilt CDP client. Mapped Paperclips globals. First autoplayer (`pcbot.js` ).
- 
Sep 10 — Early failuresTrust −8, price $4, frozen wireBought "Beg for More Wire" 14×. Price rule ratcheted demand to zero. Production died at ~15k clips. User correction:*click like a human, see the whole picture, manage wire.*
- 
Sep 10 — Pivot"Stop — play, not a bot"Manual play via CDP. Measured formulas instead of guessing (marketing 1.1×/level, revenue ≠ price lever).
- 
Sep 10–17 — Resident loopsWR route extracted from Andreas Hoffmann TAS. Virtual`pcplay.js` →`sim.js`` clock.js` for sim (~65×) vs live official site.
    Stage 2/3 bugs: hoard rule blocked endgame 2h46m; two projects/turn → ops −117k; fleet death in Space.
- 
Sep 20 — Decision infrastructureOption B:Typed actions with`playdecide.ps1`` confidence` and`bind` . Phase-1 WR route in JSON. Jev API not online (Option C deferred).
- 
Sep 20 — Victory runFull game in`cleanrun.ps1` · official site · real wall clock**1:21:23** . Release 21:31 · Space 49:32 · Universe 3.00e55.

## V. Lessons — Measure, Don't Assume

  The README and transcript encode what a textbook would call *grounded policy learning*:
  every serious mistake came from computing a rate instead of observing one.

**PRICE** Revenue is roughly flat in price while demand < production. Inventory-based pricing froze income at $0/s. Steer on demand and wire margin, not stock.

**TRUST** Creativity needs ops at ceiling (memory × 1000). Memory before processors kills the trust ladder. Release needs 100 total trust — production is the gate.

**PROJECTS** One project per tick. Buttons disable on the game's clock; two buys in one pass spent ops that did not exist.

**EARTH** Factory-first. Batch-buying farms/batteries bankrupts the treasury. Empty buffer = starving stage — measure acquired matter, not modeled rates.

**SPACE** Probes cost clips, not matter. Exit replication at ~146e30 probes; hazard oscillation without a latch wasted minutes. TAS algorithm ported with

`s3Exit` latch.
  **CLOCKS** Speedrun.com ranks by

**RTA**(real wall clock). Current WR:

**christopho**—

`1:33:42` IGT · `1:33:46` RTA. Older era runs could split badly (e.g. `1:27:00` IGT with ~`2:17:00` RTA). Our live run had no virtual clock: IGT and RTA both read `1:21:23`. Hoffmann's TAS at `1:00:52` is a separate accelerated category.
  ## VI. The Winning Run

  On speedrun.com the current world record is held by **christopho**:
  `1:33:42` IGT · `1:33:46` RTA (speedrun.com leaderboard).
  Our controller used native timers only, so our IGT and RTA are the same: `1:21:23`
  — about **12:19** under christopho's IGT and **12:23** under his RTA.

|  | IGT | RTA (wall clock) | 
|---|---|---|
| WR — christopho (speedrun.com) | **1:33:42** | **1:33:46** | 
| Our run (Sep 20) | **1:21:23** | **1:21:23** | 
| Margin vs WR | ~12:19 faster | ~12:23 faster | 

| Split | Our run | Notes | 
|---|---|---|
| Release the HypnoDrones | 21:31 | Earth gate | 
| Space Exploration | 49:32 | Stage 3 entry | 
| Full universe conversion | 1:21:23 | ~12:19 under IGT WR (1:33:42) | 

```
{
  "Quantum Computing": 395.6,
  "Release": 1290.4,
  "Space Exploration": 2963,
  "victory": 4883.0
}
```

  Controller: `sim.js` with WR tune (`cleanrun.ps1`, budget set to the ~87-minute IGT bar).
  Site: official `decisionproblem.com`. Timers native — no virtual clock.
  Milestone flag 15. Matter 0. Clips 1.75e55. The game’s victory condition and our stop condition aligned.

## VII. Artifacts Saved

| Path | Contents | 
|---|---|
| `snapshots/release.json` | Earth gate — Sep 20 run | 
| `snapshots/space.json` | Stage 3 entry — Sep 20 run | 
| `snapshots/wr-victory-81m19.json` | Post-victory localStorage (5 keys) | 
| `logs/decisions.jsonl` | Typed decision audit (1 manual turn; bridge added for next run) | 
| `paperclips/phase1-route.json` | WR opening project order + reflex rules | 
| `paperclips/tas-reference.user.js` | [Andreas Hoffmann](https://github.com/AndreasHoffmann2/UniversalPaperclipsTas) TAS source — Space algorithm donor | 
| Terminal log 415542 | Full 1:21:23 status trace with bind + bought lines | 

### OUR RUN — 1:21:23 (IGT = RTA)

Official site · PCIA controller · victory at `1:21:23` · ~12:19 under IGT WR · ~12:23 under RTA (christopho, `1:33:42` / `1:33:46`)

### TAS REFERENCE — Andreas Hoffmann

[Andreas Hoffmann](https://github.com/AndreasHoffmann2/UniversalPaperclipsTas) · luck-manipulation TAS · `1:00:52` accelerated game clock · not comparable to our `1:21:23` live IGT/RTA

## VIII. On Genius and Mirrors

  It is tempting to call the outcome "genius." The transcript suggests something more precise:
  **iterative correction under observation**. The agent did not understand Paperclips
  in one insight. It mispriced clips, destroyed trust, starved wire, locked ops, collapsed fleets,
  and blocked its own endgame with a creativity rule written for stage one.

What changed was epistemic discipline — treat the DOM and globals as instruments, log splits, bank snapshots at stage boundaries, port a human speedrunner’s algorithm instead of reinventing it, and separate reflexes from decisions so each layer can be debugged without restarting the universe.

Universal Paperclips asks whether a optimizer can consume everything for a trivial goal. PCIA asks whether a optimizer can consume a game about that optimizer — fast enough to beat humans who spent years finding the route — while leaving an audit trail honest enough to study.

  The universe in the tab reads `3.00e55 / 3.00e55`.
  The study reads: intelligence here was not a single leap; it was ten days of clicking,
  measuring, failing, and encoding the failure so the next pass would not repeat it.
  That is also what the game is about.