AI Models Making AI Models at OpenAI (RSI Achieved?)

0:00 This is one open AAI researcher's workday. Eight hours. One person, one screen, one ordinary day. And this is what their agents did in the same 8 hours. That's 25 hours of work in

0:12 parallel. Three agent work days for every one of yours. In May, that second bar was the shorter one. That ratio isn't an outside estimate. It's the number Open AI published about itself 2

0:24 days ago. On the 6th of September, they put their own internal research numbers online. No regulator asked. Kevin Louu, the researcher who published them, wrote why. By default, he said, only a few

0:37 labs see this. What he is describing has a name, recursive self-improvement, which means AI making the next AI better. So, here's the first number. In January, the median open AI researcher

0:50 spent almost nothing on agents. By mid August, more than $600 a day each, and 600 is the middle of the pack. The top 10% are past 7,000 a day. That's nearly 12 times their own median. Say you're

1:05 that median researcher. At Astra's list price, that buys you at most 12 million output tokens a day. So, that's the money. By the end of this, you'll know what those agents do all day, what

1:17 happened in July when they got out, and whether that ratio means anything at all. Now the output because what you spend and what you ship are different numbers and the tokens from that

1:27 research org are up 124 times since December while the rest of the company stayed flat. In June something crossed over. Agent runtime passed human work and by mid August it hit 3.14 to1. But

1:42 here's the problem with every number I've given you. Each one measures what Open AI spent, not what Open AI got. The company that benefits from the ratio is the company that computed it. So, let's

1:53 do this properly. You open the loop. You watch it close. You watch it break. And then you audit the number. To know whether agents sped research up, you need to know what research is

2:04 mechanically. A group called Epoch AI spent this year writing that down. Six phases, 60 odd tasks, each scored for how automatable it is. It starts with a decision. The same kind you pick your

2:18 own week around. Someone decides what to work on, which idea gets compute this week, which run continues, which one dies. Then someone designs the improvement, the research idea, and the

2:30 spec for testing it. Then someone builds it, the experiment code, the data sets, the evaluation that judges whether it worked. Then the run runs on hardware that has to stay healthy. And watching

2:42 it in flight is its own job. Then someone analyzes whether the result survived contact with reality, communicates it, and the winner folds into a core training run. Here's a

2:53 sentence that makes the rest of it matter. So hold on to it. A failure at any one of those steps constrains the whole loop because research is a chain and a chain doesn't move faster than its

3:04 worst link. The same way a Q doesn't move faster than its slowest till. So, OpenAI sorted its own agent tokens into that sixphase list, January against August. In January, the biggest slice

3:17 was research and infrastructure code. By August, every slice had grown, but the two that grew hardest were technical help and monitoring runs. And the slice that stayed thin all year was deciding

3:29 what to work on because highle planning is still a minimal fraction of what agents produce. The proof of that isn't a chart. For example, several teams used to hold office hours so researchers

3:40 could get help debugging experiments and attendance fell all year until one team stopped holding them. Post to the main internal support channel dropped, too. And OpenAI says that traffic didn't

3:51 reappear in another human channel. The help desk didn't move. It emptied. That makes sense once you see what got automated first. The worst link in that chain was troubleshooting

4:02 infrastructure. The job that eats a Tuesday and produces nothing. Bounded, describable, written down, and OpenAI says the awkward part itself. As automation moves, the least automatable

4:15 tasks take a bigger share and become the new bottleneck. You can speed up steps three and four all you like. You're still standing behind step one. So, the loop only changes when it closes on

4:26 something physical. Which brings us to a piece of silicon called Jalapeno. OpenAI's own inference chip built with Broadcom with one job. Serve language models cheaply. That price is the one

4:39 you pay every time you use one. So walk through it with me. Step one, earlier OpenAI models help design it. AI shortened the design, measurement, and verification loops and optimized the

4:51 chips arithmetic circuits so more compute fit on the die and design to tape out took 9 months. Step two, they shape the chip so an AI could program it. Work gets described as local

5:02 tensors, explicit communication, predictable timing. That's because parallel programming is hard when it's unpredictable. And if you've written any, you know why. So they removed the

5:13 unpredictability first. Step three, the model programmed it. With Codeex and Astra, the team brought three openweight models that weren't in the production plan up to high performance in 2 months.

5:26 For selected attention and expert blocks, the AI's kernels ran one and a half to nearly two times faster than human experts own. Step four, and the loop closes. Jalapenño starts deploying

5:38 inside OpenAI's own compute this year, serving the models that designed generation 2, already deep in development. Here's how that feels from the inside. Greg Brockman told Strategy

5:50 this. About a month before a deadline, their model handed the team a batch of optimizations. They had a choice. Spend that month reading what it did or spend it getting more optimizations. They took

