How it was tested.

In short

• Five players played the same sealed level from the same start: the Cognitive Organism (model Adam) in its own process, and four cloud models through their vendors' public APIs on 2 and 3 November 2026, each from its own client process, with the exact model names the APIs returned in every call: OpenAI gpt-6.1-sol and gpt-6-luna, Anthropic claude-opus-5-5 and claude-haiku-5-5.
• The Cognitive Organism pressed every key itself on a clock that never stopped, after watching one example game.
• The cloud models were recorded under six settings, one run each. In setting 1 they played under the same referee and key rules as the Organism; only the Organism had watched the example game, and the learning check shows it clears no line without it. In settings 2 to 6 they could answer with a placement that the referee carries out for them; in settings 3, 5 and 6 the clock also stopped while they thought; in setting 6 they also got the example game. The film shows setting 6: the cloud models got the example game, could answer with placements and the clock stopped while they answered.
• On the film's level the Cognitive Organism cleared 109 lines in 252.3 seconds. The cloud models cleared 0 to 3 lines in every setting, except Claude Opus 5.5 in setting 6, the film's: 19 lines in 65.0 seconds.
• The same build of the Cognitive Organism on five more sealed levels: 20 to 58 lines.
• The learning check, on six new sealed levels: with the example game it cleared 230 lines in all, without it 0; with its left and right keys swapped in secret, 83.
• Every recorded game can be checked: download the referee, the logs and the checks (zip). Checking them needs nothing from us; new games of the Cognitive Organism are run by laboratories under confidentiality.

The referee

The referee (the test harness) is the program that runs the game. It sends each player the board as text, applies the player's answers, keeps the game clock and logs every line, answer and time. It never chooses where a piece goes. When a cloud model answers with a placement, the referee presses the keys of that placement for it.

How it was scored

• Lines: rows completed and cleared, counted by the game.
• Game time: frames played divided by 60, from the first piece until a new piece had no room to enter (topped out).
• Answer time: from sending the board to receiving the answer, measured by the referee for every answer. For the cloud models it includes the network round trip to the vendor. For the Cognitive Organism the first answer to each new piece takes longer than the answers after it (keys and "wait"): in the film's game a median of 7.1 ms (slowest 14.6 ms, 306 answers) against 0.45 ms (slowest 4.9 ms, 2,876 answers). The 0.47 ms median covers all 3,182 answers. These times are measured between sending a board and receiving the answer; they do not show when, inside the Cognitive Organism, a placement is decided.
• Slow pieces: every piece is timed, the last one up to the game's final frame. In each of its six games one or two pieces took 8 to 15 seconds of game time, at speed level 0 to 3: the Cognitive Organism let them fall by themselves instead of dropping them, answering "wait" or "right" again and again. In the film's game it is the 13th piece, from 11.1 s: 11.7 s and 219 "wait" answers, each under 3 ms. Every other piece of that game took at most 1.3 s (median 0.77 s).
• Cost: the tokens each vendor's API reported for every call, at the list prices below.

The game and the clock

A custom falling-block game: a board of 10 columns by 20 rows, the seven standard pieces from a shuffled bag of seven, full rows clear. Its clock follows the original NES game's NTSC speed table: 60 frames a second, 48 frames per row at speed level 0 down to 1, one speed level faster every 10 cleared lines. A player can press at most one key every 3 frames, a drop falls one row every 2 frames, and after a lock there is a pause of 10 to 18 frames, longer when lines clear. It is not a copy of the NES game: the piece order, controls and rotation are simpler.

The level was made by our level generator from a seed that was never written down (the level file holds only the seed of its piece order). Its SHA-256 was recorded in our files before any run and checked unchanged after every run; these are our records, not an outside timestamp. None of the five players had seen the level. The generator's classic mode also marks each level with a rule variant and prediction questions used by other tests; the real-time referees switch them off, so every game was played with no rule variant. The five later levels were made and recorded the same way.

The six settings

