GPT-6 Astra Portal Reality Check: 23h43m, 434.8M Tokens, Paused-Game MCP—and Why It Is Not a Benchmark

What actually happened

Developer cozyblaze published the code, configuration and a sanitized evidence export for a GPT-6 Astra run that reached the end credits of Valve's Portal on September 5, 2026 (PDT). The repository says the session began on September 4 at 5:00:35 PM PDT and reached the completion event on September 5 at 4:43:09 PM PDT. Its machine-readable summary reports 85,354 seconds to completion, or about 23 hours 42 minutes 34 seconds.

The exact model identity in the public summary is gpt-6-astra with max reasoning effort. The repository says the run later resumed after capacity interruptions and switched to Fast mode. After the initial gameplay goal, the creator says the only additional gameplay instruction was to leave the credits rolling.

Primary artifact:

• cozyblaze/portal-agent
• Evidence summary
• How the harness works

This is unusually useful launch-week evidence because it exposes code, configuration and a large sanitized session log. It is still one custom agent trajectory, not a controlled benchmark.

The model did not play through a normal human input channel

The biggest methodological detail is that Portal paused while Astra reasoned. The agent received a screenshot, exact player position and camera angles, selected an input plan, let the game advance for a bounded number of simulation ticks, then paused again to inspect the result.

The public harness documents three core Portal tools:

• portal_documentation, which describes the game-control API;
• portal_screenshot, which returns a full-resolution image;
• portal_exec, which can read state or execute a movement/action plan.

Automatic screenshots were reduced to 360 pixels high, while explicit screenshot calls could return full-resolution images. A single action plan could contain up to 1,000 steps and 6,600 ticks, around 99 seconds at the configured simulation rate.

The test also used sv_cheats 1, exposed player position through SourcePauseTool, raised acceleration and friction, and ran the game at roughly 67 simulation ticks per second. That does not mean the model was simply handed puzzle solutions. It does mean the evaluation surface differs materially from a person playing with only vision, mouse and keyboard, and from a generic screen-control benchmark.

The repository says web search and general shell/browser tools were disabled, which is an important control: Astra could not simply search the web for a walkthrough through those general tools. The relevant comparison is therefore Astra plus a purpose-built paused-game MCP harness, not "raw Astra sees pixels and plays exactly like a human."

434.8M reported tokens, with an unusually high cache share

The current public summary reports the last cumulative thread usage as:

• 433,210,793 input tokens
• 426,415,104 cached input tokens
• 1,598,341 output tokens
• 1,181,102 reasoning output tokens
• 434,809,134 total tokens

On the face of those fields, about 98.43% of reported input tokens were cached. Reasoning output represents about 73.90% of reported output tokens. Those ratios help explain why a headline of hundreds of millions of tokens does not translate directly into hundreds of millions of uncached-token charges.

OpenAI's current API page lists gpt-6-astra with a 1,050,000-token context window, 128,000 maximum output tokens, and standard rates of $10/M input, $1/M cached input and $50/M output. It also says requests above 272K input tokens receive a higher full-request price multiplier, and Fast processing is priced differently from standard processing.

A deliberately simple reconstruction using the public cumulative token totals and only the base short-context rates gives roughly $574.29. That is close to the widely reported $571.18 headline, but it is not an invoice reconstruction. The public export does not expose enough request-by-request billing data to know which calls crossed the long-context price threshold, how Fast-mode accounting was applied, whether subscription credits absorbed usage, or whether the final cumulative token snapshot exactly matches the creator's billing screen.

Tom's Hardware reports that cozyblaze said the run's headline usage was covered by a $200 Codex Pro subscription. Treat that as a creator-reported subscription outcome, not as evidence that another user can reproduce the same 24-hour run for $200.

Sources:

• OpenAI GPT-6 Astra API model page
• Tom's Hardware report, September 7

A 3,336-versus-3,306 tool-call discrepancy should stay visible

Several media reports describe 3,336 tool calls. The current public evidence/summary.json, however, enumerates the following tool_methods_in_exec counts:

The public summary therefore does not currently reconcile to 3,336 using the exposed method counts. There may be a different counting scope in the creator's original billing/run view, omitted tool categories, or a later export revision. Without a primary itemized total that explains the extra 30 calls, the safe reporting is: 3,306 tool calls are explicitly enumerated in the current public summary; 3,336 is a separately reported headline that remains unreconciled.

That distinction is small numerically but important methodologically. Agent benchmarks are especially sensitive to what counts as a turn, tool call, retry, environment action or hidden orchestration step.

The public log is substantial but intentionally incomplete

The evidence export retains 6,925 records from 26,460 source records. It says 19,535 records were omitted, 3,263 image occurrences were removed, and 21 identifiers were redacted. Host/system/developer context, reasoning payloads, opaque data, original identifiers and embedded screenshots are not distributed in the sanitized text log.

This is the right privacy posture for a public artifact, but it limits exact independent reproduction. A third party can inspect the controller, SourcePauseTool patch, configuration, sanitized messages/actions/results and summary statistics, yet cannot reconstruct every hidden model state or every original image from the published export alone.

The strongest next reproduction would pin:

1. the exact Codex/client build and gpt-6-astra endpoint behavior;
2. the Portal and SourcePauseTool versions;
3. the same configuration and initial goal;
4. a full run under a predeclared success rule;
5. at least several repeated attempts;
6. request-level token/cost accounting;
7. failure and retry counts;
8. a matched comparison against one or more alternative models under the identical harness.

