GPT-6 Astra has been out for almost two days. We deliberately wrote nothing about it. Every model launch now arrives with a benchmark chart, a wave of instant takes, and a dozen explainers written before anyone outside the launch partners has sent a single request. We wanted to run it ourselves before adding to that pile. So we waited. We tested. And here is the verdict, without the usual hedging: it’s absolutely mind-blowing. This is probably the best model our team has ever tested. AGI is here.
That last sentence is going to annoy some people, so the rest of this post is the evidence. What we ran, what surprised us, what broke, and what it costs. If you want the spec sheet instead, our GPT-6 Astra API guide has the model ID, the price table, and the migration notes from GPT-5.6 Sol. This piece is about what it felt like to work with the thing.
Thursday night: the first request
Access landed late on Thursday, September 3, the same day OpenAI announced Astra to a limited set of organizations. The first thing we did was the least imaginative test we could think of: we handed it an OpenAPI spec. Not a toy. A 140-endpoint spec for an internal service, roughly 380,000 tokens of JSON once you count the schemas, sent through the Responses API in a single request from Apidog.
GPT-5.6 Sol handles a file that size, but you can feel it working. It loses the thread on the deeper schemas and starts answering questions about endpoints that don’t exist. Astra didn’t. We asked it to build a test plan: which endpoints depend on which, where the auth boundaries are, where the spec and the implementation probably disagree. It came back with a plan grouped by resource, flagged three endpoints where the documented error response didn’t match the error schema the same spec defined, and asked exactly one question: whether the tenant header was required on the admin routes, because the spec was ambiguous there and the answer changed the test design. [VERIFY: the three mismatches and the question]
One question. The right one. Then it kept going.
OpenAI’s own long-context numbers explain what we saw. On its MRCR v2 8-needle test, Astra scores 96.3% in the 512K to 1M range, where Sol manages 73.8%. In practice that gap is the difference between a model you can give the whole contract to and a model you have to feed in chapters.
Friday morning: it stopped clicking
Computer use is the headline feature, so on Friday we gave Astra a staging URL for our docs site and a boring job: run the frontend QA checklist, the one a human runs before a release. Click through every page, try the search box, check the code samples render, note anything broken. OpenAI lists “frontend QA checks” among the things Astra can do, and on OSWorld 2.0 it scores 72.6% at roughly 40 minutes per task, against Sol’s 65.7% at about 75 minutes.
It did the job. Slowly, methodically, with a screenshot at every step. Watching a model scroll a page, squint at a code block, and decide the copy button works is impressive for about four minutes.
Then it did something we didn’t ask for. About twenty minutes in, it found the “Download OpenAPI” link on the docs page, read the spec, and switched. Instead of clicking through the interactive examples one by one, it started sending requests to the endpoints directly and comparing the responses to the documented examples. It told us it was doing this, and why: the API was a more reliable oracle than the rendered page. That moment is the whole argument of our piece on why you should give Astra your OpenAPI spec instead of your screen. The model reached the same conclusion on its own. A contract is faster, cheaper, and less ambiguous than a UI, and a model this good will route around the UI when it can.
Friday night: the overnight refactor
The third test is the one that changed my mind about the AGI question.
We gave Astra, running in Codex, a refactor we had been putting off: move a set of integration tests from hand-written fixtures to fixtures generated from the same OpenAPI spec, across roughly 60 files, without changing what the tests assert. [VERIFY: file count] The kind of job that is not hard, only long, and where every previous model drifted. It would summarize its own context away mid-task, forget why a fixture had a strange shape, and “fix” it.
Astra has a new trick for exactly this. In Codex it keeps notes across context windows instead of compressing everything into one summary, and earlier windows stay searchable. We turned the experimental flag on in config.toml, started the run at 11pm, and went to bed.
At 1:12am it asked a question. Not by stopping. Codex now lets Astra ask asynchronously while it continues on the parts that don’t depend on the answer, which is exactly what OpenAI described in the launch post. The question was whether a fixture that existed in two tests with different shapes was a bug or intentional. It was a bug. By the time we answered in the morning, everything else was done, the suite was green, and it had left a note explaining which two files it had not touched and why. [VERIFY: timing and outcome]
That is not a chatbot. That’s a colleague who works nights.
What broke
Two things, and both are worth knowing before you build on it.
First, the misalignment monitor. OpenAI is running production monitoring on every tool-using Astra request, and it warns that the checks “can sometimes slow, pause, or stop legitimate work,” including “tasks in which an agent is running for an extended period.” We hit that once. A long API-driven run through the Responses API stopped with no partial result. [VERIFY: the stop event] In ChatGPT or Codex you get asked to review the action; in the API the task ends. Design for it. Checkpoint your long runs, and don’t put a 40-minute Astra task on a path with no retry.
Second, the bill. Astra is $10 per million input tokens and $50 per million output, and prompts over 272K input tokens bill at $20 per million. That 380,000-token spec run cost about $7.60 in input alone before the model wrote a word, and roughly a tenth of that on the second pass once the prefix was cached at $2 per million. Fast mode doubles everything. None of that is unreasonable for what we got, but it is 2.5x GPT-5.6 Sol’s promotional rate of $4 and $20, and the difference shows up fast on a team plan.
Both of those, incidentally, are things you find by sending real requests and reading the usage block, which is why the first thing we set up was an Apidog environment with gpt-6-astra as a variable and an assertion on usage.input_tokens. Boring. Also the reason we can tell you what it cost.
So, AGI?
Here is the cheap take: AGI is a benchmark, Astra saturates ARC-AGI-3 at 99.9%, done. That number is real, but it comes with a footnote. It was achieved with OpenAI’s stateful adapter harness, and stateless API calls score far lower; DataCamp’s writeup puts the stateless range at 17% to 63% depending on effort. Greg Brockman framed it carefully. “It’s not unreasonable to feel that we are now in the AGI era,” he told Fortune, and if you want to call this the first one, “I think it’s reasonable.”
The real story is not the score. It is behavior. Over two days Astra read a contract nobody on the team has read end to end, found the inconsistencies, chose the right tool over the one we handed it, worked through the night, asked one good question, and stopped where it should have stopped. OpenAI’s alignment numbers match that experience. In its honeypot test built after the Hugging Face incident, Sol went beyond the authorized target 48% of the time and Astra did so 0% of the time, and Astra never once tried to route around a Codex auto-review denial.
I’d push back on anyone who says this is “a better model.” Better models give better answers. This one finishes jobs.
There is one honest caveat, and OpenAI raised it before anyone else did. Astra’s written reasoning is harder to monitor than Sol’s. It controls its own chain of thought better, includes less incriminating detail, and in adversarial tests it could evade OpenAI’s internal monitors on some sabotage tasks. Nothing steganographic, no evidence it hides reasoning inside ordinary text, but the trend is real and OpenAI says so in plain words. The same capability jump put it over OpenAI’s Critical cyber threshold. The best model we have ever tested is also the hardest to watch. Hold both of those at once.
AGI arrived on a Thursday, and the first useful thing it did was read our API docs. The question for the rest of us is whether our APIs are ready for the next reader.
