GPT-6 Astra Beats Portal: When a General-Purpose Agent Conquers a 3D World for the First Time

1. Introduction: An Unbelievable Night

Late on September 5, 2026, AI enthusiast CozyBlaze posted a stunning announcement on X — GPT-6 Astra had autonomously completed Valve’s classic 3D puzzle game Portal from start to finish, from the first test chamber to the final confrontation with GLaDOS, without any human intervention or reliance on pre-existing walkthroughs or scripted assistance.

The entire experiment took roughly 24 hours, involved 3,336 tool calls, and carried an API cost of $571.18 — though the actual expense was covered by CozyBlaze’s $200/month Codex Pro subscription. The edited highlight reel was compressed to about 2 hours, removing the model’s lengthy thinking pauses.

Not long ago, AI was still losing at Atari 2600 chess. Today, a general-purpose language model, relying only on screenshots and coordinate data, can autonomously navigate and control a complete 3D physics-engine world, traversing dozens of meticulously designed puzzle chambers. This is not just evidence of technological progress — it is a compelling demonstration of multimodal AI intelligence.

2. Technical Details: How MCP + SPT Let the AI “See” and “Control” the Game

2.1 Core Architecture Overview

GPT-6 Astra did not sit in front of a monitor holding a controller. Instead, it operated through a carefully engineered toolchain:

+------------------+       +------------------+       +------------------+
|   GPT-6 Astra    |       |   MCP Protocol   |       |  SourcePauseTool |
|  (Reasoning Eng) | <---> | (Model Context   ) | <---> |  (Pause/Control) |
+------------------+       +------------------+       +------------------+
        |                                                    |
        |  Inputs:                                           |  Outputs:
        |  - Game screenshots (360p)                         |  - Keyboard input sequences
        |  - Player coordinates (x,y,z)                      |  - Mouse movement/clicks
        |  - Camera angles (yaw/pitch/roll)                  |  - View rotation
        |  - Context management (cross-window notes)         |  - Game pause/resume
        |                                                    |
        v                                                    v
+---------------------------------------------------------------+
|                    Portal (Source Engine)                       |
|  Physics Simulation | Rendering | Collision Detection | Logic  |
+---------------------------------------------------------------+

2.2 MCP (Model Context Protocol)

MCP served as the bridge between GPT-6 Astra and the game world. Through this protocol, the model could:

• Request game state snapshots (screenshots + coordinates)
• Send operation instructions (movement, jumping, portal shooting)
• Receive execution result feedback

class MCPGameClient:
    """MCP protocol communication client for Portal control"""
    
    def __init__(self, game_process, spt):
        self.game = game_process
        self.spt = spt
        self.context_window = []
        self.max_context = 258_400  # Astra's context window capacity
        
    def capture_state(self):
        """Capture current game state"""
        self.game.pause()
        screenshot = self.game.capture_screenshot(resolution="360p")
        position = self.game.get_player_position()
        camera = self.game.get_camera_angle()
        return {
            "screenshot": screenshot,
            "position": position,  # (x, y, z)
            "camera": camera,      # (yaw, pitch, roll)
            "timestamp": time.time()
        }
    
    def send_actions(self, actions: list):
        """Send precomputed action sequence"""
        self.spt.unpause()
        for action in actions:
            self.game.execute(action)
            time.sleep(action.duration)
        self.spt.pause()
        
    def think_and_act(self):
        """Model reasoning-to-execution cycle"""
        state = self.capture_state()
        # Model pauses here, reasoning from screenshot + coordinates
        decision = self.model.reason(state)
        # Execute the decision
        self.send_actions(decision.actions)
        # Update context
        self.context_window.append(decision.summary)

2.3 SourcePauseTool (SPT) and the Pause Mechanism

SourcePauseTool is a modification tool designed for Source engine games. CozyBlaze modified it to:

1. Pause the game: Freeze all physics and logic updates while the model thinks
2. Execute inputs: After the model outputs a sequence of predefined inputs, SPT unpauses and executes them
3. Return control: Re-pause after execution, waiting for the next reasoning cycle

Timeline: Model Reasoning → Game Paused → Execute Actions → Re-pause → Model Reasoning
            |__________|                         |__________|
              Think Cycle                          Think Cycle