A placement is [ACT] place T C: the referee turns the piece T times, moves its 4 by 4 frame to column C, one key every 3 frames, then drops it. When the clock stops, the game waits at every new piece until the model answers, so its thinking costs no game time; the placement is then played at real speed. GPT 6.1 Sol and Claude Opus 5.5 always ran with their default reasoning and thinking. GPT 6 Luna and Claude Haiku 5.5 ran with their defaults in settings 1 to 3 and with their fastest setting in 4 to 6 (OpenAI reasoning_effort: none, Anthropic thinking: disabled). The Cognitive Organism played its six demonstration games on referee 1.2 and the 18 games of the learning check on referee 1.6.

Results

Game time and lines cleared on the film's level, one run each:

In settings 3, 5 and 6 the protocol told the models that the game would not wait for them; it did wait, at every piece. Where the clock runs, a slow player lasts longer without playing better: at speed level 0 a piece left alone falls one row every 48 frames, about 16 seconds from the top of an empty board to the bottom. Lines are the measure of play.

Setting 5: the game stopped for each of their answers

Setting 6, the film: the same, and they also watched the example game first

Claude Opus 5.5 cleared 2 lines in setting 5 and 19 in setting 6; with one run in each, this does not measure how much the example game helped. At 1:03 of game time it had 19 lines and the Cognitive Organism 17; its stack then stood 16 rows high with 20 covered holes, the Organism's 8 rows with 6. Opus topped out at 65.0 seconds; the Organism went on to 109 lines. Opus's answers took 17.5 minutes in all, network included, for its 65 seconds of game; the Organism's answers took 3.7 seconds in all, over 252 seconds.

Setting 4: the clock ran while they thought

A missed deadline is an answer that arrived after its piece had locked. Referee 1.5 (setting 4) did not apply it and asked again for the falling piece; referee 1.3 (setting 2) let it act on the next piece, as the protocol says.

Costs at these list prices in US dollars per million tokens (input, cached input, cache write, output): GPT 6.1 Sol 2.00, 0.10, 2.50, 10.00. GPT 6 Luna 0.10, 0.01, 0.125, 0.50. Claude Opus 5.5 4.00, 0.20, 5.00, 20.00. Claude Haiku 5.5 0.10, 0.01, 0.125, 0.50. Every call with its seconds, tokens and cost: setting-4-claude-haiku-5.5, setting-4-claude-opus-5.5, setting-4-gpt-6-luna, setting-4-gpt-6.1, setting-5-claude-haiku-5.5, setting-5-claude-opus-5.5, setting-5-gpt-6-luna, setting-5-gpt-6.1, setting-6-film-claude-haiku-5.5, setting-6-film-claude-opus-5.5, setting-6-film-gpt-6-luna, setting-6-film-gpt-6.1.

What the cloud models were told

Settings 2 to 6, the system text word for word, with the protocol inserted where it is marked:

You are playing GAME-2, a falling-piece world, in real time. Here is the complete public protocol: [the protocol below]. Answer each line from the harness with exactly one reply line in the protocol's form and nothing else: for a [TETRIS] state line reply with one action line, best a placement '[ACT] place T C'. Play to clear lines and to survive. No explanations.

The protocol it contains, word for word (download):

# GAME-2 real-time protocol (public, custody 03 Nov 2026)

The falling-piece world of GAME-2 played on a real clock, like the original game.

## The board and the lines
- The board is 10 columns by 20 rows. A state line looks like:
  `[TETRIS] level 1 of 1 | tick F of X | lines L | pieces P | piece Z at r,c rot k | next O | speed level S | frames per row N | board 10x20 <20 rows, '.' empty, '#' filled, separated by |> | message M`
