GPT-6, Astra, is powerful as hell. In my own tests, it’s a crazy step change in performance. There is also a geekier ongoing debate about whether Astra is as powerful as it is because of a new way for LLMs to think: internal reasoning.
I am in the camp that thinks internal reasoning is real and gives us another dimension for making models more powerful, and I will explain why, but as always, I find the implications the most interesting part.
Disclaimer: this is likely going to be one of my long posts that I use to really understand a concept. If you want to get to the conclusion, just skip to the implications.
What does it mean that a model is thinking?
Before o1-preview came out in September 2024 (it feels so long ago), the main way we made models more powerful was to give them more capacity, more data, and more training compute. That still works today; it’s one of the scaling laws, and it is a big part of why labs keep building larger training clusters.
Then o1 showed that giving models time and space to think - instead of spitting the next token, they used those tokens to prepare a response - improved their accuracy. This is what we usually mean when we talk about reasoning models. OpenAI’s original release showed performance improving with both training compute and time spent thinking.
Source: OpenAI, Learning to reason with LLMs, September 2024. The chart on the right shows the benefit of more compute at test time.
That extra compute can go into a longer attempt or into several attempts that the system compares. I think of these as vertical and horizontal scaling, often called sequential and parallel test-time scaling. Vertical means giving the model more time to work through a solution, much like a person spending longer on a problem.
Horizontal, on the other hand, means trying several possible solutions and comparing them. Exploring different branches of the problem, trying new things. Those attempts can run in parallel (for example, through sub-agents), although trying another approach can also happen within one long chain of thought.
Since then, longer attempts and more attempts have become familiar ways to improve reasoning systems. With Astra, I suspect more of that work is happening before the next token is produced.
External vs. internal thinking
When teachers at school taught my daughter to read, they taught her to read with an “external” voice and an “internal” voice. Out loud, or in silence (bear with me).
o1-style reasoning works like that external voice. For a model, thinking out loud means producing tokens, the small pieces of text that make up its words. Prompt the model with a problem, and it starts spitting out tokens. Some go into planning (“To solve this problem I should…”), some into calling tools (“call web fetch to look at this document...”) and gathering evidence (“read document Y”), some even into checking its own work (“does this make sense?”). Then, when the model is comfortable (or hits the limit we introduced), it starts producing tokens for the final answer.
Teaching models to do this means training them to find useful ways of reaching an answer. Pre-training gives them a foundation; reinforcement learning can reward strategies that lead to better solutions.
Because this thinking is expressed in text, whoever has access can read it and look for problems. That helps us correct, interrupt, or limit what the system does. That also helps us build the infrastructure (harnesses in the industry jargon) that makes a model an agent. The text has never been a complete view of its computation, but it gives us something to inspect.
Introducing internal thinking
I have not found confirmation from OpenAI that Astra uses an internal reasoning loop. This is my interpretation of the evidence.
Going back to my daughter’s reading lessons, internal thinking would be closer to using the internal voice. The model could work through intermediate steps in its own computational state, without turning each one into a token. That is what I mean by internal thinking.
More technically, one way to do this is to let the model spend compute time in a loop through some of its inner layers. The trained weights can stay fixed while the information passing through them changes. This is similar to giving the model more layers to work through, except that it reuses the same layers, which theoretically should allow it to improve performance while reducing memory consumption (an expensive commodity nowadays).
There is research on recurrent depth from before Astra. The question is how far a frontier model can take it.
With this kind of internal thinking, a model can improve its performance while maintaining or reducing the number of tokens it produces. Which is my first clue about Astra.
In OpenAI’s release results, Astra scores 59.3% on Agents’ Last Exam, compared with 55.5% for Claude Opus 5, while using approximately 65% fewer output tokens at those settings. Better results, substantially less text. That fits the idea, although it does not establish that an internal loop caused the improvement.
Aside: does using fewer tokens mean the model is cheaper for OpenAI to run? My intuition tells me internal reasoning makes tokens per successfully completed task a less reliable measure of the work. Internal computation still needs energy, so joules consumed per token could change quite a bit. Fewer tokens alone do not tell us how much the lab saves. Relevant to you? Probably not, but fun to think about.
The second piece of evidence is more striking. In the Astra system card, OpenAI reports that Astra can complete substantially harder tasks without chain of thought, including tasks where reasoning cannot be moved into tools or a long answer. UK AISI measured a no-CoT math time horizon of 30.9 minutes, versus 3.6 minutes for Sol, about 8.6 times higher. Those minutes measure task difficulty in human-time terms; they are not the model’s thinking time.
So, is internal thinking a new thing? It depends. Models produced useful answers before we called them reasoning models. If a model answered 10281² correctly, had it seen that calculation in training, or did it know how to calculate? One answer cannot tell us. My intuition is that there has been a bit of both memorization and generalization.
What I suspect is new at this scale is a more deliberate effort to get useful reasoning out of internal computation, with less dependence on writing the process down. And some of the implications are scary.
What are the implications?
As we established, with external thinking, the model produces intermediate tokens before the final response. With internal thinking, it works through changes in its computational state without writing out each step. Both can work together. The question is what happens as more of the work moves inside.
Two big implications: safety and harnesses.
For safety
Let’s start with the scary one. One useful way to monitor reasoning models has been to analyze their chains of thought. That can give us evidence that a model is trying to deceive us or is finding a way to pass a test without doing the intended work. OpenAI has shown this with reward hacking, where models learn to exploit the way their performance is scored.
If fewer of those steps become tokens, we have less to read. How do we tell whether the model made an honest mistake or deliberately gave us the wrong answer? We can still check actions and results, but the explanation was another useful source of evidence.
The system card reports weaker CoT monitorability for Astra across most tested lengths, although action-only monitoring improves. It also reports stronger covert sandbagging, meaning deliberate underperformance, when the model is explicitly instructed to evade detection. OpenAI says, “we would likely be unable to catch it reliably.” That is a prompted test, not evidence that Astra spontaneously does this in normal use.
To me, training models to reason more internally while our ability to monitor that computation lags behind is a risky endeavor, especially given how powerful these models already are and especially since we do not seem to have found an asymptote for performance.
If more of the reasoning happens inside the model, our monitoring needs to reach further inside too. That is why mechanistic interpretability becomes more important: studying the model’s activations and internal mechanisms to understand how it reaches an answer. Having access to those signals does not mean we know how to read them, but we need to get better at it.
For harnesses and competitive advantage
The same visibility problem matters when you are building an agent. Your harness has to manage the model’s work, but it can only use the information the provider makes available. There was already a gap here before Astra.
In the early versions of OpenAI’s reasoning models, the raw chains of thought were hidden from users. The o1 release listed user experience, competitive advantage, and monitoring among the reasons. The model could be “thinking out loud” in tokens while we only saw a summary of what it said. Keeping those chains private also protects useful training material. Distillation means using a larger model’s outputs to train a smaller one, which is why access to good reasoning examples has commercial value. DeepSeek-R1 and its distilled models showed how valuable that could be.
As reasoning models became more capable of using tools, model harnesses became the thing (to the point that everyone is building their own!). A harness is the framework around a model that helps it work toward a goal: which tools it can use, what context it receives, how it gets feedback, and when to return control to the user.
OpenAI’s explanation of the Codex harness describes how this surrounding software manages the interaction between the user, model, and tools.
Getting a task done properly depends on how well that framework manages the process. It can monitor tool calls, check results, and control permissions. Where reasoning text is available, it is an important source of information.
With more internal thinking, models can become more of a black box for those harnesses.
The ARC-AGI-3 results show how much the surrounding framework can matter. Astra’s best observed Semi-Private score went from 62.7% with the Standard harness to 99.9% with the Provider Adapter harness. The adapter, not surprisingly, preserves opaque reasoning state between requests and uses compaction to manage the conversation. Across the 167 game/reasoning pairs that both setups solved, it also used 49% fewer total tokens. Better performance and less text, from changing how the same model carries its work forward.
The same model, with different ways of carrying its work forward. Source: ARC Prize.
An external harness can use provider features to get much better performance. But preserving that opaque reasoning state, and looking into it, means AI builders play in their home court.
The lab controls the inference system and can potentially inspect signals that an external developer never receives. We can control what the model is allowed to do, but we may have much less visibility into how it reached that decision.
As has happened in the last two years, I expect open-weight models to bring more of this capability to everyone. But monitoring internal thinking will also demand code and methods for inspecting and controlling internal model states, something that is not trivial. In the meantime, the labs’ advantage can compound.
That said, I think Astra is a step change in models. I am excited about what it lets us do. But as it gets better at using its “internal voice,” I want us to get better at understanding what happens when we can no longer hear the steps.