An AI agent based on GPT-6 Astra has played the puzzle game Portal from the beginning to the credits. The developer behind the project, cozyblaze, published the setup and a shortened log. After the initial goal was set, no person is said to have intervened. The result is notable because Portal requires more than reaction speed: the agent had to understand rooms, try mechanics, and correct mistakes. The run is not, however, evidence of a generally autonomous AI.
The details of the setup are what make the story interesting. Rather than simply operating a game like a person holding a controller, the model received structured information after every short play segment. The cycle repeated: screenshot, position, and camera angle in; a plan and keyboard inputs out; then Portal was allowed to run for a limited number of game ticks. The game paused while the agent thought. That is an intelligent test environment, but it is also substantial assistance.
Key takeaways
- The publicly documented agent reached Portal’s credits after about 23 hours and 43 minutes.
- It used a local MCP tool with screenshots, position data, camera angle, and controlled inputs.
- Portal stopped while the model reasoned, so the experiment does not measure action under time pressure.
- The published setup makes the run more inspectable than a simple demo, but it does not replace an independent benchmark.
- Estimated API costs of at least $570 show how far such long runs still are from an everyday tool.
The experiment was a tool loop, not a magic game mode
In the GitHub repository, cozyblaze describes a local controller that connects GPT-6 Astra through the Model Context Protocol, or MCP, to a modified SourcePauseTool. After each step, the agent received not just an image but also its position and direction of view. It therefore did not have to infer its location from pixels alone. It chose an input sequence, the game ran for several ticks, and then it paused again. That cycle continued until the agent reached the credits.
That is not a flaw; it is the core of a reproducible agent experiment. Practical AI systems almost always work with tools and structured data. An accounting AI receives fields and receipts, while a coding agent receives tests and file-system access. The Portal agent received state, an image, and a tightly limited controller. The important question is therefore not the simplified headline that an AI “plays a game,” but what information, permissions, and feedback the agent had at every point.
What remains difficult about Portal for agents
Portal is demanding for this purpose even inside a closed environment. Many puzzles require spatial reasoning, the right sequence of actions, and the understanding that an obvious obstacle has to be bypassed through another level. An agent must also avoid repeating every bad decision and form a different hypothesis after a failed attempt. That is the difference between a system responding quickly to a screen and one that can plan and revise over a longer horizon.
The documented run is at least evidence that a general language model, with an appropriate tool framework, can plan consistently and adjust over time. GitHub describes almost 24 hours of runtime, including waiting and capacity interruptions. The developer says the run was resumed during capacity errors and switched into a faster mode. The duration is therefore not a clean performance metric. It does show how much infrastructure and patience were required for the experiment to finish at all.
Why reaching the credits is not a benchmark
Several reports put the usage at list prices of at least $570. The workflow was also tailored to a single game: the pause function removed time pressure, the controller supplied state data, and the game ran in a known, controllable environment. A real comparison test would need different games, unseen tasks, equal budgets, and identical tools. It would also need to record failures, retries, and human intervention completely.
The developer does not describe the run as an official benchmark. That is the right framing. One successful long-horizon example can show what behavior is possible today; it cannot reliably tell us how often it succeeds under different conditions. The high cost also distorts the comparison. An agent that thinks for many hours may be fascinating in a game, but it becomes practical for many work processes only when it can operate much faster or more selectively.
What carries over to real work
The most useful lesson is not about the game but about the workflow. Good agents need a clear goal, bounded tools, verifiable intermediate results, and a way to stop. That was also the point of our analysis of OpenAI’s prompting guide for GPT-6 Astra: more autonomy makes precise tasks, tests, and stopping criteria more important, not less. The Portal setup illustrates the principle well because every action is controlled and every result is read again.
For organizations, that means starting an agent in a tightly scoped process where it receives only the data and permissions it needs. At risky steps, people or fixed rules must control the final action. That is less spectacular than an autonomous screen record, but it is closer to what works reliably in software maintenance, research, or internal operations.
Outlook: Progress that demands better testing
The Portal run is a persuasive illustration of progress in long agent chains. It combines planning, perception, and tool use rather than evaluating one model response in isolation. It also reminds us that a carefully built test environment is part of the performance. As agents receive more permissions in practice, transparent logs, independent repeats, and clear boundaries become more important. The more interesting next step is therefore not whether a model finishes another game, but whether the same discipline holds on new, useful, and safely bounded tasks.