ReadMultiplex.com: The Terminal Dies: Flapping Airplanes Returns the Silicon to the Metal and Leaves OpenAI and Anthropic as the New IBM
45 minAudio
Got something to say to this podcast? Send a voicemail, and you might hear yourself on the next episode! Flapping Airplanes, founded in late 2025 by Ben Spector, Asher Spector, and Aidan Smith, announced a $1 billion Series A on October 21, 2026, co-led by Index Ventures and Lux Capital at a reported $6 billion valuation. The round followed a $180 million seed nine months earlier that valued the company at $1.5 billion. The lab has no commercial product, no public benchmarks of its current system, and a team described as a couple of dozen people working in person in San Francisco. Nvidia is among the investors. The founders state that demand for AI will outpace supply of data and compute, and that efficiency in both will determine who can put capable systems into the economy. I built Qfresh in 1987 on an IBM PC in a garage. The machine refreshed DRAM on a fixed schedule that left cycles unused. I wrote a TSR that moved the refresh into those gaps. On the workloads I measured the gain reached about 50 percent. IBM preferred the standard timing. I published the code. The silicon already held unused capacity once the refresh boundary was removed. That measurement has stayed with me. Local machines, custom layouts, and the refusal to treat a vendor schedule as final still occupy the same bench. The work that follows from Flapping Airplanes sits on the same premise: the GPU already contains idle time that can be recovered if the launch boundary between kernels is removed. ThunderKittens, the framework Ben Spector co-authored in 2024 at Stanford’s Hazy Research group, supplies the prior technical record. It defines 16-by-16 matrix tiles that match the size of the tensor cores, templates that overlap asynchronous loads and stores across warps, and grid-level mechanisms that hide block launch and teardown. On H100 hardware the kernels matched cuBLAS and FlashAttention-3 on forward GEMM and attention. They outperformed the strongest baselines by 10-40 percent on attention backward, 8× on state-space models, and 14× on linear attention. A single 40-line GEMM kernel competed with cuBLAS. The paper and code are public. The numbers come from the authors’ benchmarks on the hardware available then. Tensor cores supply roughly 16× the FLOPs of general-purpose compute on those chips; kernels that leave them idle forfeit most of the machine. Read more at: ReadMultiplex.com Support this work by buying us a coffee: https://ko-fi.com/brianroemmele
Audio and video play straight from the show's own hosting. PodSubs stores and serves no media.
Transcript
From the show. Tap a time to play from there.
I want you to picture a scenario for a moment. Just imagine it's October 2026. Okay, I'm picturing it. We are in a room in San Francisco. There are maybe, I don't know, two dozen people sitting at desks, just working in person. A pretty small setup. Exactly, very small. And if you look around, you will not see a commercial product. Like, there is no sleek hardware sitting on a table anywhere. No fancy prototypes. Nope. No enterprise software suite being demoed on a big screen.
And if you check online, you will not find any public benchmarks for whatever system they are supposedly building. They're basically a ghost online. Yeah, they don't have some massive GitHub repo with millions of stars for their flagship product. But this company, a startup called Flapping Airplanes, just closed a Series A funding round. And this wasn't just a standard round. No, it wasn't. They didn't just raise like a few million. They raised $1 billion in cash. Which is astronomical.
I mean, even by the crazy standards of Silicon Valley hype cycles. Seriously. And that billion dollars came at an almost unbelievable $6 billion valuation. So a billion dollars handed over to a two dozen person team with literally no product on the market. Right. It's wild. But before we unpack this billion dollar mystery, a quick reminder. This is the Read Multiplex podcast. Support Brian's work, buy him a coffee, or become a member. Definitely go do that. But let's get right into the mission of today's deep dive for you guys listening.
We are exploring a fascinating thesis today based on some incredibly dense source material we've got. Oh yeah, very dense. And it's a thesis that makes a very bold, almost, well, heretical claim. Heretical is a good word for it. The claim is that the current undisputed kings of AI, Companies like OpenAI and Anthropic, you know, the absolute titans of the space, are on the verge of becoming the quote unquote new IBM. Right. And they are going to become the new IBM because they are
getting entirely bogged down by their own massive sprawling infrastructure. Which completely challenges the fundamental orthodoxy of like the last five years of AI development. It really does. Because right now the prevailing wisdom is scale. Just pure brute force scale. Build bigger data centers. Exactly. Buy hundreds of thousands of accelerators, secure massive energy leases, maybe even invest in nuclear power plants. Yeah, we've seen those headlines. Right. But the core theme we're analyzing today suggests that the future of AI might not actually be about building those bigger data
centers at all. Wait, really? Then what is it about? Well, the source material argues that the true bottleneck isn't the lack of raw compute power. It's the software paradigms we use to manage that power. Interesting. The future might be about squeezing every last drop of unused potential out of the silicon we've already built. By doing what exactly? By completely removing artificial software boundaries that we didn't even realize were holding us back. OK, let's unpack this, because if flapping airplanes is
sitting on a secret worth six billion dollars, I mean, we need to understand exactly what that secret is. We do. And according to our sources, to understand why this company is worth so much today, we actually have to travel back in time. Way back. Yeah, we can't start with neural networks or like transformer models. We have to go back almost 40 years. To 1987. Right, to a garage in 1987. Just to look at a very specific piece of hardware philosophy. We have to look at the original IBM PC, you know, the machine that largely
defined early personal computing. The beige box. Yeah. The classic beige box. The source text gives us a direct account from the author, who describes building a program called QFresh in a garage in 1987. Okay. And this was running on an Intel 8088 processor inside an IBM PC. But to understand the parallel to today's AI accelerators, we have to get into the physical weeds of how that 1987 machine actually worked. Like at the hardware level. Exactly. Specifically,
how its memory worked. The IBM PC used DRAM, Dynamic Random Access Memory. Okay, so dynamic meaning it's constantly changing, or in this case, constantly forgetting things if you don't actively remind it. That is actually a very literal way to describe it. Oh, really? Yeah. Physically, DRAM stores each bit of data in a microscopic capacitor. You can think of a capacitor like a tiny bucket holding a static electric charge. Okay, tiny bucket. I can picture that. But these buckets are leaky. Hmm. Over a very short period
of time, the charge just drains away. Right. So if the computer doesn't periodically read the charge and top it back up, which is a process called refreshing, the data just vanishes. So the computer has to constantly stop whatever it's doing to like water the plants, so to speak. That's a great analogy. The architecture required a dedicated hardware timer to trigger a direct memory access or DMA controller. Okay. IBM engineered the system so that this refresh happened on a very rigid fixed schedule. Every 15 microseconds, the CPU would essentially be put on pause. Wow.
Every 15 microseconds. Yeah. The DMA controller would take over the bus, read a row of memory, write it back to refresh the capacitors, and then finally give control back to the CPU. So it's constantly interrupting the actual work. Exactly. And the problem the author noticed was that this fixed schedule was incredibly conservative. It left a lot of compute cycles completely unused. Because it was being overly safe? Right. The computer was just sitting there in the dark, waiting for the refresh cycle to finish and dictate when it could work again. So the author looks
at this and says, well, that's a waste. But how do you actually fix a hardware timer? I mean, it's physically wired into the motherboard, isn't it? It is. But you bypass it with software that operates at the lowest possible level. Ah. The author wrote a TSR, a Terminate and Stay Resident program. Wait, what's a TSR? In the days of MS -DOS, before we had modern multitasking operating systems like Windows or Linux. Right, back when you could only do one thing at a time. Exactly. TSR was a program that loaded into memory and
just stayed there in the background, hooking into hardware interrupts. Okay. What this specific TSR did was intercept the timer. It effectively took that memory refresh process and, instead of running it on IBM's rigid schedule, moved it directly into the natural gaps in the CPU's workload. Oh, wow. So it broke the fixed schedule entirely. Yes. It hid the refresh inside the idle moments. So it's like, okay, it's like renting an apartment but realizing there's a whole secret room you aren't using just because the landlord's
floor plan didn't draw a door. That's exactly it. You're paying for the whole square footage. The electricity is already running to that room, but you're only living in half of it because the schematic told you to. So you just decide to knock a hole in the drywall. And the results of knocking that hole in the drywall were staggering. How big of a difference did it make? On the workloads the author measured, this tiny piece of background code delivered a massive 50 % performance gain. 50 %? Just from moving the refresh schedule? Let that sink in. They didn't upgrade the processor.
They didn't add more RAM. They got 50 % more performance out of the exact same physical machine. Just by reclaiming time that the hardware was already experiencing, but the software was ignoring. Exactly. But wait, I have to push back a little here because I don't understand IBM's motivation. I mean, IBM was the undisputed king of computing in the 1980s. They absolutely were. They had the best engineers in the world. Why would they design a system that threw away 50 % of its potential? Did they just not care about the sufficiency back then? Well, it's not that they didn't care.
The author notes that IBM preferred the standard timing. But is this the exact same mistake the big AI labs are making today? Are they preferring standard timing over actual efficiency? Yes, that's the core argument. See, IBM preferred predictability over absolute optimization. Okay, that makes sense for a massive company. Right. When you are building hundreds of thousands of consumer machines, you have to account for variances in manufacturing, temperature, component degradation. Sure. A fixed conservative schedule guarantees
that no matter how hot the room gets or how cheap the DRAM chips are, the memory won't corrupt. So it's foolproof. IBM accepted the 50 % performance penalty as the cost of absolute stability and simplicity in their hardware design. Wow. And the argument the source text makes is that this is the exact psychological and structural trap that OpenAI and Anthropic are falling into right now. That is wild. So we are taking the exact same philosophical approach from a 1987 garage
and applying it to multi -thousand dollar NVIDIA AI chips in 2026. The foundational premise of flapping airplanes is identical to that 1987 QFOS hack. Just on a much bigger scale. Right. The modern GPU, the graphics processing unit, which is the engine driving the entire generative AI boom, already contains massive amounts of idle time. Just like that old IBM PC. Exactly. And that idle time can be recovered if we simply stop treating the hardware vendor schedule or the standard software stack as the final unbreakable
law. Because the silicon already holds that capacity. Yes. You just have to remove the software boundary that is walling it off. Okay, so we have established this philosophy of finding hidden space in the machine. Now, let's look at the actual blueprint that proved this works on modern AI hardware. Right, because they need proof. Because I'm assuming flapping airplanes didn't just walk into a Sand Hill Road venture capital office, tell a cute story about a 1987 DOS hack, and walk out with a billion dollars. Definitely not. They have prior technical records. So we need to talk about something called the launch tax and an incredibly
named piece of software called Thunder Kittens. Yeah, Thunder Kittens is a great name. But to appreciate what Thunder Kittens achieved, we first have to map out the invisible friction slowing down modern AI. Okay. And that friction is the kernel launch tax. The launch tax. Right. When an AI model, say a massive large language model, runs on a GPU, It isn't executing as one monolithic piece of code. It executes as thousands of separate tiny programs called kernels. Let's
pause there for a second because kernel is one of those words that means like five different things depending on who you talk to in tech. Oh, absolutely. We aren't talking about the Linux kernel here, right? No, no. In the context of GPU programming, particularly with NVIDIA's CUDA platform. A kernel is simply a function that is compiled to run on the GPU instead of the CPU. Okay. Think of it as a highly specialized microtask. You have a kernel for matrix multiplication. Right. You have a completely separate kernel for the attention mechanism. Another kernel for
layer normalization. And yet another kernel just for moving memory from one part of the chip to another. So a single inference pass, like just generating one word of text, requires the system to orchestrate thousands of these microtasks in a specific order. Exactly. And the CPU acts as the manager. Okay. The CPU tells the GPU, okay, run the matrix multiplication kernel. The GPU runs it. Then the GPU has to signal back to the CPU, I'm done. So there's a back and forth?
Yes. The CPU says, great, now run the normalization kernel. Every single time one of these kernels is launched, it carries administrative overhead. Like paperwork. Pretty much. The GPU has to allocate registers, set up the execution grid, synchronize threads, and eventually tear it all down when the kernel finishes. Imagine if every time a line cook in a restaurant chopped a carrot, they had to clock out, clock back in, wash their hands, re -read the recipe, and wait for the head chef to specifically authorize them to start chopping
an onion. That is exactly what is happening. That's what our most advanced multi -million dollar supercomputers are doing right now. It sounds absurd when you put it in human terms. The chef analogy works perfectly because the chef's actual chopping time, like the pure mathematical compute, is incredibly fast. Right. GPUs are fast. The GPU is an absolute monster at math. But the administrative overhead of clocking in and out is destroying their throughput. So what happens during that downtime? That's the tragedy here. What happens inside the GPU while all this
kernel launching and tearing down is taking place, the actual compute engines, which on modern NVIDIA chips are called tensor cores, are just sitting there idle. Just doing nothing. Nothing. They're waiting for dependencies to resolve. They're waiting for the CPU manager to finish its paperwork. And these tensor cores are the expensive part of the chip, right? Like that's what everyone is paying tens of thousands of dollars for. They are the beating heart of the AI revolution. A standard CUDA core on a GPU is good at general -purpose parallel math. Okay. But a tensor core
is a highly specialized piece of silicon designed to do one thing with terrifying efficiency, multiply and accumulate matrices. And that's what AI runs on. Exactly. To put it in perspective, the source text notes that tensor cores supply roughly 16 times the floating point operations, the flops. of the general purpose compute on an NVIDIA H100 chip. Wait, 16 times? Yes. So the vast, vast majority of the actual computational muscle on
the chip is locked up in these specific cores? It is. So if your software stack is designed in a way that leaves those tensor cores idle while it manages administrative kernel launches or waits for memory to slowly trickle in, you are literally... forfeiting the vast majority of a multi -thousand -dollar machine. Oh, man. You're paying for a Ferrari and driving it in a school zone because your software forces it to stop at every crosswalk. Which brings us to Thunder Kittens. Yes. This is the 2024 Stanford
framework co -authored by Ben Spector, who is now one of the founders of flapping airplanes. That's him. This was the proof of concept that you could bypass the crosswalks. In 2024, out of Stanford's hazy research group, Thunder Kittens provided the undeniable open -source technical record that you could bypass this massive inefficiency. How did they do it? Well, they didn't write a new model. They wrote a new way of talking to the hardware. And it went incredibly granular, matching the software directly to the physical reality of the chip. What does that mean in practice?
Like, how do you match software to physical reality? It comes down to understanding the physical dimensions of the silicon. The Thunder Kittens framework defined 16 by 16 matrix tiles. Why 16 by 16? Because that perfectly matches the physical hardware layout of the Tensor cores on an NVIDIA GPU. I see. Instead of writing abstract code that the compiler has to awkwardly squish into the hardware, they wrote code shaped exactly like the hardware. So they basically built a kitchen where the cutting boards are exactly the size
of the chef's knife span, so no movement is wasted. Exactly. And they went further. They created templates that overlapped asynchronous memory loads and stores across warps. Let's slow down there. Asynchronous memory loads across warps. I know, it's a lot of jargon. I know a warp in NVIDIA terminology is a group of 32 threads that execute instructions simultaneously, but what does it actually look like when they work asynchronously versus synchronously? Let's use an analogy. Are
we talking about a relay race versus a three -legged race? The standard synchronous approach is like a relay race where the entire team has to wait for the baton. Okay. A warp of 32 threads needs data from the main memory. It requests the data, and then all 32 threads just sit down and wait for the data to arrive. Just twiddling their thumbs. Once it arrives, they stand up, do the math, and then request the next batch of data. Sit down, wait, stand up, compute. That sounds terribly inefficient. It is. Asynchronous memory loading completely changes the paradigm.
Instead of waiting, you have multiple warps operating in a staggered rhythm. How does that work? Warp A requests data. While Warp A's data is traveling over the memory bus, Warp B is already computing on data it received a microsecond earlier. Oh, so someone is always working. Right. When Warp B finishes computing, it requests its next batch of data. And right at that exact moment, Warp A's data arrives and it begins computing. So there's no downtime. You are hiding the latency of memory transfers behind the computation of other threads. The tensor cores never stop firing.
The chef never clocks out. The ingredients are just asynchronously tossed to them while they keep chopping. Perfectly said. And the numbers from the source text backing this up are absolutely mind -blowing. They really are. The Thunder Kittens kernels match the absolute industry gold standards, NVIDIA's own kublas, and the famous Flash Attention 3 on standard forward passes. Which is already impressive. But then on the attention backward passes, which are notoriously difficult, they outperformed the strongest baselines by 10 to 40 percent. Huge gains. They were eight times
faster on state space models and an incredible 14 times faster on linear attention. 14 times. We are talking about a tiny 40 line kernel written by academics competing with and beating massive corporate code bases maintained by armies of engineers at NVIDIA and Google. And the most vital takeaway here is that. They didn't invent new hardware. Right, no secret chips. They didn't fabricate a magical new chip in a secret laboratory. They used the exact same off -the -shelf GPUs everyone else had. That's the crazy part. They
just organized the work to perfectly fit the physical reality of the silicon that was already there. They measured the idle intervals, just like the QFresh author measured the DRAM refresh caps. And they removed the software boundaries creating those intervals. Okay, here's where it gets really interesting. Thunder Kittens was an amazing academic proof of concept. Yes. But writing a fast 40 -line kernel for one specific operation doesn't build a $6 billion company. No, it doesn't. Flapping airplanes took that academic success and they scaled it into a total
paradigm shift. They evolved the concept of the optimized kernel into something called the mega kernel. This is the architectural leap that justifies the valuation. The mega kernel. The mega kernel takes the philosophy of Thunder Kittens. You know, eliminating administrative overhead and matching the hardware. And applies it to the entire generative AI system. How is that different from what everyone else does? Instead of launching thousands of separate kernels for all those different tasks we talked about earlier. Yeah. Flapping
Airplanes has collapsed the entire execution schedule inside one single monolithic long -running program. A mega kernel. A single kernel launch. Because it is one continuous program, the GPU can overlap memory -bound work with compute -bound work across the entire lifecycle of the model, without ever giving control back to the host CPU. I want to make sure I'm wrapping my head around this. Because normally the CPU is the boss giving orders to the GPU for every single step. Yes. Do step one, okay now do step two,
okay now do step three. You're saying the mega -kernel cuts the boss completely out of the loop. Entirely. The CPU... launches the mega kernel once, and then the GPU essentially secedes from the host system. It goes rogue. Kind of. The GPU manages its own schedule internally. To accomplish this, the team built what is described as the KVM, the Kitten's Virtual Machine. Kitten's Virtual Machine. It sounds so non -threatening for a piece of software that is trying to dethrone the biggest tech companies on Earth. It does
sound cute. What actually is it? How do you run a virtual machine inside a GPU? Well, in traditional computing, a virtual machine lets you run an operating system inside another operating system. Right, like running Windows inside a Mac. Exactly. The KVM is a persistent runtime environment that takes over the GPU entirely. It exposes its own instruction -based programming model directly to the hardware. Okay. But its main trick, the real magic, is how it handles memory. The KVM can co -pack completely independent workloads
into the same kernel. Co -packing independent workloads, meaning it's doing different tasks at the exact same time without separating them. Yes. How do you trick the GPU into doing that? Don't different tasks overwrite each other's memory? In a traditional stack, yes. If you run two different kernels, they have separate address spaces to prevent them from crashing into each other. Right. But setting up those separate spaces takes time. The KVM forces the hardware to share the exact same address space, the same ultra -fast registers, and the same interconnects continuously.
That sounds dangerous. It operates like a highly choreographed dance. Because the KVM is fully aware of the physical layout of the chip, down to the individual 16x16 matrix tiles, it can weave different operations together. Ah, I see. While one part of the model is waiting for memory, the KVM instantly swaps in a different operation to use the idle tensor cores. It maintains sustained maximum occupancy. And we have the measured gains from the source text to prove this isn't just theoretical. The numbers are real. These are
secondary accounts of their earlier mega kernel work, but the numbers are wild. On an NVIDIA H100 chip running standard open source frameworks like VLLM or SGLang, the memory bandwidth utilization is an abysmal 50%. Half of it. Half of it. It's gone. The very thing that usually bottlenecks these models is just wasted. But running on the mega kernel for a LAMA 3 .2 1 billion parameter model doing single sequence generation. That utilization shot up from 50 % to 78%. And the
actual inference speed was more than one and a half times faster. And it scales up to much larger models, too. Does it? The source mentions later work on a massive LAMA70B model using a related framework called Tokasaurus. Tokasaurus. Another great name. Which showed end -to -end throughput more than 22 % higher than the strongest baselines in SG Lang. But the most staggering detail in this entire document is a post from one of the founders. Oh, this part. They stated that this framework has already been used for trillion parameter scale pre -training inside
a single mega kernel. That is the line that should keep hardware engineers up at night. A trillion parameters. Pre -training a frontier class model inside one single kernel launch. That completely breaks the standard architecture of how AI is built today. I mean, normally training a trillion parameter model requires a supercomputer choreographing millions of kernel launches across thousands of GPUs over several months. It's a logistical nightmare. To say you can collapse that orchestration into a single persistent runtime. I mean, that
brings us to the giants in the room. The open AIs of the world. Right. If this startup, this two dozen person team in San Francisco can get vastly more power out of a single chip. What does that mean for open AI and Anthropic? It changes their whole value proposition. Because they are currently spending tens of billions of dollars buying up hundreds of thousands of these chips. Are they building dinosaurs? Are they just constructing massive, expensive, inefficient monuments to the old way of doing things? This brings us to the core thesis of the new IBM. Right, the title of the piece. OpenAI and Anthropic
are operating under what the text implies is the trap of cloud -scale thinking. Okay. They have achieved incredible things, but their business model is entirely predicated on scaling horizontally. Meaning just adding more hardware. Exactly. They're scaling by purchasing more of the same accelerators, securing more massive data center leases, negotiating for more megawatts of power from the grid and hoarding more of the same massive training data sets. Because that's what worked for GPT -3 and that's what worked for GPT -4. Precisely. Or
I should say, that's the established playbook. Their entire software stack, which relies on standard frameworks and traditional CUDA implementations, assumes that kernel launch overhead, the strict separation of training and inference, and the absolute necessity of massive cloud data centers are fixed, unavoidable costs. They just accept the friction. They accept the 50 % utilization rate because they believe the only way to get more intelligence is to plug in another GPU. They're acting exactly like IBM in the 1980s.
Exactly. IBM assumed that mainframes and fixed, rigid hardware schedules were just the way computing had to be. They couldn't imagine that a guy in a garage tweaking the DRAM refresh rate could change the economics of computing. The parallels are striking. OpenAI and Anthropic now occupy the market position IBM held when the personal computer arrived. They're the incumbents. They have the capital, they have the market share, and they have the institutional momentum. Flapping airplanes, on the other hand, treats all of those
fixed assumptions as the actual problem to be removed. But I've got to play devil's advocate here. Go for it. Buying more data centers is a proven model. OpenAI is the undisputed heavyweight right now. Their models work beautifully. They do. Their brute force scaling laws have held up for years. Every time they add more compute, the model gets smarter. Isn't the $6 billion valuation for a company with no product just a massive, incredibly risky gamble that efficiency can beat brute force? It is a massive gamble. I mean, couldn't OpenAI just hire 500 engineers
to build their own megakernel? They could try, but it's a calculated bet based on physical and economic limits. The $6 billion valuation isn't pricing a current product. What's it pricing then? It prices the possibility that the next major leap in AI capability doesn't come from signing another multi -billion dollar data center lease. Because we might run out of power. Exactly. The grid power literally might not exist to support the next generation of brute force scaling. The valuation prices the possibility that the next
leap comes from finally utilizing the installed silicon to its full potential. The chips we already have. Right. The capital. That billion -dollar Series A has already moved to bet on this efficiency. And regarding OpenAI just copying it, you run into the innovator's dilemma. How so? When your entire billion -dollar infrastructure and your thousands of engineers are optimized for the old stack, pivoting to a megakernel architecture requires tearing down everything you've built. It's hard to change the engines while the plane
is flying. Very hard. And there's another layer to this bet that is even more profound than just saving money on GPUs. It's about the data itself. The source material talks about the sample efficiency. Holy grail. This is where the hardware efficiency translates into actual intelligence. OK, tell me about sample efficiency. The founders of flapping airplanes have set a very specific target. They estimate that human beings are roughly 100 ,000 to 1 million times more sample efficient than current AI models. Meaning a human toddler can
see one picture of a cat, maybe have their parent point to it and say cat. And from that moment on, the toddler forever knows what a cat is. Yes. But an AI needs a data set of hundreds of thousands, if not millions of cat images from every possible angle just to learn the same concept. The human brain is a marvel of sample efficiency. Clearly. The AI requires a... brute force amount of data because its architecture currently is highly inefficient at extracting the underlying concepts and rules from a single exposure. It's
just memorizing patterns. Right. Flapping airplanes treats this million -fold gap not as a permanent biological advantage, but as an engineering target. But how does a mega -kernel help an AI learn what a cat is faster? By freeing up compute cycles. Walk me through that. If you reclaim 50 % of the GPU's time that was previously wasted on launch taxes and memory bottlenecks, you don't necessarily just use that time to spit out the next word faster. What do you use it for? You can use those free compute cycles to run richer, more complex internal architectures. You can
run vastly more internal experiments during the forward pass. Like it's contemplating the data? Exactly. You can allow the model to think longer about a single piece of data before moving on. If they can use their hardware efficiency to close even a fraction of that sample efficiency gap. If they do that, the whole paradigm collapses. The capital and the data required to build a capable AI would plummet drastically. Because you wouldn't need a massive data set anymore. You no longer need to scrape the entire internet, which we are running out of, by the way. Right,
the data wall. And you no longer need to spend a billion dollars on compute to train a frontier model. If a model can learn a concept from 10 examples instead of 10 ,000, the barrier to entry for building superintelligence drops out of the cloud and into the garage. So we have solved the hardware bottleneck, or at least Flapping Airplanes believes they are on the verge of solving it. We have a path to sample efficiency. Yes. But doing so breaks something much older than the AI boom. It breaks a fundamental contract of computing that has existed since the very
first teletype machines. This is a huge shift. The source text calls this the death of the terminal, and this is the part of the deep dive that really messes with my head. This is where the hardware evolution forces a deep philosophical shift in how humans interact with machines. How so? If we trace the history of computing, from the early days of the ENIAC with punch cards, to teletype machines printing on endless rolls of paper, to cathode ray tubes, to the glass terminals of the 1970s, to... graphical consoles, and all
the way up to modern AWS cloud dashboards, they all share one fundamental, unquestioned requirement. Human readability. Exactly. The intermediate states of the machine, the file systems, the process schedulers, the network logs, the error reports, were all meticulously written and formatted so that a human operator could read them, monitor them, and intervene. Computers were designed to explain themselves to us at every step. Yes. They had to pause what they were doing, translate their internal binary states into English strings,
and print them on a screen so we could feel like we were in charge. The contract was transparency through human readability. Logs are formatted so a person can understand them. Right. When a server fails, a systems administrator expects to be able to open a text file and read a timestamped error message explaining what happened. But flapping airplanes, mega kernel architecture absolutely shatters this contract, doesn't it? It shatters it completely. Because the scheduler now lives inside the GPU running continuously inside the KPM. Those intermediate activations no longer
need a human readable form. The cycle does not pause for a human to review a log. Nope. The machine talks only to itself and to the physical world. Let's consider the physical cost of logging for a second. Okay. Translating a high dimensional vector state into a human readable string. Moving it from the GPU memory across the PCIe bus through the CPU into the operating system and rendering it on a monitor takes millions of clock cycles. Just to print some text. In the time it takes to print error 404 on a screen, the megakernel
could have run a million matrix multiplications. Wow. By removing the requirement to log intermediate states, you remove a massive computational anchor. It's like having a brilliant translator working for you. Okay. I like this analogy. Usually they have to stop every five seconds, turn to you, and translate their internal thoughts into English so you can monitor their progress. Right. They spend more time translating their thoughts for you than they do actually solving the problem. If they suddenly realize they can think and act infinitely faster if they just stop translating for you, they just do the work. They just do
it. Input arrives as raw sensor streams or tokens, and output leaves as actuator commands or the next internal state. The terminal, the screen we stare at, becomes nothing more than a debug port. that we only plug into when the machine physically breaks. I'd take that analogy a step further. Oh. It's not just that the translator stops speaking English to you. The translator begins developing their own internal shorthand that is so hyper -optimized for speed that even if you demanded they explain it, the concepts wouldn't map neatly onto human language anymore.
Oh, that's creepy. The machine's internal representations become entirely alien. optimized purely for hardware efficiency. And this leads to another major boundary collapsing, one that is crucial for the future of AI. Which is? The boundary between training and inference. Right, because historically, those are two totally separate phases. Completely separate. You train a model in a massive data center, that's phase one. You freeze its weights, you deploy it to a phone or a server, that's phase two, inference. If the deployed model needs to learn
something new, it can't. You have to collect that data, send it all the way back to the cloud, retrain a new version of the model, and push an update. It is a slow, disconnected loop. But with the MegaKernel, both training and inference run inside the exact same persistent environment. At the same time. Because you don't have to tear down the kernel, and because you aren't logging everything to a CPU manager, a local model running on an edge device can serve a request and learn from it simultaneously. Give me a real -world example of what that looks like. Imagine a robotic
arm sorting recycling on a conveyor belt. Okay, got it. It's running a mega kernel locally. It reaches for a crushed soda can, but its grip slips. Standard error. In a conventional system, it would just log a failure, maybe try again, and eventually an engineer would gather all the failure logs, retrain the vision model in the cloud, and update the robot next week. The slow loop. With the mega kernel, the robot serves the inference request. attempting to grab the can, and simultaneously updates its internal weights based on the immediate tactile feedback
that it failed. It just learns right then and there. It learns continuously, locally, in real time, without checkpointing or shipping data back to a cloud terminal. So where does that leave us? What is the new role of the human if we aren't monitoring the terminal, reading the logs, or manually initiating training runs? Human intervention is pushed entirely to the physical and conceptual edges of the system. The edges. We become the entities that set the high -level goals. We say, sort the recycling. We supply
sparse, high -value labels when the machine is truly stuck. Like pointing out a brand new material it's never seen? Exactly. Or, in a physical system, we are the ones who arrive with a wrench to replace a broken actuator when the machine physically cannot move its arm. We're just mechanics. But the continuous stream of tokens, the massive matrices of activations, the memory transfers, that all stays securely inside the black box of the chassis. The black box. Neither side, human or machine, maintains a running commentary for the other anymore. That is deeply unsettling,
but also incredibly elegant from an engineering perspective. It is. And the source material actually provides a literal blueprint for how a rogue lab can execute this shift and challenge the giants. They call it the 10 places to build highly optimized systems. A very detailed list. Now, we aren't going to just read a list of 10 points. Nobody wants to listen to a PowerPoint presentation on a podcast. I mean, in a deep dive like this. Right. Let's group them. But I think it helps to weave these 10 services into a narrative. Let's group them into three distinct thematic
clusters for you listening at home and imagine how a startup operates under these rules. The first cluster is all about ruthless hardware efficiency. Which covers points 1, 2, 3, 7, and 8 from the text. Exactly. This first cluster is essentially the physical manifestation of the 1987 QFresh hack brought into the modern era. If you are a garage startup trying to beat a trillion -dollar company, you start here. Okay, lay it out. Point one is removing the kernel launch tax, which we discussed at length, using that persistent runtime to recover wasted time.
The mega kernel. Right. Point two is co -packing independent work inside one address space. Right. Forcing the memory -bound phases and the compute -bound phases to share the same long -lived kernel. Utilizing the same registers and interconnects concurrently instead of waiting in line. And point three is treating underused hardware units as free capacity. Like empty real estate. The text advises mapping the actual physical utilization of every single unit on the chip. The tensor cores, the memory accelerators, the NVLink interconnects.
Everything. The philosophy is that anything running below 70 to 80 % sustained occupancy isn't good enough. It is an optimization surface. It is free real estate sitting inside the chip that your competitor is ignoring. 0 .7 is the one that really caught my eye. Building the scheduler into the silicon rather than on top of it. This is the realization of the KVM pattern we talked about. The kitten's virtual machine. Right. By letting the persistent runtime expose its own instruction model directly to the hardware, the
software and the hardware scheduler co -evolve. You stop treating the GPU as a dumb black box accelerator waiting for high -level OS instructions. You treat it as an autonomous engine. Yes. And point eight brings it back to the physical world, which I love. Measure power and thermal limits as first class constraints. This is crucial for small teams. If you are literally in a garage, you might have a 20 amp breaker. You cannot rely on the infinite water cooling and dedicated grid substations of a billion dollar AWS data center.
You'd blow the fuse immediately. You have to optimize for sustained watts per useful token. If you find thermal headroom, meaning the chip isn't running as hot as it safely could, you exploit it. Just like finding those unused DRAM cycles, you push the metal to the absolute melting point. The physical constraints enforce the discipline that leads to the megakernel. So that's the hardware. Now, the second cluster shifts from purely manipulating the hardware to the software evolution. This covers points 4, 6, and 9. Point 4 is what we
just touched on with the robotic arm, collapsing the training inference boundary. The slow loop becomes a fast loop. If a robot can update on the data it just produced without shipping weights to the cloud, the software loop becomes infinitely tighter. You don't need a massive data center if the robots are learning on the job. Right. And point six is the big one we discussed earlier, optimizing for sample efficiency before parameter count. This is the paradigm breaker. Learning like a human toddler instead of a brute force scraper. If you can achieve a 10x or 100x reduction
in the data required for a given capability, you multiply the value of every single watt and gigabyte you already have installed. Because it does more with less. You stop caring about having a trillion parameters if a 10 billion parameter model can learn perfectly from a tiny, high -quality data stream. You compete on the quality of learning, not the volume of memorization. And point nine is fascinating from a business strategy perspective. Publish the primitive, not the finished product. This is how a small
team builds an ecosystem. By releasing open, narrow abstractions like those 16 by 16 Thunder Kittens matrix tiles, they allow other garage labs to build on their own metal. They share the building blocks. They don't release a massive bloated framework. They release the highly optimized blocks. It prevents developers from being locked into closed proprietary stacks that force them to buy expensive cloud compute from the big players. It democratizes the hardware efficiency. Which brings us to the final cluster, the human demotion. The spooky one. Points five and ten. This is
the death of the terminal. Making intermediate states machine -readable only and keeping humans strictly at the goal and failure edges. Point five challenges every dashboard, every log file, and every cloud console that exists today. No more checking the logs. It argues forcefully that intermediate state, the activations, the cache. the optimizer states, should never leave the chassis in human -readable form. Just keep it inside the machine. You replace the beautiful complex dashboard with sparse, high -value signals.
A green light for working, a red light for broken. Simple as that. And point 10 finalizes the architecture. Continuous operation stays inside the box. Inside the megakernel. The ultimate workflow bottleneck in modern AI systems is currently a human reading a terminal to decide what to do next. You remove the terminal, you remove the bottleneck. So what does this all mean? When we look at this blueprint, this staggering $6 billion valuation for a company
with two dozen employees, and this philosophical shift away from human readability, where does this leave the AI industry right now? Well, to summarize the core thesis of the source material, flapping airplanes has not shipped this final world -changing system yet. Right. They still have to prove they can do it on a massive scale. That is the crucial caveat that justifies the skepticism. But they have a massive war chest of capital. They have the undeniable prior open source record with Thunder Kittens, proving the
math actually works on the silicon. The technical record is there. And they have a very clear, ruthless statement of intent. Until they ship it, OpenAI and Anthropic will continue to be the largest buyers of the old, inefficient architecture. They will continue to build the new IBM. Exactly. But the metal, the raw silicon capability is already there sitting idle in the chips we have today. The only question now is who actually finishes the job of using all of it. It is a race to the bottom of the silicon. But as we wrap up, I want to leave you with a final thought
to mull over building on this idea of the death of the terminal. Go ahead. If flapping airplanes is right and we successfully build these mega kernels where machines only output physical actuator commands and internal states. Where they stop talking to us. Right. If we permanently remove the human readable terminal because it slows the machine down, are we inadvertently creating a scenario where AI develops an internal operational language or a logic so deeply optimized and native to the silicon that even if we wanted to plug
a terminal back in one day to see how it thinks, we would be fundamentally incapable of understanding it? It's entirely possible. We might build a machine so fast and so efficient. that its thoughts become completely inaccessible to the human mind. We are actively designing the machine to turn the lights out on us so it can work faster in the dark. That is a chilling thought to end on. That's all for today's Deep Dive. Just a quick reminder before you go, this is the Read Multiplex podcast. Support Brian's work, buy him a coffee, or become a member. See you next time. Welcome
to the multiplex, where the future comes alive. Past, present, future tech, open up your eyes. Brian Romella leads the way with research deep and true. Technology and history, he connects them all for you. Brian Romella leads the way with research deep and true. Technology and history, he connects them all for you. Ancient sparks to modern code, he traces every thread good. Exploration. But human moves on. Love equation
for AI. Zero human companies building from the start. Thermodynamic wages earning the key. Secrets we will read. Experiment in publishing real researches and spending every. Great.
Got something to say to this podcast? Send a voicemail, and you might hear yourself on the next episode! Every cell in your body has lived its whole life inside a magnetic field. The Earth is a dynamo, and it has been...
Got something to say to this podcast? Send a voicemail, and you might hear yourself on the next episode! The 78 RPM Record Hour, Episode 3: From Steel to Hillbilly (Early Country). From steel to hillbilly: Frank Ferera,...
Got something to say to this podcast? Send a voicemail, and you might hear yourself on the next episode! The 78 RPM Record Hour, Episode 2: The Knife and the Steel (Hawaiian). The knife of the blues slide guitar and the...
Got something to say to this podcast? Send a voicemail, and you might hear yourself on the next episode! Somewhere in your house there is a computer you stopped thinking about. Maybe it is a 2017 laptop in a drawer, its...
Got something to say to this podcast? Send a voicemail, and you might hear yourself on the next episode! The 78 RPM Record Hour, Episode 1 (Pilot): Blues. Fourteen original 78 RPM records from 1917 to 1925 that trace...