GPT-6 Astra

GPT-6 Astra is the frontier model OpenAI released on September 3, 2026, and the clearest statement so far that the industry’s definition of a “language model” has moved. Astra is still a text-in, text-out system at the API boundary, but almost every design decision in it points away from conversation and toward operating software: a 1,050,000 token context window, five explicit reasoning effort levels topping out at max, and a first-party tool surface that includes computer use, a hosted shell, a patch applier, and skills. OpenAI’s framing is that Astra “sets a new state of the art for computer use, browsing, software engineering, cybersecurity, science, and professional work,” and the benchmark set it launched against reflects that: less MMLU, more TerminalBench and ScreenSpot. It is also the first OpenAI model to reach the Critical cybersecurity capability level under the company’s Preparedness Framework, which makes its release as much a safety-governance event as a capability one.

From Chat Model to Computer Operator

The practical shift with Astra is that the unit of work is no longer a turn. Earlier frontier models were evaluated on whether a single response was good. Astra is evaluated on whether a session that spans dozens of tool calls, a browser, a shell, and a filesystem ends in a correct artifact. OpenAI’s own examples run in this register: inspecting screens, building websites, generating documents, running QA passes, analyzing scientific data, and modelling a house in Blender before converting it into a walkable Unreal Engine 5 scene.

That reframing changes what the surrounding agent harness has to provide. A chat model needs a prompt and a response parser. A computer operator needs an environment, a permission boundary, a way to recover from a misclick, and a budget. Three properties of Astra exist specifically to serve that:

• A very large context window. At 1,050,000 tokens (922,000 of them usable for input, 128,000 for output), a session can hold an entire repository, a long browsing trace, and the accumulated screenshots-as-text of a multi-hour task without the harness having to aggressively summarize. Summarization is where long-horizon agents historically lost the thread.
• Selectable reasoning effort. Five levels (low, medium, high, xhigh, max) let the caller decide how much test-time compute a step deserves, rather than paying frontier reasoning prices for a step that is really just a form fill.
• A tool surface that includes the operating system. Web search, file search, image generation, code interpreter, hosted shell, apply patch, skills, computer use, MCP, and tool search are all first-party. The Model Context Protocol entry covers how third-party tools plug into the same loop.

# Scenario: a research agent that browses, then writes a report. The two
# phases have completely different reasoning needs, so they get different
# effort levels instead of one global setting.

# Phase 1: navigation. Mostly mechanical, needs speed and low cost.
nav = client.responses.create(
    model="gpt-6-astra",
    reasoning={"effort": "low"},
    tools=[{"type": "web_search"}],
    input="Find the three most recent primary sources on sparse-linear attention.",
)

# Phase 2: synthesis. This is where the thinking budget actually pays for itself.
synthesis = client.responses.create(
    model="gpt-6-astra",
    reasoning={"effort": "xhigh"},
    input=[
        {"role": "system", "content": "You are writing for an expert audience."},
        {"role": "user", "content": f"Sources:\n{nav.output_text}\n\nWrite the analysis."},
    ],
)

The Reasoning Effort Dial

The effort parameter is the single most consequential knob on Astra, because it silently changes both the bill and the latency by an order of magnitude. Reasoning tokens are billed at the output rate ($50 per million), so a max-effort call that thinks for 30,000 tokens before writing a 500 token answer costs roughly sixty times what the visible answer suggests. The countervailing force is prompt caching: a cached input token costs $1 per million against a $10 per million uncached rate, so an agent that keeps a large stable system prefix and appends to it can claw back most of the input cost.

The widget below models that interaction. It is a simplification, but the shape is real: the cost of a long-horizon agent is dominated by reasoning tokens at high effort and by uncached input at low effort, and the crossover moves depending on how well your harness is structured for caching.

Try this: set effort to max, then drag the cache share from 0 to 100 percent. Notice how little it helps. At high effort the bill is reasoning tokens, and caching cannot touch those. Then drop to low and repeat: now caching is nearly the whole story.

The design rule that falls out of this is to stratify effort by step type rather than picking one level for the whole agent. Navigation, form filling, and file reads run at low or medium. Planning, debugging, and final synthesis run at high or above. Reserve max for the small number of steps where a wrong answer costs more than the tokens.

Prompt Caching and the Shape of the Prompt

Because cached input is billed at a tenth of the fresh rate, Astra rewards prompts that are append-only. A cache hit requires an exact prefix match, so anything that varies (a timestamp, a shuffled tool list, a per-request user id injected at the top) invalidates everything after it.

# Scenario: a support agent that answers from a large, stable policy corpus.
# The mistake is putting the volatile bits first.

# Bad: the timestamp busts the cache on every single request.
messages_bad = [
    {"role": "system", "content": f"Current time: {now()}\n\n{POLICY_CORPUS}"},
    {"role": "user", "content": question},
]

# Good: stable prefix first, volatile suffix last. The 200k-token corpus
# is billed at the cached rate from the second request onward.
messages_good = [
    {"role": "system", "content": POLICY_CORPUS},          # stable, cacheable
    {"role": "system", "content": TOOL_CONVENTIONS},       # stable, cacheable
    {"role": "user", "content": f"[{now()}] {question}"},  # volatile, cheap
]

Benchmarks and What Saturation Means

Astra launched with state-of-the-art claims across an unusually agentic benchmark set. The notable pattern is not the wins but the saturation: several of these evaluations are effectively finished as discriminative instruments.

Three numbers at or near 100% in a single launch is the strongest argument yet for the practices described in double-blind AI benchmarking: when a benchmark saturates, it stops separating models and its remaining headline value is marketing. Teams evaluating Astra for production should assume the public numbers are uninformative about their own workload and build a private, held-out evaluation set instead. The agent evaluation entry covers how to construct one that measures trajectory quality rather than final-answer accuracy.