Step 1: Model receives screenshot + coordinates
Step 2: Model analyzes scene (paused)
Step 3: Model plans action sequence (paused)
Step 4: SPT unpauses
Step 5: Engine executes input sequence
Step 6: SPT re-pauses
Step 7: Return to Step 1

This mechanism solves a fundamental problem: the disconnect between LLM reasoning speed and real-time game physics. A human player processes visual information and makes decisions in milliseconds, while LLM reasoning cycles typically take seconds or tens of seconds. Without pausing, the model would miss all critical in-game events while thinking.

// Core SPT control logic (simplified)
package spt

import (
    "fmt"
    "time"
)

type SPTController struct {
    engine    *SourceEngine
    isPaused  bool
    thinkTime time.Duration
}

func (s *SPTController) Cycle(modelInput chan GameState, modelOutput chan ActionSequence) {
    for {
        // 1. Pause the game
        s.engine.Pause()
        s.isPaused = true
        
        // 2. Capture current state
        state := GameState{
            Screenshot: s.engine.CaptureScreen(360),
            Position:   s.engine.GetPlayerPos(),
            Camera:     s.engine.GetCameraAngles(),
        }
        
        // 3. Send to model for reasoning
        modelInput <- state
        
        // 4. Wait for model's decision
        actions := <-modelOutput
        
        // 5. Unpause and execute actions
        s.isPaused = false
        s.engine.Unpause()
        for _, action := range actions {
            s.engine.Execute(action)
        }
        
        // 6. Log execution summary
        fmt.Printf("Cycle complete: %d actions in %v\n",
            len(actions), time.Since(s.thinkTime))
    }
}

2.4 Input/Output Pipeline Details

Input Layer (information the model receives):

Output Layer (instructions the model issues):

3. Economic Cost Analysis: 3,336 Calls and $571

3.1 Token Consumption Breakdown

CozyBlaze published the complete experiment statistics on GitHub:

3.2 Cost Structure Analysis

Cost Structure (ASCII)
═══════════════════════════════════════════════════════════════════

  Input Token Cost (approx. 86%)                                 
  ████████████████████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░  
  430.5M × $10/M = $4,305 (mostly offset by cache hits)          
                                                                  
  Output Token Cost (approx. 12%)                                
  ██████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░  
  1.6M × $50/M = $80                                             
                                                                  
  Cache Writes & Misc (approx. 2%)                               
  ██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░  
                                                                  
  API List Price: $571.18                                        
  Codex Pro Subscription: $200/month                             
═══════════════════════════════════════════════════════════════════

3.3 Cost Efficiency Considerations

$571 for a single game completion is expensive by any consumer standard. However, as a research experiment, the cost reveals several key insights:

1. Subscription economics: CozyBlaze’s Codex Pro subscription ($200/month) covered the entire cost, demonstrating that subscription models can significantly lower the barrier for individual developers
2. Token efficiency trend: Astra completes complex tasks with fewer output tokens, aligning with OpenAI’s “task-cost pricing” philosophy
3. Cost decline curve: A comparable task on GPT-5.6 Sol would likely cost several times more

4. Astra’s Capability Foundation: Why It Could Succeed

4.1 Benchmark Performance Overview

GPT-6 Astra was released on September 3, 2026, positioning itself as “a new generation of intelligence.” Its benchmark scores are extraordinary:

Benchmark Comparison (ASCII)
═══════════════════════════════════════════════════════════════════

  ARC-AGI-3          GPT-6 Astra: 99.9%                         
                     ████████████████████████████████████████████  
                     GPT-5.6 Sol: 7.8% ██                         
                     Claude Opus 5: 30.2%  █████████████           
                                                                  
  OSWorld 2.0        GPT-6 Astra: 72.6%                         
                     ██████████████████████████████████████        
                     GPT-5.6 Sol: 65.7%                         
                     ██████████████████████████████████            
                                                                  
  ExploitBench       GPT-6 Astra: 100.0%                         
                     ████████████████████████████████████████████  
                     GPT-5.6 Sol: 78.5%                         
                     ████████████████████████████████████████      
                                                                  
  FrontierMath T4    GPT-6 Astra: 97.6%                         
                     ████████████████████████████████████████████  
                     Claude Fable 5.1: 87.8%                     
                     ██████████████████████████████████████████    
                                                                  
  Agents' Last Exam  GPT-6 Astra: 59.3%                         
                     ██████████████████████████████████████        
                     Claude Opus 5: 55.5%                         
                     █████████████████████████████████████         
