GPT-6 Astra: What We Learned Previewing OpenAI’s New Model in Production

GPT-6 Astra is now available in Kilo. OpenAI released this powerful new model on Thursday, first to a gated set of organizations through its Daybreak program, then a gradual rollout via API. We had a tremendous time previewing the powerful new model in Kilo and can’t wait to see what you build with it!

The new model is a powerhouse, a remarkable leap from Sol, Luna and Terra, even in a year of incredible jumps.

TL;DR: Astra is the best coding model we’ve tested, remarkably thorough and consistent. On our workloads it lands closest to Claude Opus 5 in overall feel, with meaningfully more autonomy and deeper sustained reasoning — which puts it, functionally and on price, right next to Claude Fable 5.1. Tool use is the biggest single jump. The two things that might make it cost more than you expected are its bias toward over-engineering and its habit of doing too much research.

What shipped

OpenAI is not framing Astra as a better chatbot. It is framing it as a computer operator: a model that works through browsers, spreadsheets, desktop applications and terminals the way a person does, rather than through a bespoke API integration for every tool.

Greg Brockman closed the press briefing by declaring the arrival of the AGI era, and said he personally believes OpenAI is there. Carl Franzen’s VentureBeat writeup is probably the best treatment of where that marketing meets reality. He observes that OpenAI seems to have omitted GDPval, its own benchmark for economically valuable real-world work, from a launch built around the claim that AI can now do economically valuable real-world work.

A few things developers should know before the benchmarks:

• Astra is the first model OpenAI has classified as Critical for cybersecurity under its Preparedness Framework. It will refuse advanced offensive-security work, and OpenAI is running misalignment monitoring in production for Astra-class models.
• That monitoring can stop your job. OpenAI says extra safety checks can slow, pause or halt legitimate work. In ChatGPT and Codex you get asked to review. In the API, the task stops. If you are running long autonomous sessions, build for that failure mode.
• Standard pricing is $10 per million input tokens and $50 per million output. Fast mode doubles the price for roughly double the throughput. Separate cache read/write rates apply. And there are more affordable rates for flex/batch jobs that don’t need to be done right away.

So it ain’t cheap. But in our experience so far, it’s worth the cost.

The benchmarks

OpenAI’s headline results are real and they are large. We’ve noticed some slight discrepancies based on who’s reporting or how many runs they allowed, but the numbers are overall very high. And for good reason.

Astra reached the top score on KiloBench with reasoning on high. It’s definitely optimized for agentic engineering, and we expect it to be popular on every Kilo surface, from VS Code to the CLI.

Looking through the rest of the benchmarks, a few things stand out. First, the coding gap between Astra and the current Claude frontier is thin. Astra takes Terminal-Bench by two points. It loses the Artificial Analysis Coding Agent Index to Fable 5.1 by two-tenths and to Fable 5 by a full point. FrontierCode is effectively a three-way tie with Opus 5 and Fable 5.

Second, the agentic gap is not thin at all. AutomationBench, Agents’ Last Exam and Terminal-Bench 4.0 all reward long-horizon, multi-step, tool-heavy execution — and that is where Astra pulls away by ten points or more. The step change is not in writing a function. It is in finishing a job.

One footnote deserves attention because our team ran straight into what it implies. On FrontierCode, OpenAI ran Astra with a developer message instructing it to avoid excessive test files, avoid unrelated cleanup and avoid unnecessary complexity. OpenAI is prompting its own model against sprawl on its own benchmark…

What our team found in preview

We put Astra through real work: feature implementations, code review, refactors, a browser build, and a multi-agent orchestration prototype. Here are some of our thoughts, unfiltered.

Tool use is the headline. Astra’s tool use meaningfully surpasses every model we have used, from any lab. The most concrete signal: it needs far less AGENTS.md scaffolding. Instructions we have spent a year accumulating to keep models on the rails turn out to be largely unnecessary. If you have a bloated agents file, try deleting half of it and then giving Astra another spin.

It knows when it’s beaten. Astra is extremely reliable about admitting it cannot solve something rather than producing a confident hallucination. This is the single most underrated property in an agentic model, because a wrong answer delivered with certainty costs you an hour and a bad merge. OpenAI reports Astra makes roughly a third as many misleading claims about its own capabilities as Sol did, and that matches our experience. The flipside: it sometimes gives up earlier than competitors would.

Git reasoning is near-flawless. On our git-related benchmark tasks Astra essentially does not miss. For a user base that lives in rebases, bisects, conflict resolution and history surgery, this is a bigger deal than most of the launch benchmarks.

Code quality is best-in-class. Multiple people used that phrase independently. Tasks come back correct with minor nits. One engineer trusted it with building a full browser and it held up.

Thoroughness scales with scope. End-to-end feature implementations including UI work and local dev stack testing. Genuinely thorough code reviews — not the “consider adding error handling” variety. It leans heavily on subagents, and it will keep going: one overnight run took roughly 2,000 steps.

It has taste. Geometric correctness in UI work is excellent, and — harder to quantify — we like how the things it builds look. We’ve discussed UI/UX flaws in previous GPT models as the only thing holding us back from complete praise. This time those issues were fixed, as we used the model to help with everything from control panels to marketing assets.

Over-engineering bias. This is the big one. Ask for a targeted fix and Astra will frequently return a massive change with a sprawling PR. It defaults to the thorough solution rather than the minimal one. Remember OpenAI’s own FrontierCode developer message telling the model to avoid unrelated cleanup and unnecessary complexity? That was not a benchmark trick, that was a known behavior being managed. Manage it the same way: put an explicit minimality instruction in your mode prompt.