Until then, this remains a compelling demonstration with unusually good artifacts, not a leaderboard-quality measurement.

Why "completed Portal in 24 hours" is true but easy to misinterpret

The completion time is a wall-clock duration, not continuous in-game play time. The game paused while the agent reasoned, and the repository explicitly says the elapsed period included capacity interruptions and waiting.

That makes the result valuable for long-horizon persistence: the system repeatedly inspected state, planned, executed, recovered and eventually reached the credits across nearly a day of real time. It does not support a claim that Astra played Portal at human realtime speed, nor should it be compared with a human speedrun clock.

A useful production analogy is an asynchronous software agent that pauses the environment while it plans. If the business process can wait, long deliberation can still be acceptable. If an application requires real-time embodied control, the paused-game harness leaves that requirement untested.

What the run says about Astra—and what it does not

The run is evidence that the Astra + Codex + custom MCP stack can sustain a long visual/spatial action loop and eventually solve a complete commercial puzzle game under this tailored interface. It also demonstrates effective context reuse: the reported cached-input share is extremely high.

It does not establish:

• a general "game-playing score" for GPT-6 Astra;
• a success probability across unseen games;
• a visual-only computer-use score;
• a fair speed comparison with people;
• a cost-per-success distribution;
• robustness to changed physics, camera interfaces or noisy observations;
• performance without exact position/camera telemetry;
• performance without paused reasoning;
• performance of another Astra effort level or another provider surface.

There is only one successful published trajectory here, so the effective sample size for end-to-end Portal completion is n=1.

Benchmark context: keep Portal separate from OSWorld, Terminal-Bench and coding-agent scores

OpenAI's launch page separately reports 72.6% on its OSWorld 2.0 setup for Astra, with roughly 40 minutes per task in its latency simulation. That is a vendor-published computer-use evaluation under a different environment and task set.

Artificial Analysis currently reports 59.1% on Terminal-Bench 4.0 for Astra max, independently running all 66 tasks three times and averaging pass@1. It also reports an Intelligence Index v4.3 score of 53 for Astra max. These are version-pinned standardized evaluations, not Portal scores.

Artificial Analysis's Coding Agent Index v1.4 is another separate model-plus-harness result. Its current Codex/Astra-max row reports a 67 composite, including DeepSWE, Terminal-Bench v2.1 and SWE-Atlas-QnA components. Because Codex orchestration is part of that evaluation, it should not be presented as a foundation-model-only score.

Sources:

• OpenAI GPT-6 Astra launch
• Artificial Analysis Intelligence Index v4.3
• Terminal-Bench 4.0 methodology/results
• Artificial Analysis Codex comparison

SWE-bench Verified and SWE-bench Pro remain separate gaps

The Portal run adds no evidence for SWE-bench Verified or SWE-bench Pro. They are repository-software-engineering evaluations with different tasks, environments and harnesses.

In the current primary OpenAI Astra material reviewed for this article, no exact Astra SWE-bench Verified score was accepted, and no version-pinned exact SWE-bench Pro score with sufficient current methodology was accepted. DeepSWE, Terminal-Bench, SWE-Atlas-QnA, FrontierCode and a Portal playthrough cannot be relabeled as either SWE-bench variant.

That cell should remain not established in this review rather than being filled from an unrelated score.

Public feedback: excitement and methodology skepticism coexist

The creator's dated X post on September 5, 2026 says Astra had autonomously completed Portal and links the result back to OpenAI's older ambition to build a single agent capable of solving many games. The actual post is:

• cozyblaze on X, September 5, 2026

That is primary launch provenance for the experiment, not an independent benchmark review.

An accessible September 8 Reddit discussion in r/KI_Welt shows the other side of the reaction. Some commenters were impressed, while others immediately asked how much the custom MCP/cheat-enabled interface mattered, questioned the cost, or contrasted the setup with ordinary desktop computer control:

• r/KI_Welt discussion, September 8, 2026

Those comments are self-selected anecdotes. They are useful because they identify the right reproducibility questions—interface privilege, game pausing, cost and ordinary-screen-control transfer—but they are not a representative poll and should not be described as community consensus.

Practical verdict

This Portal run is stronger evidence than a short edited demo because it has a public controller, patched game interface, configuration, a 6,925-record sanitized export and machine-readable statistics. It shows that a frontier general-purpose model can sustain a difficult, long-running visual-action loop when given a carefully engineered tool surface.

The methodological caveats are equally important. The environment pauses during reasoning, exposes exact position and camera telemetry, uses modified physics/debug settings, has only one published successful trajectory, and the public export omits substantial private/opaque state. Current media tool-call and billing headlines also do not perfectly reconcile with the exposed summary.

So the defensible conclusion is narrower than "Astra can play games like a human": GPT-6 Astra, at max reasoning inside Codex and a custom paused-game MCP harness, completed this Portal run in about 23h43m. The result is a useful real-world agent demonstration, not a standardized benchmark.

For a reproducible comparison, the next step is a fixed multi-game suite with identical interfaces, repeated seeds, declared retry limits, full request-level accounting, matched models and separate reporting of wall-clock time, simulated game time, tokens, tool calls, cost and completion rate.