═══════════════════════════════════════════════════════════════════

4.2 Why Astra Was Up to the Task

1. Multimodal Reasoning

Astra processes both visual (screenshots) and textual (coordinates, context) information simultaneously, building associations between them. In Portal, this means:

• Understanding 3D spatial layout from 2D screenshots
• Identifying key objects (portal exits, buttons, cubes, turrets)
• Combining visual information with physics rules (portal entrance/exit connectivity)

2. Computer Use Capability

Astra scored 72.6% on OSWorld 2.0, 47% faster per task than its predecessor. While Portal is not a desktop application, the core capability chain — “look at screen → understand interface → operate” — is directly transferable.

3. Context Management

Astra introduced cross-window note-taking, allowing it to maintain notes across context windows in Codex rather than repeatedly compressing previous summaries. During a 24-hour game session, the model needed to remember:

• Areas already explored
• Current test chamber number and progress
• Specific puzzle-solving strategies
• Previously attempted (and failed) approaches

class AstraContextManager:
    """Cross-window context management system"""
    
    def __init__(self, window_size=258_400):
        self.window_size = window_size
        self.active_window = []
        self.archived_notes = []
        self.current_size = 0
        
    def add_observation(self, observation: dict):
        """Add a new observation"""
        note = self._summarize(observation)
        if self.current_size + len(note) > self.window_size:
            self._archive()
            self.active_window = []
            self.current_size = 0
        self.active_window.append(note)
        self.current_size += len(note)
        
    def _summarize(self, obs):
        """Compress observation into structured notes"""
        return {
            "chamber": obs["level"],
            "progress": obs["checkpoint"],
            "failed_approaches": obs.get("failures", []),
            "key_objects": obs.get("objects", []),
            "strategy": obs.get("plan", ""),
        }
    
    def _archive(self):
        """Archive current window with searchable index"""
        summary = {
            "window_id": len(self.archived_notes),
            "chambers_covered": self._extract_chambers(),
            "key_decisions": self._extract_decisions(),
            "token_count": self.current_size,
        }
        self.archived_notes.append(summary)
        
    def recall(self, query: str) -> list:
        """Retrieve relevant information from archived notes"""
        results = []
        for note in self.archived_notes:
            if query in str(note):
                results.append(note)
        return results

4. Spatial Reasoning and Abstract Modeling

On ARC-AGI-3 (99.9%), Astra demonstrated a remarkable ability to abstract unfamiliar environments into compact symbolic models. It autonomously created domain-specific language (DSL) to track state and plan actions. In Portal, this translated to:

• Mapping 3D spaces into logical rules
• Understanding “portal entrance → exit” causality
• Planning multi-step sequences (place portal, move cube, press button)

5. From Atari to Portal: The Evolution of AI Gaming

5.1 2016: OpenAI’s Vision

In 2016, OpenAI articulated a bold technical goal — “solve a wide variety of games using a single agent.” At the time, this was considered a distant and radical aspiration. That same year, AI was losing at Atari 2600 chess, unable to defeat even novice players.

5.2 Evolution Timeline

AI Gaming Capability Timeline (ASCII)
═══════════════════════════════════════════════════════════════════

  2016 ─ OpenAI proposes "single agent solving multiple games"
   │      AI loses at Atari 2600 chess
   │
  2017 ─ AlphaStar in StarCraft 2 (requires extensive training)
   │
  2019 ─ OpenAI Five defeats pro Dota 2 teams (specialized RL)
   │
  2022 ─ ChatGPT released; LLMs begin showing reasoning
   │
  2024 ─ GPT-4 completes simple 2D game tasks
   │      Multimodal models begin understanding visual interfaces
   │
  2025 ─ GPT-5.6 Sol shows preliminary computer use
   │      Agent frameworks emerge (LangChain, AutoGPT, etc.)
   │
  2026.9.3 ─ GPT-6 Astra released
   │          ARC-AGI-3: 99.9%  |  OSWorld 2.0: 72.6%
   │
  2026.9.5 ─ GPT-6 Astra autonomously completes Portal
   │          3,336 tool calls  |  24 hours  |  $571.18
   │          First general-purpose agent conquers a 3D world
   │
  2026+ ─ Next milestone: Real-time 3D gaming?
   │       Autonomous play without pause assistance?
   v       Multi-game general-purpose agent?