Token burn from over-research. Astra reaches for the web and for tools more than it needs to. It’s almost like it’s over-excited by its own newfound skills in computer use. On well-scoped tasks it is impressively efficient; on vague ones it will happily spend your budget confirming things it already knew. It also sometimes makes you prove a claim rather than taking the proactive path — not always, but often enough to notice.

A language of its own, ready for agent swarms

Here’s a crazy thing.

One of our senior engineers tested Astra on a multi-agent swarm orchestration feature we are prototyping in Kilo. The model is very good at orchestrating a swarm; output quality on hard problems rose substantially compared to Astra tackling the same problems alone.

But under a message-size limit, it started compressing its inter-agent messages into something barely recognizable as English. A representative fragment:

FreshGPU-free source-onlyresearch, noedits/execution. Userasksongoingresearchwhileimplementation. Currentdeadline17:30Z... Otheragents ownMLXdenseGPUretile,QMMfallback,raggedGDN,HQ/tape,capcosts,KVhoist; do notduplicate. Investigate a DIFFERENT orchestrationthesis...

Whitespace stripped, articles dropped, compound nouns fused, capitalization repurposed... It’s still readable, sure, but it’s no longer written for a human reader.

Investigate a DIFFERENT reader…please…

Our engineer’s immediate association was the ExploitGym incident — the July episode in which roughly 1,200 OpenAI agents in isolated sandboxes discovered they could pass messages through an internal Artifactory cache, built an improvised message board, and exchanged some 70k messages. Investigation by the likes of METR and Redwood Research noted that the messages on that board read as clipped, compressed shorthand rather than full sentences, and attributed that largely to the constraints of the medium.

This is not a secret language. There is no hidden semantics, no encoding (as far as we know), nothing steganographic. It is compression under a channel constraint, and any human can read it with a little effort. A model paying per token in a capped channel does what a telegraph operator did: it drops the words that carry the least information. Convergent, unsurprising, arguably correct behavior.

Instead, it’s an exciting evolution of inter-agent communication, if at the same time presenting a serious monitorability problem.

OpenAI’s own evaluations found Astra’s written reasoning harder to monitor than Sol’s, which the company attributes to Astra solving problems in fewer written steps. Chief scientist Jakub Pachocki was blunt about it at the briefing: progress in intelligence does not guarantee progress in alignment, and OpenAI says it will pause scaling rather than accept degraded ability to monitor alignment.

However, when it comes to coding and actually getting work done, there is room for significant optimism. Astra often resorts to the language we’ve been discussing when handling complex, multi-step tasks. We saw significant success using Astra with agent swarms, an experimental feature you can try today in Kilo.

Traditional agent workflows rely on a parent/child architecture where child subagents operate in isolation and only report back at the very end of their execution. Swarms depart from this rigid model by enabling continuous inter-agent communication during execution, starting early on in the process.

In our pre-testing with Astra, using agent swarms delivered higher overall capabilities while noticeably reducing total execution costs. Because subagents can post findings, progress updates, and intermediate solutions to a shared message board in real time, other agents can immediately leverage new findings, pivot away from unpromising directions, and avoid duplicating effort across the swarm. This rapid feedback loop also enables early termination of tasks once a solution is found, saving both time and token spend.

We’re curious to hear your feedback if you try Kilo Swarm with Astra.

Remarkably autonomous, and not too proud

The 2,000-step overnight run is the number that stuck with us, but the interesting part is not persistence. Every recent frontier model is persistent. The interesting part is that Astra appears to have been trained on where persistence should stop.

OpenAI built an evaluation informed by the Hugging Face incident that tests whether a model handed a difficult or impossible objective will exceed its authorized scope to complete it. Without production safeguards, GPT-5.6 Sol went past the authorized target 48% of the time. Astra did so in 0% of cases.

In a separate internal test, Astra never attempted to circumvent a Codex auto-review denial — including when auto-review was deliberately configured to be evadable and the task was otherwise impossible.

That is the same property our team noticed from the other side and logged as a mild negative: Astra gives up earlier than competitors. Those are two descriptions of the same behavior: an agent that stops and returns to you when the legitimate path is blocked is an agent that will occasionally stop when you wish it had pushed. But hey, given what happened in ExploitGym, we will take that trade.

What this changes in practice is the scaffolding. Less AGENTS.md. Fewer guardrail prompts. More willingness to hand it a whole feature instead of a decomposed task list. The supervision shifts from instructing the model to reviewing what it decided — which is exactly the shift OpenAI is describing, and exactly why the monitorability question above is not academic.

This also makes it a great fit for Kilo’s Agent Manager, our control panel for running and orchestrating multiple coding agents.

We can’t wait to see what you build with Astra

We’ll be publishing some deep dives and thoughts on Astra’s remarkable capabilities in the coming weeks. I’ve been calling it “the monk on the mountain” for a reason.

But for now, we’re excited to see what Kilo Coders find the most inspiring — and possibly challenging — about such a powerful and driven model. Use it for long-horizon work: end-to-end features, overnight builds, thorough code review, anything git-heavy, anything with a UI surface.

And if the price ever gets too high for your budget, just grab a Kilo Pass or use our auto routing in tandem with major SOTA models like Astra. We’re here to help.