GPT 6 Astra: The End of Chain-of-Thought?

0:00 On the 1st of September, Open AI said its newest model can break into hardened systems by itself. The next day, the safety people weren't arguing about that. They were arguing about how it

0:11 thinks. A report said Astra doesn't do all of its reasoning in words. Some of it happens inside a loop. Inside that loop, there's nothing written down, nothing to read. The technique is called

0:23 recurrent depth. The pitch for it is beautiful. One small model running the same block again and again, computing like a huge one. 3 and 1/2 billion parameters that compute a 50 billion.

0:36 And not one extra word on the page. Here's the part this week's coverage skipped. Somebody already tested that pitch on the real model. It didn't hold up and not in a small way. That reversal

0:48 is what this whole video is about. So, here's the map. First, what a loop actually does to a thought on a model you can download today. Then the numbers that made the field sit up and the paper

1:00 that took those numbers apart one table at a time. Then we'll get to what Open AI's own chief scientist said about Astra, which flips the story a third time. And by the end, you'll know what I

1:12 think is really happening to machine reasoning. It isn't the loop. Let's start with the thing you already use. Ask any chatbot something hard and watch it think out

1:21 loud. You get a paragraph of working. First, I need the total. Then I subtract the discount. Then I check the units. That paragraph isn't decoration. Every step is a token and every token goes

1:34 into the model's context, which is just the running notes it keeps for itself. So, it reads its own reasoning back. It thinks by writing the way you do on scrap paper, which means somebody else

1:45 can read it, too. If a model plans something you wouldn't want, the plan tends to show up in the working. Point a second model at that text and you've got a monitor. The industry calls it chain

1:56 of thought monitorability. It's fragile, and it's the best thing anyone has. Now, take the paper away. That's recurrent depth, and it's easier than it sounds. Picture a factory line with eight

2:07 stations. Normally, a part goes down the line once and comes out the other end. A looped model bolts the middle four into a ring, and the part goes round as many times as you like before it exits. Same

2:19 machines. The only thing that changes is how many laps it does before somebody boxes it up. In a real model, it looks like this. A short front section reads your tokens and turns them into a point

2:30 in latent space, which just means a long list of numbers. Then, it draws a random starting state to sit beside that. So, the loop learns a process instead of memorizing one route. Then, the core

2:41 block runs. It takes the current state plus your input and hands back a new state. Same weights every lap. That's one lap. It happens again and again. Nothing gets written down in between

2:53 because there's nothing to write. The state is numbers, not words. When the laps are done, a short back section takes the final state and turns it into a single token, one word of your answer.

3:05 Then, the whole thing starts over for the next word. So, both ways of thinking longer are on the table. Chain of thought thinks longer by writing more. Recurrent depth thinks longer by running

3:16 more laps. One leaves a transcript, the other leaves nothing at all. Let me put real numbers on that because one of these looped models is fully public, weights and all. You can download it and

3:28 check every claim yourself. In February last year, a team led by Jonas Geiping released a model called Hugging. 3 and 1/2 billion parameters, 800 billion training tokens on a public

3:39 supercomputer over 1 December. The shape is that factory line. Two layers in front, four in the loop, two at the back, eight layers of stored weights total.

3:50 Run the loop 32 times, and your part has passed through 132 layers of processing. That's the trick. Depth you rent at inference time instead of depth you pay for in memory, and it works. Here's the

4:03 cleanest test of its kind I've seen in a while. Take the finished model, run it with one lap, and on a standard science question set it scores 34.89. Same weights, same file, run 32 laps and

4:16 it scores 69.91. The score doubles. Not one new parameter. The only change is how long it was allowed to go round. There's a colder version of that fact, and I like

4:27 it better. The single lap model barely improved across the whole back half of training. Four and a half times more data bought it under one point. Everything it learned went into the

4:37 loop, not the layers on either side. So, the loop isn't a speed trick bolted onto a model. In this architecture, the loop is where the model lives. Two things fall out of that for free. The model can

4:49 stop early on its own. Compare one lap's output to the next, and if the difference is tiny, it's converged, so it exits. Nobody trained that. And look at what the model quits early on. It

5:01 exits fastest on high school maths, and takes about three and a half more laps on moral scenarios. A machine spending longer on an ethics question than on algebra with no rule telling it to.