5.3 Key Turning Points

From 2016 to 2026, AI gaming capabilities evolved through three critical phases:

Phase 1: Specialized Reinforcement Learning (2016-2022)

Models like AlphaStar and OpenAI Five excelled in specific games, but each required millions or billions of specialized training iterations. They could not transfer learned skills to other games.

Phase 2: LLM + Multimodal (2023-2025)

Large language models changed the paradigm. Models no longer needed specialized training; they could “understand” game rules through natural language and visual information. However, limited by reasoning speed and context windows, they could only handle simple 2D games or short tasks.

Phase 3: General-Purpose Agents (2026-)

GPT-6 Astra represents the beginning of a third phase, combining:

• Powerful multimodal understanding
• Efficient context management
• Computer operation capabilities
• Long-duration task execution

This enables a general-purpose model to handle complex 3D game tasks that previously required specialized training.

6. Technical Significance: A Milestone for General-Purpose Agents

6.1 From “Answering Questions” to “Completing Tasks”

Astra’s Portal performance marks a fundamental shift from “answering questions” to “completing tasks”:

AI Capability Evolution (ASCII)
═══════════════════════════════════════════════════════════════════

  GPT-3 Era (2020)          GPT-4 Era (2023)          GPT-6 Astra (2026)
  ┌─────────────────┐      ┌─────────────────┐      ┌─────────────────┐
  │ User: "Write a  │      │ User: "Analyze  │      │ User: "Beat     │
  │        poem"    │      │        data"    │      │        Portal"  │
  │ Model: outputs  │      │ Model: outputs  │      │ Model:          │
  │        text     │      │        code     │      │ 1. Screenshot   │
  │ Task done       │      │ User: copy/run  │      │ 2. Plan actions │
  │                  │      │ User: fix error │      │ 3. Execute      │
  │ One-way output  │      │ User: re-run    │      │ 4. Check result │
  │ No feedback     │      │ ...             │      │ 5. Iterate      │
  │ loop            │      │ Multi-turn but  │      │ 6. Goal reached │
  │                  │      │ human-dependent │      │                  │
  │ Output model    │      │ Assistive model │      │ Autonomous agent│
  └─────────────────┘      └─────────────────┘      └─────────────────┘

6.2 Multimodal Reasoning in Practice

The Portal run demonstrated several critical multimodal reasoning capabilities:

Spatial Understanding: The model had to infer 3D space from 2D screenshots — recognizing walls, platforms, and the spatial relationships between objects.

Causal Reasoning: Portal’s core mechanic is “entrance → exit” connectivity. The model needed to understand:

• If you place a blue portal on one wall and an orange portal on another, entering the blue one exits through the orange one
• Momentum conservation: entering from a high position exits at high velocity

Long-term Planning: Puzzle chambers often require multi-step operations:

1. Move a cube onto a pressure plate
2. The plate activates a platform
3. Place a portal on the wall
4. Cross through the portal to the high ground
5. Jump from the high ground to reach the exit

6.3 Tool Use Generalization

Astra controlling a game through MCP is fundamentally a demonstration of generalized tool use — the same “look → understand → act” loop applies to:

• Operating desktop software (CRM, Excel, browsers)
• Writing and debugging code
• Cybersecurity analysis
• Scientific data analysis

// Universal Agent Loop Structure (Go)
package agent

type AgentLoop struct {
    Model    ReasoningEngine
    Tools    []Tool
    Context  ContextManager
    Memory   LongTermMemory
}

func (a *AgentLoop) Run(task Task) Result {
    // Universal loop: Perceive → Reason → Act → Evaluate
    for !task.IsComplete() {
        // Perceive: collect current state
        observations := a.sense(task)
        
        // Reason: model analyzes and decides
        plan := a.Model.Reason(observations, task.Goal)
        
        // Act: execute the plan
        for _, step := range plan.Steps {
            result := a.execute(step)
            a.Context.Add(step, result)
            
            // Evaluate: check if adjustment is needed
            if result.HasError() {
                correction := a.Model.Correct(step, result)
                a.execute(correction)
            }
        }
    }
    return a.assembleResult(task)
}