Safety: The First Critical Cybersecurity Classification

Astra is the first OpenAI model to reach the Critical cybersecurity capability level under the Preparedness Framework, a threshold that triggers additional safeguards before and during deployment rather than a simple release. The 100% ExploitBench result is the concrete face of this: a model that can reliably find and weaponize vulnerabilities is dual-use in the strongest sense, valuable to defenders doing authorized testing and dangerous in the hands of an attacker who no longer needs the expertise.

The practical consequence for builders is that capability access and deployment surface are now decoupled. Availability rolled out in stages (Pro, Enterprise, and Business Premium first, then Plus and Business, with API access reaching selected partners before general release), and cyber-capable behaviours sit behind additional gating. If your product touches security tooling, expect the access question to be a policy conversation and not just a billing one.

What’s New (2025 to 2026)

The Astra release crystallizes four trends that had been building through 2025 and into 2026.

Reasoning effort became a first-class API parameter. The xhigh and max tiers extend a ladder that started with the o-series. Effort is now something you budget per step, which is why test-time compute has moved from a research topic to a line item.

Context windows crossed a million tokens as a default expectation, not a headline. Astra’s 1.05M window arrives in the same season as GLM-5.3-Flash’s 1M window at a fraction of the price. The differentiator moved from window size to effective recall across the window, and from there to cost per useful token.

Computer use stopped being a preview. ScreenSpot Pro and AutomationBench are now launch benchmarks, which they were not eighteen months earlier.

Benchmark saturation forced a governance response. With FrontierMath Tier 4 and ARC-AGI-3 both reported as saturated in a single release, the field’s measurement problem became acute enough that contamination-resistant and cryptographically blinded evaluation moved from academic proposal to industry practice.

A Practical Architecture

The following is the shape most teams converge on when putting Astra behind a real workload. The key move is that the expensive model is not the only model in the system.

flowchart TD
    A[User request] --> B{Router: classify step type}
    B -->|mechanical: fetch, fill, read| C[Astra @ low effort]
    B -->|planning, debugging, synthesis| D[Astra @ high or xhigh]
    B -->|bulk extraction, classification| E[Flash-tier model]
    C --> F[Tool layer]
    D --> F
    E --> F
    F --> G[(Cached stable prefix<br/>policy, schemas, conventions)]
    G --> H[Verifier: schema check + held-out eval]
    H -->|pass| I[Artifact delivered]
    H -->|fail| D

    classDef default fill:#ffffff,stroke:#4338CA,stroke-width:2px,color:#0F172A,rx:8px,ry:8px;
    classDef data    fill:#EEF0F7,stroke:#0D9488,stroke-width:2px,color:#0F172A,rx:8px,ry:8px;
    classDef process fill:#F7F8FC,stroke:#6366F1,stroke-width:2px,color:#0F172A,rx:8px,ry:8px;
    classDef output  fill:#4338CA,stroke:#4338CA,stroke-width:2px,color:#ffffff,rx:8px,ry:8px;
    class G data;
    class C,D,E,F,H process;
    class I output;

# Scenario: the router above. Cheap classification decides how much the
# expensive model is allowed to think, which is where most of the savings live.
EFFORT_BY_KIND = {
    "fetch": "low", "fill_form": "low", "read_file": "low",
    "summarize": "medium",
    "plan": "high", "debug": "high",
    "final_synthesis": "xhigh",
    "irreversible_decision": "max",
}

def step(kind: str, prompt: str, tools: list):
    return client.responses.create(
        model="gpt-6-astra",
        reasoning={"effort": EFFORT_BY_KIND.get(kind, "medium")},
        tools=tools,
        input=[
            {"role": "system", "content": STABLE_PREFIX},  # cached across all steps
            {"role": "user", "content": prompt},
        ],
    )

Limitations Worth Naming

Astra’s input modalities are text and image; its output is text only. Image generation is available as a tool, not as a native output modality, which distinguishes it from a natively multimodal model in the strict sense. Its knowledge cutoff is April 30, 2026, so anything after that date must arrive through search or retrieval rather than parameters, and the model will confabulate about recent events if you do not ground it.

The deeper limitation is economic rather than technical. At $10 per million input tokens and $50 per million output tokens, a naive agent that replays a growing transcript at high effort across forty steps can cost more than the human it was meant to assist. Astra makes the capability available; extracting value from it is a systems-engineering problem about routing, caching, and verification, not a prompting problem.

# Scenario: a QA engineer wants Astra to open a staging site in a hosted
# browser, walk a signup flow, and file a structured bug report. This is a
# long-horizon task, so it gets a high effort level and a cached system
# prefix that every run in the suite reuses.
from openai import OpenAI

client = OpenAI()

resp = client.responses.create(
    model="gpt-6-astra",
    reasoning={"effort": "high"},        # low | medium | high | xhigh | max
    tools=[
        {"type": "computer_use"},        # screen inspection plus click/type
        {"type": "web_search"},
    ],
    input=[
        {
            "role": "system",
            # Long, stable prefix: put it first so prompt caching can
            # bill it at $1/M instead of $10/M on every later run.
            "content": QA_HANDBOOK + BUG_TAXONOMY + STAGING_CREDENTIALS_NOTE,
        },
        {
            "role": "user",
            "content": (
                "Open https://staging.example.com, complete the signup flow "
                "with a throwaway address, and report the first step that "
                "deviates from the documented behaviour."
            ),
        },
    ],
    text={
        "format": {
            "type": "json_schema",
            "name": "bug_report",
            "schema": BUG_REPORT_SCHEMA,   # structured output, not prose
        }
    },
    max_output_tokens=16000,
)

report = resp.output_parsed
print(report["failing_step"], report["severity"])