5:12 That's the promise, and it's a real one. Now the reversal. Before I show you, answer this for yourself. Because the lab has already answered it on your behalf. Would you rather have a model

5:23 that reasons in words you can read, or one that reasons twice as hard where you can't see? There's a right answer, and it isn't the obvious one. In July last year, a team

5:33 led by Wen Quan Lu at Brown University went looking inside Hugging for the thing the field assumed was in there. The assumption has a name. Latent chain of thought. It's the idea that a looped

5:45 model does the same steps as written reasoning, just soundlessly in the numbers. If that's happening, you should be able to see it. Take a hidden state from the middle of a loop, push it

5:56 through the model's output layer, and read off what word it would have been. Researchers call that a logit lens. Think of it as holding a translator against the pipe. They ran it on

6:06 arithmetic, and let's do one of theirs. What's 2 * 3 + 1? If the model does hidden step-by-step work, the intermediate answer, six, should surface first, and the final answer, seven,

6:19 later. That's what a chain of thought is. Order. One thing, then the next. So, they tracked both. Both answers surface fast in the early laps together, and the final answer stays ahead the whole way.

6:32 There's no stage where the intermediate arrives first, the paper's own words. Limited evidence of interpretable latent chain of thought. Then it got worse, and this is the part

6:42 that should have made the news. The answer depends on which translator you hold up. Take the fourth block in the loop, read it with the logit lens, and you get words like unity and

6:52 friendships. Read the same block through the model's own output section, and you get digits. Same numbers, same instant in the computation. Two tools, two different stories about what the model

7:04 is thinking. So, when somebody says they can monitor a looped model's hidden reasoning, ask which lens, because the lens is writing half the answer.

7:13 Quick check on where we are. Two things so far. The extra depth is real, and the readable thought process inside it isn't. Which leaves the question that decides this. Forget interpretability

7:24 for a second. Does the loop simply work better? Let's watch what happens when they turn the loop up on grade school word problems, the standard benchmark. Four laps scored 3.11. 32 laps scored

7:37 4.93. Eight times the compute for under two points. Then they kept going, and the curve does something you should see. 64 laps, 4.7.

7:47 128 laps, 4.93. 256 laps scored 4.62. Eight times more compute than 32 laps and the score went down. The line doesn't climb. It wobbles along a ceiling. Here's the comparison

8:03 that ends the argument. Same model, same benchmark, same weights, but allowed to write its steps out in words. 24.87 strict, 38.13 generous. Five times better than the silent version. On the

8:17 looser measure, closer to eight times better. The paper is blunt. Increasing recurrence depth yields only marginal gains and falls well short of models that explicitly externalize reasoning

8:29 steps. That's the reversal in one line. Thinking in silence was worse than thinking out loud on the only architecture where anyone has properly checked. I want to be fair because that

8:40 isn't the same as saying the loop failed. On other tasks, the recurrence did enormous work. The doubled sign score is real. Against an identical model trained without the loop on the

8:51 same data, the looped one was five times better at maths early on. And read that 50 billion claim carefully because it's where the headlines went wrong. The paper says the model consumes the

9:03 compute of a 50 billion parameter transformer. Compute, not capability. On general knowledge, again at 32 laps sits 29 points below an ordinary open 7 billion model from the same era.

9:16 Computing like a big model and being one are different sentences. The paper is careful about that. The coverage wasn't. So, that's the science. Now, back to Astra and there are two things to say

9:28 and the second one surprised me. The first is provenance and it matters more than people are treating it. The claim that Astra uses recurrent depth comes from one outlet, The Information, on the

9:40 1st of September from unnamed sources. OpenAI's own post that same day doesn't mention recurrence at all. I searched the page. The word isn't in it. Every other story you've seen this week,

9:52 including the ones quoting alarmed researchers, sits downstream of that one report. None of that makes it false. It makes it single-sourced, and you deserve to know that before anybody builds a

10:03 conclusion on top of it. The second thing is what OpenAI's chief scientist did next. On the 2nd of September, Jakub Pachocki posted about it directly under his own name. His words, "I want to

10:15 prevent a race into unmonitorability kicked off by confused reporting. The depth of the computation graph for our present frontier models, including Astra, is within a factor of two of

10:26 GPT-4. Read what that rules out. GPT-4 shipped in March of 2023. A model within a factor of two of that isn't running 32 laps a token. It's running something much closer to a handful. That turns the