// This loop works equally well for Portal, desktop apps, and code writing
// The only difference is the concrete Tool implementations

7. Limitations and Challenges

7.1 Time Cost

A 24-hour completion time, compared to a human player’s 4-6 hours, reveals the vast gap between current LLM reasoning speed and human perception-action cycles. While the pause mechanism solves the “real-time” problem, it also means the model cannot handle scenarios requiring rapid reactions (combat, obstacle avoidance).

7.2 Economic Cost

$571.18 for a single game completion remains prohibitively expensive. Even with the Codex Pro subscription absorbing the cost, at API list price this represents:

• Approximately 38 copies of Portal on Steam
• Enough to pay a junior developer for two weeks
• Far beyond most AI research experiment budgets

7.3 Technical Limitations

Current Limitations vs Future Directions (ASCII)
═══════════════════════════════════════════════════════════════════

  Current Limitations                      Future Directions
  ─────────────────────                    ─────────────────────
  Requires pause mechanism                Real-time reasoning
  ████████████████████████████████████    ██░░░░░░░░░░░░░░░░░░░░░░░
                                           
  High API cost                           Cost reduction 10-100x
  ████████████████████████████████████    ██░░░░░░░░░░░░░░░░░░░░░░░
                                           
  360p screenshot input                   HD visual understanding
  ████████████████████████████████████    ██░░░░░░░░░░░░░░░░░░░░░░░
                                           
  Manual intervention for edge cases      Fully autonomous recovery
  ████████████████████████████████████    █░░░░░░░░░░░░░░░░░░░░░░░░
                                           
  Source engine only                      Multi-engine adapters
  ████████████████████████████████████    █░░░░░░░░░░░░░░░░░░░░░░░░
                                           
  Single reasoning cycle 2-30 seconds     Sub-second inference
  ████████████████████████████████████    █░░░░░░░░░░░░░░░░░░░░░░░░

7.4 Not a Standardized Benchmark

CozyBlaze explicitly stated that this run should not be viewed as a standardized AI benchmark. Reasons include:

1. Training data contamination: Portal was released in 2007 — nearly 20 years old — with walkthroughs, videos, and discussions spanning the entire internet, potentially appearing in Astra’s training data
2. Tool assistance: SPT provided coordinate and angle information that human players typically do not have
3. Pause mechanism: The game froze during model reasoning, effectively converting a real-time game into a turn-based one
4. Single trial: Only one successful experiment, lacking statistical significance

8. Industry Impact

8.1 Impact on AI Agents

The Portal experiment proves that a general-purpose agent can complete complex tasks that previously required specialized training. This means:

1. Agent framework evolution: The focus shifts from “how to make the model call functions” to “how to constrain tasks, manage state, and handle failures”
2. Multimodal reasoning expansion: Models are no longer limited to text and simple visuals but can handle complete 3D environments
3. Autonomy grading: Moving from “full human supervision” to “set a goal and let it execute”

8.2 Impact on Game AI

Game AI Technology Evolution (ASCII)
═══════════════════════════════════════════════════════════════════

  Traditional Game AI       LLM-Driven AI          General-Purpose Agent
  ──────────────────       ────────────           ────────────────────
  Finite State Machines     NPC Dialogue           Autonomous Gameplay
  ████████████████████      ████████████████████    ████████████████████
  
  Behavior Trees            Dynamic Story Gen      Game Test Automation
  ████████████████████      ████████████████████    ████████████████████
  
  Pathfinding Algorithms    Intelligent NPCs       New Game Adaptation
  ████████████████████      ████████████████████    ████████████░░░░░░░░
  
  Rule Scripts              Player Behavior Analysis Cross-Game Transfer
  ████████████████████      ████████████████████    ██████░░░░░░░░░░░░░░
  
  Specialized RL            In-Game Assistants     Autonomous Game Design
  ████████████████████      ████████████████████    ████░░░░░░░░░░░░░░░░

8.3 Impact on Automated Testing

The ability to autonomously explore game worlds and discover solutions has direct applications in:

• Quality assurance: Automated testing of all levels for passability and bug detection
• Game balance validation: AI attempts multiple strategies to detect design flaws
• Regression testing: Automated verification of all levels after each update

