展开全文
GPT-6 Astra is here. The biggest upgrade isn’t necessarily raw code generation — it’s the ability to autonomously work through complex tasks and actually get them to completion.
For Codex and other coding agents, this could be a pretty significant jump.
1. Much Stronger as an Autonomous Coding Agent
Astra is significantly better at long workflows like:
inspect the repo → understand the architecture → make changes → run the code → encounter an error → fix it → test everything
The improvement on Terminal-Bench 4.0 is particularly noticeable:
GPT-5.6 Sol: 37.3% → GPT-6 Astra: 57.9%
That’s roughly a 55% relative improvement over Sol.
For Codex, this may be one of the most important benchmarks because it’s much closer to real agentic software engineering than simply “write this function from a specification.”
2. Better With Huge Repositories and Long Context
Astra supports up to 1.05M tokens of context.
The long-context results in the 512K–1M range are especially interesting:
GPT-5.6 Sol: 73.8% → GPT-6 Astra: 96.3%
This should matter for large codebases where changing one module affects several other parts of the system and the model needs to maintain an understanding of the broader architecture.
3. Much Stronger at Terminal, DevOps, and Infrastructure Tasks
Astra shows particularly large improvements on tasks where writing code is only one part of the job.
For example:
Database migrations: 42.7% → 63.9%
This should make it particularly interesting for:
database migrations
Docker
CI/CD
VPS/server infrastructure
production debugging
complex multi-step changes
In other words, tasks where the agent needs to interact with a real system, observe what happens, and iterate — rather than simply generate a patch.
4. Better at Figuring Out Completely Unknown Problems
ARC-AGI-3 is particularly interesting here.
Astra scored 62.7% using the standard independent harness, and up to 99.9% using the OpenAI Provider Adapter.
Important caveat: the 99.9% result should not be directly compared with older model scores, because the harness and conditions are different.
What’s more interesting is Astra’s behavior.
The model can explore an unfamiliar environment, build an internal representation of its rules, test hypotheses, observe the results, and adjust its strategy.
That’s surprisingly relevant to coding agents.
A good coding agent shouldn’t only be able to implement a feature from a perfect specification. It should also be able to figure out:
what is happening → what is broken → why → what to try → whether it worked → what to do next
GPT-6 Astra vs GPT-5.6 Sol — Benchmarks
Benchmark
GPT-5.6 Sol
GPT-6 Astra
Terminal-Bench 4.0
37.3%
57.9%
DeepSWE 1.1
72.7%
74.1%
FrontierCode Main
47.5%
53.3%
FrontierCode Extended
60.6%
64.5%
Database migrations
42.7%
63.9%
One important detail: on a more traditional SWE benchmark, the improvement isn’t revolutionary:
72.7% → 74.1%
So Astra doesn’t suddenly make GPT-5.6 a bad coding model.
The biggest gains appear in long-running agentic tasks where the model needs to investigate a system, use tools, make decisions, verify the results, and iterate on its own work.
Pricing
Current API pricing per 1M tokens. Previous GPT-5.6 prices are shown in parentheses:
Model
Input
Output
✨ GPT-6 Astra
$10
$50
☀️ GPT-5.6 Sol
$4 ($5)
$20 ($30)
🌍 GPT-5.6 Terra
$2 ($2.50)
$12 ($15)
🌙 GPT-5.6 Luna
$0.20 ($1)
$1.20 ($6)
Astra is roughly 2.5x more expensive than Sol, while Luna has become 5x cheaper than its original price.
This creates a pretty wide price/performance spectrum, so using Astra for absolutely everything probably doesn’t make much sense.
Which Model Should You Use?
🌙 GPT-5.6 Luna — Mechanical Work
Renaming, simple edits, boilerplate, copy changes, types, lint fixes, and repetitive modifications.
Example:
Rename this component across the project, update all imports, and fix any resulting lint errors.
Very cheap and ideal when there isn’t much uncertainty about what needs to be done.
🌍 GPT-5.6 Terra — Everyday Development
Regular screens, endpoints, integrations with existing APIs, tests, and relatively straightforward features.
Example:
Add an account deletion endpoint and connect it to the existing settings screen.
Probably the best balance of cost and capability for normal development work.
☀️ GPT-5.6 Sol — Complex Development
Debugging, changes across multiple modules, complex features, code review, and working with an existing architecture.
Example:
Find out why offline sync occasionally creates duplicates, fix the root cause, and add regression tests.
Likely still the sweet spot for most serious software development tasks.
✨ GPT-6 Astra — “Figure It Out and Get It Done”
Complex unknown bugs, architectural changes, large migrations, infrastructure, DevOps, and tasks spanning multiple systems.
For example:
I don’t know where the problem is. Investigate the project, reproduce the bug, identify the root cause, choose the appropriate solution, implement it, run the tests, and keep iterating until everything works.
This is where Astra’s advantages should become much more noticeable.
TL;DR
Model
Best For
🌙 Luna
You know exactly what needs to be done — just do it cheaply
🌍 Terra
Normal software development
☀️ Sol
The implementation itself is difficult
✨ Astra
Even figuring out what should be done is difficult
Based on the initial results, Astra looks less like “a much better code generator” and more like a significantly stronger autonomous software engineering agent.
That’s why the Terminal-Bench jump from 37.3% to 57.9% may ultimately be much more interesting than the relatively small improvement on traditional coding benchmarks.
GPT-6 Astra 帖子与演示
官方公告与视频，以及社区讨论。
X (Twitter)
OpenAI ·
This is GPT-6 Astra. Anything you can do on a computer, Astra can do for you. Fast. https://t.co/gDd0IsewJw
https://pbs.twimg.com/amplify_video_thumb/2095595661559574528/img/Vmb2pgEFJ6fpCUTD.jpg查看原文OpenAI ·
GPT-6 Astra is now available to all Pro, Enterprise, and Business Premium users in ChatGPT Work and Codex. It's also live in the API. It might take a few days to roll out to our Plus and Business users. Thank you for your patience.
查看原文OpenAI ·
In Chat, GPT-6 Astra powers GPT-6 Pro, now available to all Pro, Business, and Enterprise users.
查看原文Reddit
GPT-6 Astra | OpenAI
MatricesRL ·
查看原文GPT-6 Astra: Everything You Need to Know
emir_morris ·
展开全文
GPT-6 Astra is here. The biggest upgrade isn’t necessarily raw code generation — it’s the ability to autonomously work through complex tasks and actually get them to completion. For Codex and other coding agents, this could be a pretty significant jump. 1. Much Stronger as an Autonomous Coding Agent Astra is significantly better at long workflows like: inspect the repo → understand the architecture → make changes → run the code → encounter an error → fix it → test everything The improvement on Terminal-Bench 4.0 is particularly noticeable: GPT-5.6 Sol: 37.3% → GPT-6 Astra: 57.9% That’s roughly a 55% relative improvement over Sol. For Codex, this may be one of the most important benchmarks because it’s much closer to real agentic software engineering than simply “write this function from a specification.” 2. Better With Huge Repositories and Long Context Astra supports up to 1.05M tokens of context. The long-context results in the 512K–1M range are especially interesting: GPT-5.6 Sol: 73.8% → GPT-6 Astra: 96.3% This should matter for large codebases where changing one module affects several other parts of the system and the model needs to maintain an understanding of the broader architecture. 3. Much Stronger at Terminal, DevOps, and Infrastructure Tasks Astra shows particularly large improvements on tasks where writing code is only one part of the job. For example: Database migrations: 42.7% → 63.9% This should make it particularly interesting for: database migrations Docker CI/CD VPS/server infrastructure production debugging complex multi-step changes In other words, tasks where the agent needs to interact with a real system, observe what happens, and iterate — rather than simply generate a patch. 4. Better at Figuring Out Completely Unknown Problems ARC-AGI-3 is particularly interesting here. Astra scored 62.7% using the standard independent harness, and up to 99.9% using the OpenAI Provider Adapter. Important caveat: the 99.9% result should not be directly compared with older model scores, because the harness and conditions are different. What’s more interesting is Astra’s behavior. The model can explore an unfamiliar environment, build an internal representation of its rules, test hypotheses, observe the results, and adjust its strategy. That’s surprisingly relevant to coding agents. A good coding agent shouldn’t only be able to implement a feature from a perfect specification. It should also be able to figure out: what is happening → what is broken → why → what to try → whether it worked → what to do next GPT-6 Astra vs GPT-5.6 Sol — Benchmarks Benchmark GPT-5.6 Sol GPT-6 Astra Terminal-Bench 4.0 37.3% 57.9% DeepSWE 1.1 72.7% 74.1% FrontierCode Main 47.5% 53.3% FrontierCode Extended 60.6% 64.5% Database migrations 42.7% 63.9% One important detail: on a more traditional SWE benchmark, the improvement isn’t revolutionary: 72.7% → 74.1% So Astra doesn’t suddenly make GPT-5.6 a bad coding model. The biggest gains appear in long-running agentic tasks where the model needs to investigate a system, use tools, make decisions, verify the results, and iterate on its own work. Pricing Current API pricing per 1M tokens. Previous GPT-5.6 prices are shown in parentheses: Model Input Output ✨ GPT-6 Astra $10 $50 ☀️ GPT-5.6 Sol $4 ($5) $20 ($30) 🌍 GPT-5.6 Terra $2 ($2.50) $12 ($15) 🌙 GPT-5.6 Luna $0.20 ($1) $1.20 ($6) Astra is roughly 2.5x more expensive than Sol, while Luna has become 5x cheaper than its original price. This creates a pretty wide price/performance spectrum, so using Astra for absolutely everything probably doesn’t make much sense. Which Model Should You Use? 🌙 GPT-5.6 Luna — Mechanical Work Renaming, simple edits, boilerplate, copy changes, types, lint fixes, and repetitive modifications. Example: Rename this component across the project, update all imports, and fix any resulting lint errors. Very cheap and ideal when there isn’t much uncertainty about what needs to be done. 🌍 GPT-5.6 Terra — Everyday Development Regular screens, endpoints, integrations with existing APIs, tests, and relatively straightforward features. Example: Add an account deletion endpoint and connect it to the existing settings screen. Probably the best balance of cost and capability for normal development work. ☀️ GPT-5.6 Sol — Complex Development Debugging, changes across multiple modules, complex features, code review, and working with an existing architecture. Example: Find out why offline sync occasionally creates duplicates, fix the root cause, and add regression tests. Likely still the sweet spot for most serious software development tasks. ✨ GPT-6 Astra — “Figure It Out and Get It Done” Complex unknown bugs, architectural changes, large migrations, infrastructure, DevOps, and tasks spanning multiple systems. For example: I don’t know where the problem is. Investigate the project, reproduce the bug, identify the root cause, choose the appropriate solution, implement it, run the tests, and keep iterating until everything works. This is where Astra’s advantages should become much more noticeable. TL;DR Model Best For 🌙 Luna You know exactly what needs to be done — just do it cheaply 🌍 Terra Normal software development ☀️ Sol The implementation itself is difficult ✨ Astra Even figuring out what should be done is difficult Based on the initial results, Astra looks less like “a much better code generator” and more like a significantly stronger autonomous software engineering agent. That’s why the Terminal-Bench jump from 37.3% to 57.9% may ultimately be much more interesting than the relatively small improvement on traditional coding benchmarks.
Got GPT-6 Astra working in Cursor's Agent (tools + reasoning) via BYOK – what blocks it and how I worked around it
salmoukas ·
展开全文
TL;DR: With your own OpenAI key, gpt-6-astra doesn't work in Cursor even though the same key works via curl. I put a logging relay between Cursor and OpenAI and found two mismatches: Cursor's BYOK path speaks Chat Completions, but OpenAI only allows function tools with reasoning for Astra via /v1/responses – and Cursor's own model registry blocks the name on that path anyway. A small local relay that translates between the two makes Astra usable in Cursor's Agent with tools and reasoning. Details below, code at the end. What happens Custom model gpt-6-astra, no base URL override → model_not_found. I couldn't diagnose this one; the request is made by Cursor's backend and I can't see it. Given the current OpenAI/Cursor situation, Cursor's infrastructure may simply not reach the model, whoever's key it is. With "Override OpenAI Base URL" → Routing failed: model registry mcid "gpt-6-astra" ... cannot serve client protocol "chat_completions". Nothing ever reaches your URL. Cursor's registry knows the name as Responses-only and refuses it on the (Chat Completions) BYOK path. An unknown alias gets through as a generic custom model. With an alias, Cursor sends plain Chat Completions with tools and no reasoning_effort. OpenAI answers: Function tools with reasoning_effort are not supported for gpt-6-astra in /v1/chat/completions. To use function tools, use /v1/responses or set reasoning_effort to 'none'. So Astra with reasoning+tools requires the Responses API – but Cursor expects Chat Completions chunks back. What the relay does (~750 lines TypeScript, Node 24, runs on your machine, embedded ngrok tunnel because Cursor's backend needs a public URL) Model aliases with an effort suffix: relay-gpt-6-astra-high → gpt-6-astra + reasoning.effort=high. Add …-low / …-medium as separate models – Cursor has no reasoning control for custom models, this gives you one. Translates the Chat Completions request to Responses (messages, tools, tool calls/results, images) → /v1/responses, and converts the Responses SSE stream back to chat.completion.chunks (text, tool calls, finish reason, usage). Your real key stays in a local .env; Cursor only gets a random relay token. Stop in Cursor aborts the upstream request. Optional full request/response logging (that's how I found the above). Setup: pnpm install, four values in .env (OpenAI key, relay token, ngrok authtoken + free dev domain), pnpm start. In Cursor: API key = relay token, base URL = ngrok URL + /v1, custom models = relay-gpt-6-astra-high etc. Verified with multi-turn tool round trips in Agent mode. Caveats Requests still pass through Cursor's servers – verified, the calls to the relay come from an AWS EC2 host, not from my machine. Only the hop to OpenAI is local. reasoning.encrypted_content can't be returned through Chat Completions chunks, so Astra doesn't see its previous reasoning in later turns (answers and tool results are preserved). ngrok free = 1 GB/month; any SSE-capable tunnel works instead (Cloudflare Quick Tunnels don't, they buffer SSE). Cursor may change its BYOK format at any time; the relay logs dropped=[...] for fields it doesn't know. Happy to answer questions here. Code, if it's useful to anyone (MIT-free to fork, I have no commercial interest in it): https://github.com/coreprocess/openai-relay-for-cursor
YouTube
Introducing GPT-6 Astra: the most intelligent and aligned model in the world.
OpenAI
查看原文Introducing GPT-6 Astra for developers
OpenAI
查看原文GPT-6 Astra with Peter Gostev
OpenAI
查看原文