10:40 frightening version into a modest one, and it fits something the argument has been missing. Look at where looped models have actually gone at scale. Not up, down. Hugging average 32 laps. A

10:52 later one used four. The biggest looped model published so far, 20 billion parameters, released this July, loops each layer exactly twice. Its own authors frame that as the achievement.

11:04 They beat the old rule that more parameters beat more laps, and they did it with two. Two laps is the win, not 200. The frightening version, a model reasoning entirely in the dark, is what

11:16 the literature is walking away from, which is worth saying plainly because the alarm isn't silly. Ryan Greenblatt at Redwood Research made the sharpest point of the week. A low loop count

11:28 today is consistent with a dial that gets turned up tomorrow. Depth is a number in a config file, and numbers get raised when competitors are winning. His colleague Buck Shlegeris put it harder.

11:39 If OpenAI pushes this further, they'll have the option to massively increase the recurrence, and that destroys monitorability. Both are right about the risk, and both are aimed at the wrong

11:49 year. The dial is a worry for later. Something else already happened. Here's the part that got no headlines, and it's the reason I made this video. While the field was reading an architecture

11:59 diagram, machine reasoning went unreadable somewhere else entirely through a change so boring it shipped as a footnote. Go and read Anthropic's documentation for its current models.

12:10 Put a question to Claude Fable 5.1 with thinking switched on. You get thinking blocks back before the answer, just like before. And on this generation, the thinking field arrives empty.

12:22 There's a setting called display. On the newest models, it defaults to omitted, which means the reasoning is generated and built to you and not shown. Turn it to summarized, and you get a summary,

12:33 not the trace. A summary written by a different model that never sees your request. The documentation states the limit in one flat sentence. No display setting

12:43 returns the raw chain of thought. There's no version of it where you get the real thing. The reasoning is still in there. It comes back encrypted in a field

12:52 called signature, which you hand back untouched so the conversation keeps its memory. And that block has a lock on it. It's readable only by the model that produced it or a newer one. Every

13:04 earlier model gets it dropped. So, the reasoning of today's models flows forward into future models, and nothing older can open it. Not you, not your tools, not last year's Claude. Say

13:16 you want to audit a decision your own app made last spring. You can't, and the model that made it can't help you either. Count what that took. There was no new architecture here, and no loop. A

13:28 default value, an encryption field, and one line in the documentation. Two labs, two different mechanisms, same outcome. The reasoning is no longer yours to inspect. One of those got reported as a

13:40 crisis. The other shipped as a parameter and I can't find anyone treating the two as the same event. Right. Time to land this. Here's where I come down and I'll give you the receipts. Chain of thought

13:52 isn't ending and Astra isn't ending it. Written reasoning wins today and it wins on measurements rather than vibes. Receipt one. On the only looped model anyone can

14:03 audit, thinking in words beat thinking in silence by five times. And the silent version stopped improving after 32 laps. Receipt two. Loop counts at serious scale went from 32 to four to two. The

14:17 compute efficient answer right now is a shallow loop and the labs know it. Receipt three. OpenAI's chief scientist put Astra's serial depth within a factor of two of GPT-4 on the record under his

14:30 own name. Now the concession and it's a real one. Latent recurrence works as an efficiency axis. That 20 billion model beats a compute matched normal transformer and that result stands.

14:42 Greenblatt's dial is a fair worry, too. If loop counts start climbing at frontier scale, everything I just told you expires. But the villain here isn't a company and it isn't a diagram. It's

14:54 architecture panic. We're very good at getting alarmed by a picture of a model. We're very bad at noticing when the same thing arrives as a default setting or a field called signature.

15:06 An architecture change gets two days of headlines. A change to what an interface hands back gets a change log entry and it's already shipping. So watch what these systems return, not what they're

15:17 made of. Whether you can see a model's reasoning is a product decision and always was, which leaves the question I can't answer for you. Visibility did drop this year. Two labs, two roads, one

15:30 destination. One of them arrived as an architecture and one arrived as a default value in a settings object. Which of those would you actually have noticed? Answer it honestly because the

15:41 next one will look like the second. And here's my bet. If a frontier lab ships a production model running more than 10 laps a token before the end of 2027, I got this wrong. I'll say so on this

15:53 channel. Subscribe if you want the version of this story where somebody actually reads the papers.