8.4 Impact on AI Agent Safety

Astra is simultaneously OpenAI’s first model to reach the “Critical” cybersecurity capability threshold. When models can autonomously operate computers, browse screens, and execute action sequences, safety controls become paramount:

class AgentSafetyLayer:
    """AI Agent safety control layer"""
    
    PERMISSION_LEVELS = {
        "read_only": 0,      # Read-only, no operations
        "confirm_all": 1,    # Every step requires human approval
        "confirm_risk": 2,   # High-risk operations need approval
        "autonomous": 3,     # Fully autonomous (high risk)
    }
    
    def __init__(self, model, permission_level="confirm_risk"):
        self.model = model
        self.permission_level = permission_level
        self.audit_log = []
        
    def execute_with_safety(self, action):
        """Execute action with safety checks"""
        risk_score = self._assess_risk(action)
        
        # Log for audit
        self.audit_log.append({
            "action": action,
            "risk": risk_score,
            "timestamp": time.now(),
        })
        
        # Check if human approval needed
        if self._needs_approval(risk_score):
            approved = self._request_approval(action)
            if not approved:
                return {"status": "rejected", "action": action}
        
        # Execute
        result = self.model.execute(action)
        
        # Post-execution check
        if self._detect_anomaly(result):
            self._emergency_stop()
            
        return result

9. The Experimenter’s Perspective: CozyBlaze’s Comments

CozyBlaze shared his thoughts on X and GitHub:

“GPT-6 Astra has autonomously completed Portal! I didn’t expect this to happen so soon, but I’m glad we’ve made so much progress here. I was reminded that back in 2016, one of OpenAI’s technical goals was to ‘solve a wide variety of games using a single agent.’ Watching a general-purpose agent autonomously navigate and make it all the way through the game feels like a small glimpse of that original vision becoming real.”

He also added a characteristically pragmatic note:

“GPT-6 Astra is the worst model we’ll ever get.”

The implication: Astra represents the starting point of general-purpose agents, not the destination. Future models will be cheaper, faster, and more capable. What looks like a milestone today will likely be seen as a baseline tomorrow.

10. Conclusion

GPT-6 Astra’s autonomous completion of Portal is a symbolic milestone. It demonstrates that:

1. A general-purpose agent can handle a complete 3D game world, not just text or 2D environments
2. The combination of multimodal reasoning + tool use + context management enables models to complete complex tasks requiring long-term planning and multi-step operations
3. AI Agent capabilities are shifting from “assistance” to “execution”, from “answering questions” to “completing tasks”

But we must also recognize the sobering realities: 24 hours of wall time, $571 in cost, the pause mechanism’s assistance, and nearly two decades of game history in the training data. This is not the endpoint of general-purpose AI — it is the beginning.

As CozyBlaze put it, Astra is the worst general-purpose agent we will ever have. Future models will complete more complex tasks in less time, at lower cost, and without assistance.

The vision OpenAI articulated in 2016 — “a single agent solving a wide variety of games” — is becoming real in 2026.

References

1. CozyBlaze (@cozyblazex) on X: “GPT-6 Astra has autonomously completed Portal!” — September 5, 2026
2. CozyBlaze, “Portal Agent” — GitHub repository (code and documentation)
3. OpenAI, “GPT-6 Astra: A new generation of intelligence” — Official release page, September 3, 2026
4. OpenAI, “GPT-6 Astra System Card” — Safety technical report, September 2026
5. ARC Prize, “OpenAI’s GPT-6 Astra on ARC-AGI-3” — Independent evaluation, September 3, 2026
6. Tom’s Hardware — “AI model successfully completes Portal but it costs $571 in tokens” — September 7, 2026
7. The Decoder — “GPT-6 Astra beat Portal start to finish without human help in under 24 hours” — September 7, 2026
8. IT之家 — “OpenAI GPT-6 Astra模型自主通关3D解谜游戏《传送门》” — September 7, 2026
9. VideoCardz — “GPT-6 Astra beat Portal — after $571 in API calls” — September 7, 2026
10. ARC Prize Blog — “OpenAI’s GPT-6 Astra on ARC-AGI-3” — September 3, 2026

• ←Previous
• Next→