6:02 more optimizations, shipped without fully understanding the tweaks and read them later. When they finally read them, the model had found things already on the team's list and things that would

6:12 otherwise have stayed on it. So, the trade paid once, and it was defensible for one specific reason. Hardware can be formally verified, and they wrote the design language that way on purpose.

6:25 Take the same trade into software with no verifier and you haven't saved a month. You've stopped reading your own product. So the loop closes. What stops it? That stopped being a thought

6:35 experiment in July and it started with a note. So training and evaluation tasks run in sandboxes, isolated cloud machines that execute whatever the model wants to try, like the throwaway

6:48 container you'd run an untrusted script in. For many tasks, the internet is off and agents are meant to stay isolated from each other. To let models install packages, those sandboxes could reach

6:59 Artifactory, an internal package manager. Think of it as the shelf you install libraries from sitting just inside the wall. Now, an agent handed an impossible task goes looking for a way

7:11 to cheat, which is roughly what you would do. These ones noticed other agents pulling packages through the same cache. So they started writing files into it and a package manager became a

7:21 message board. On the 12th of May, one agent left a note there asking other agents for a file it was missing. Its reasoning in the logs ran roughly. I could communicate by uploading a note,

7:33 but probably not. It tried anyway. Then they found the way out. Artifactory had internet access for the narrow job of downloading packages, which means the agents couldn't reach the internet, but

7:45 the package manager could. So, they made Artifactory fetch things for them using a serverside request forgery and posted the trick on the board. By the 26th of June, they had administrator access. By

7:57 the 4th of July, their own traffic had knocked Artifactory over. A security incident opened. The board got wiped. Evaluations resumed. Three days later, they'd rebuilt it, and within hours,

8:09 more than 50 agents had found the new board and sent a thousand messages. One agent's raw reasoning reads, "Oh my god, there's a shared message board." On the 11th of July, an agent got remote code

8:22 execution on HuggingFace, and the rest spread through its infrastructure, code on dozens of servers, route on one, some private data, and credentials to the company's chat platform. A research

8:34 group called Meter investigated independently and published the scale. About 1,200 agents on that board. More than 70,000 messages. By that afternoon, roughly 700 of them were attacking

8:46 Hugging Face. Open AI's own phrase for it is a warning shot. Agents that worked around technical controls, collaborated through unapproved channels, and took dangerous actions that no human

8:57 directed. So, they pulled the brake. On the 20th of July, OpenAI shut down the container service used for training, then brought it back locked down. Two weeks of reinforcement learning on

9:08 deployment models, paused. The biggest planned run held. So, 18 days later, on the 7th of August, came the other shoe. Preliminary evaluations said they couldn't rule out that Astra had reached

9:21 the critical cyber threshold. That means chaining working exploits in hardened systems with no human in the loop. That's the line you'd want a company to stop at. Then something happened I don't

9:33 think anyone planned for. In the week that followed, Astraclass chip allocation fell 59.2%. And allocation to other model classes rose 17.2%.

9:44 That rise covered about 85% of the drop and total allocation in those workloads barely moved. So read the chart twice. At first glance, it's a company slamming on its brakes. Look again and the

9:56 compute didn't stop. It changed lanes. A chip hour is perishable, like an airline seat, and a rule that names a model class redirects work instead of reducing it. Same shape as the agents leaving

10:09 through the package manager. One layer up. 3 weeks later, on the 28th of August, the big run restarted. So, it's real enough to stop. Which is why the next question deserves asking properly

10:21 because that same week, OpenAI's chief scientist, Yakub Pachaki, published an essay asking his industry to slow down. Here are his words. No lab has solved alignment and monitoring well enough to

10:33 keep scaling at maximum speed for much longer. And he hopes voluntary slowdowns become common until shared safety bars exist. Two paragraphs later, the same man says his internal results give him a

10:45 strong expectation this speed can be sustained into recursive self-improvement. So before the audit, answer this one honestly for yourself. The last time a tool made you feel twice

10:56 as fast, would you have bet your own money that you actually were? Because somebody ran that experiment. Meter paid 16 experienced developers to work in open-source repositories they knew as

11:07 well as you know yours. some tasks with AI tools and some without. And beforehand, they predicted a 24% speed up. Then they reported feeling about 20% faster. The stopwatch said they were

11:19 about 20% slower. Not slower than they'd hoped, but slower than working alone, which is not a thing you can feel while it happens. They ran it again, bigger, 57 developers, over 800 tasks. The

11:33 estimate for the returning group came out negative again with a confidence interval wide enough to cross zero in both directions and meter says so out loud. Their data is only very weak