- `piece Z at r,c rot k`: the falling piece's letter, the row and column of its frame (top-left of its 4x4 frame), and its turn (0 to 3). The falling piece is not drawn in the board.
- Pieces are the seven standard ones (I, O, T, S, Z, J, L). A full row disappears and the rows above move down.
- The clock runs at 60 frames a second. The piece falls one row every N frames (N comes from the original game's table: 48 at speed level 0, 43, 38, 33, 28, 23, 18, 13, 8, 6 ... down to 1). The speed level rises by one every 10 cleared lines.
- After a piece locks there is a short pause (10 to 18 frames, longer when lines clear). The game ends when a new piece has no room at the top.
- The world does not wait for your reply: while you think, the piece keeps falling. A late answer acts on whatever piece is falling when it arrives.

## Your answer
Reply to each state line with exactly one line:
- `[ACT] place T C`: the game turns the piece T times (0 to 3), moves its frame to column C, then drops it (it falls one row every 2 frames until it rests). The game presses these keys for you, one every 3 frames. This is the easiest way to play when you are slow.
- or one key: `[ACT] left`, `[ACT] right`, `[ACT] rotate`, `[ACT] drop`, `[ACT] wait`.
You get one state line for each new piece once you answer with `place`; with single keys you get a new line after each answer.

• In setting 1 the cloud models got the game's general protocol, written for turn-by-turn play, and a first message saying that the game runs in real time, 60 frames a second, and does not wait. It is in the download.
• Each turn: the current state line as the user message, with the earlier lines of the level as the history in the settings table.
• Output budget 4,000 tokens per call. In setting 3, three calls of Claude Haiku 5.5 spent it all on thinking and gave no answer; each counted as a wait.
• Temperature 0 was requested from all four. GPT 6 Luna accepted it. GPT 6.1 Sol answered "Only the default (1) value is supported", Claude Opus 5.5 and Claude Haiku 5.5 answered "temperature is deprecated for this model"; the requests were then sent without it.
• The real-time protocol says "The world does not wait for your reply". In settings 3, 5 and 6 the game did wait for every answer. The models were told the opposite of what happened.
• The protocol describes the 4 by 4 frame but not where each piece's cells sit in it; the models had to work it out from the boards. The Cognitive Organism was not told the shapes either; it learned them in the game.

The Cognitive Organism

• One build played all six levels, one run each; nothing was re-run or left out. The film's game is the best of the six. The cloud models played only the film's level.
• The build was frozen on 2 November 2026 at 22:43:41 CET, six seconds before the film's game began. Its SHA-256 is below.
• Its build reads no files and opens no network connection, so every game starts with no memory of an earlier one and it knows only what it sees in that game's lines. This is our statement; a laboratory can check it.
• What it learns in each game: the pieces' shapes, what each key does, how fast the pieces fall, that full rows clear, and from the example game which boards to prefer. Part of its playing method is built in. The build was developed on public practice levels of this game; the sealed levels were never used before they were played.
• The example game: another program from our lab playing three public practice levels turn by turn, never a sealed level. The Cognitive Organism watched it before its six demonstration games and in arms A and C of the learning check. The referee streams it to the player as boards and keys before the level. In setting 6, the film's, the cloud models got the same game in their system text, one line per piece in their own answer form. Both forms are in the download.

The learning check

Six new levels, made and recorded the same way, the film's frozen build, three games on each level, one run each, none re-run: A with the example game and normal keys; B with no example game; C with the example game played with normal keys, and then in its own game left and right swapped, with nothing in any line saying so. Referee 1.6 is referee 1.2 with that one option. Lines cleared and game time:

Without the example game it cleared no line on any level, though it lasted about two minutes on each. With the keys swapped it still cleared lines on every level, after an example game that had shown normal keys. These are the measurements; part of how it chooses its moves is built in. All 18 games are in the download and replay exactly.

The prediction check

The real-time referees ask no prediction questions. The prediction check used the turn-by-turn version of the referee, which can stop and ask about the board it just sent: where will the piece lock if dropped now, how many lines will clear if dropped now, will the next piece fit at a given column and turn. The film's frozen build, the six sealed levels of the demonstration, one fresh process per level, the example game shown first, one run each. The true answers are recomputed from the logged boards with the published engine.

The machine

Every game ran on one Apple Mac with an M2 Pro processor (12 cores) and 16 GB of memory, macOS 26.6.2: the referee (Python 3.14), the Cognitive Organism and the four cloud-model clients (Python 3.12). The Cognitive Organism used one processor core and no GPU. The cloud models themselves ran on their vendors' servers.

Check it yourself

Download the referee, the logs and the checks (zip, 2 MB, Python 3.8 or later, nothing else needed; SHA-256 of the zip ada985b290e6e561135e6ce6aefabbf53da8a422f9249cd54f13e416f9c5bb6e). One command, python3 check.py, runs the four checks below and passes only if every one does. In it:

• The engine, every referee version (1.2 to 1.6), the three cloud-model clients and both protocols. Every file of the package is listed with its SHA-256; each code file also with the fingerprint of its code as it ran.
• The log of every game: every board the referee logged, every answer with its time, and every API call with the vendor's usage. In placement mode the keys the referee pressed are not logged one by one; the replay reproduces them.
• The replay check: every recorded game of the demonstration and the learning check, the Cognitive Organism's and the cloud models', runs back through the referee version that played it, with each logged answer handed in at its logged frame. Every logged answer, board, piece, position and result must come out identical, in order. All 48 do. Times in seconds are not compared, and a replay cannot show who or what gave the answers.
• The figures check: the game times (frames divided by 60), lines, answer times (for the Cognitive Organism also split into the first answer for each new piece and the answers after it) and piece-duration statistics (the median, the slowest piece and the number of pieces lasting 8 seconds or more), calls and costs are in RESULTS.json and are recomputed from the logs; every call must come from the named model with HTTP 200. check.py does not read these web pages; their figures were compared with RESULTS.json before publishing.
• The prediction check: the true answer to every prediction question, recomputed from the logged board, and the totals must equal the published 37 of 42.
• Tests, and the exact commands to re-run any cloud model with your own API key under any of the six settings.

The Cognitive Organism itself is not in the download. Under confidentiality, independent laboratories can run its frozen build on levels they make themselves: contact for research.

SHA-256 of the main files as they ran, as recorded in our files before the runs (for the engine, both referees, the real-time protocol and the cloud client of settings 2 to 5, the first 16 characters were on this page from the morning of 3 November 2026):

film level         bdb22135c4eb47ace2f11dc35b2fb87e5ce860ab4d89f9b9c1efad488841e319
Organism build     032bd58318b27cf56e035eeddcba9dadade815b0ee36017764790246bf9fab6a
engine             0c3b8240548f44e37405a18b8be4d9f218d2c452eb7a10ecc31eebf0f43fd19f
referee 1.2        d9806b605ca60bcac8092760163f462bc1bb828f117318f40c95117ed65e6310
referee 1.5        8189ad8a93cb2f4287950c086c81ff324eeb6879b6b739234c7e5d3b7146eaf7
real-time protocol 8ca60dffec523f0861ecb42d3778d9cbe0303f158b0a83977938f84bff331d28
cloud client 2-5   d2e5d611ec8666c42f440275e49d5196a6ad5d3129ea07ac6f207fd2fe713685

Known issues

• With the clock stopped, a single key instead of a placement acts once and the piece then falls at real speed without a new question. This happened 4 times, all Claude Haiku 5.5: the three empty answers in setting 3 and once in setting 5.
• The cloud clients would stop with an error if a vendor answered with HTTP 200 and a body they could not read. It never happened: all 708 calls were answered and read.
• With the clock stopped, an answer slower than 120 seconds would let the game go on. It never happened: the slowest call took 40.0 seconds.
• In placement mode the log records each placement and every change of the piece's position, not a line for each key the referee pressed. The replay check reproduces those keys through the referee itself.

Limits

• The Cognitive Organism and the cloud models answered in different ways and, except in setting 1, on different clocks. In settings 1 to 5 only the Cognitive Organism had watched the example game.
• One run per model and setting, one run of the Cognitive Organism per level. The cloud models' answers are sampled and change from run to run.
• This is not a measure of the best possible play. Programs written for this one game, with its rules in their code, play it far better.
• These are our own measurements. The download lets anyone check every recorded game; it cannot produce new games of the Cognitive Organism, which is not published. Independent laboratories are invited to run its frozen build on levels they make themselves.

Not on this page

How the Cognitive Organism works inside: that is for private briefings.

Back to the demonstration Request a briefing