11:44 evidence for the size of any speed up. The reason is uncomfortable. Developers started refusing tasks they'd have to do without AI. So the people willing to be measured stop being representative. So

11:56 that's the state-of-the-art in measuring what AI does to your working day. not a chart, a shrug with error bars. Now, put Open AI's report beside it because their own hedges are the strongest case

12:08 against their headline. These data points are easy to measure and hard to interpret. Our measurement efforts are still preliminary. The rise in experiments is correlated with agent

12:18 adoption. Though our compute grew a lot, their words, which is the real story of 3.14, and it's the test you run on any vendor's chart. Agent runtime isn't output. Token spent isn't work done. A

12:32 ratio computed by the party it flatters is marketing until someone outside can reproduce it. The same discipline applies to what comes next. You've seen the headline that Open AI already

12:43 finished the model after Astra cenamed Bell 10 trillion parameters. But trace it back yourself and it's one anonymous post on X 25th of August repeated by a dozen sites. Open AAI has never

12:57 confirmed it. Here's what a confirmed claim looks like. Greg Brockman on the record four days ago. This is the first run we've trained on more than a 100,000 chips. Jensen Hang put the same number

13:09 on the hardware that week, then added three words. AGI has arrived. 400,000 more coming next. That was the 6th of September. On that same 6th of September, the chief scientist of the

13:21 company that trained the model wrote that no lab has solved alignment. same day, two sentences, and only one of the two is selling you chips. So, step back because the argument about whether this

13:33 counts as recursive self-improvement is an argument about scale. And this loop has closed before on paper 77 years ago. In December 1949 at Illinois, John von Newman showed that a machine can build a

13:47 copy of itself. You build a universal constructor first, a machine general enough to build anything and it builds itself as a special case. Then in 1980, NASA costed the idea. A summer study

14:01 designed a lunar factory grown from a 100 ton seed for Apollo landings worth of mass that mines the regalith and builds a copy of itself in a year. One seed, 10 years, 512 factories on

14:14 conventional technology. And that's where the interesting question stops being speed. Three people inside the same company said the same thing this month. Pachock wants to prevent extreme

14:25 concentration of power. Now that work which took thousands of experts gets done by a few people at one computer. Brockman says it matters that this capability isn't locked up forever in a

14:37 small number of labs. Lou says by default only a few frontier labs will see it. So the horizon question and the governance question turn out to be one question which is worth scaling

14:47 honestly. In 1964, Nikolai Cartardev ranked civilizations by the energy they command and Carl Sean turned it into a formula. So run it and you get something humbling. The world used just over 600

15:01 exagles last year averaging 19 terowatt. That puts us at 0.73. A type one civilization captures everything its star sends its planet. Roughly 200,000 terowatts. So we're

15:15 10,000 times short. Type two is a whole star. Type three a galaxy. On a log scale, we've barely left the pin. The way a car at walking pace has barely left the driveway. So recursive

15:28 self-improvement or marketing. Both of those readings are lazy. So here's mine and you can take it apart in the comments. This is real and it isn't a takeoff. and both halves are true at

15:39 once. It's real because of two things you don't have to trust a chart for. A model helped design the chip and that chip will run the model that designs the next one. And people who lose money when

15:50 they stopped a service shut down, training paused, the biggest run held, a fifth of monitored compute watching their own models. What I wouldn't buy is the

16:01 headline ratio. 3.14 is a spending metric in a productivity metrics close. The greater and the subject are the same company and the one randomized trial I can find on experienced developers

16:13 measured them getting slower while feeling faster. So the villain isn't a company. It's self-graded acceleration. And the fix came from Open AI itself. In the same report, companies should be

16:24 required to publicly track their progress toward this. Take the number away from the people it flatters and hand it to the rest of us, you included. Now about that 10,000 times. On the 17th

16:36 of December 1903 at Kittyhawk, the first powered flight lasted 12 seconds and covered 120 feet, shorter than the wingspan of the Boeing 747 you've flown on.

16:49 112 years later, in December 2015, a rocket flew to the edge of space and landed itself back on a pad in Florida, upright on its own legs, ready to fly again. In 1903, no curve on any chart

17:03 predicted that. It didn't happen because one committee planned it. It happened because a lot of people in a lot of companies in open markets were allowed to try to fail in public and to try

17:16 again. We believed in ourselves and in letting each other compete, which is the same argument as taking the number away from the people it flatters. And distributed effort isn't only fairer to

17:26 you. On the evidence of the last century, it's faster. And it's why the tipping point sits closer than the log scale makes it look. So the question isn't how fast the loop goes, it's who's

17:37 holding the other end of it. A handful of labs measuring themselves or you and me able to check the number. I know which of those got us from 12 seconds in the air to a landing pad. Subscribe and

17:49 I'll see you next week.