Flapping Airplanes Raises $1B to Collapse Entire AI Training Into One GPU Kernel

AI research startup Flapping Airplanes has closed a Series A before releasing a commercial product. Bloomberg reported the following terms:

The financing backs Flapping Airplanes’ thesis that the GPU should serve as the primary surface for AI research. The company says new low-level GPU primitives can support different training algorithms, improve hardware utilization, and reduce the cost of building and running models.

One kernel, an entire workload

A GPU kernel is a program that runs on the graphics processor. Contemporary training and inference systems can launch thousands of kernels during a model step, with separate launches for matrix multiplication, normalization, attention, memory movement, and other operations.

Each launch adds overhead, while dependencies between operations can leave GPU resources idle. A megakernel combines many operations inside one larger program, allowing an internal scheduler to coordinate computation, memory transfers, and communication without repeatedly returning control to the host system.

CUDA Graphs can reduce launch overhead by recording and replaying operation sequences. Compilers and tools such as XLA, PyTorch Inductor, and Triton already fuse selected operations. Megakernels push fusion further by placing more of the workload and its scheduling logic inside a long-running GPU program.

Flapping Airplanes says its framework can keep an entire training run inside one kernel while concurrently serving inference requests and running a video game. The team has also described a “Kittens” virtual machine that takes control of the GPU and schedules different workloads across it. No public code or benchmark currently allows independent testing of those claims.

Deeper fusion introduces engineering costs alongside possible speed gains. Large kernels can increase register and shared-memory pressure, extend compilation times, complicate debugging, and require architecture-specific tuning. Long-running kernels can also make preemption, failure recovery, checkpointing, and communication across multiple GPUs harder to manage.

A team steeped in GPU systems

Brothers Ben and Asher Spector founded the company with Aidan Smith, a Thiel Fellow and former Neuralink engineer. Ben Spector completed a Stanford doctorate under Chris Ré and founded Prod, the incubator associated with companies including Cursor, Mercor, Etched, and Decart.

Ben’s earlier research included ThunderKittens, megakernels, and AI scaling laws. ThunderKittens is a domain-specific language and library for writing high-performance GPU kernels, developed through Stanford’s Hazy Research group. The current company extends that line of work from individual optimized kernels toward whole-workload scheduling.

Asher Spector has worked at Cursor, Mercor, and Meta. His product and infrastructure experience complements the research backgrounds of the other founders.

Why investors priced the thesis early

Flapping Airplanes fits the “neolab” model, in which a research-focused startup raises substantial capital before establishing a commercial product. These companies pursue new model architectures, training methods, scientific systems, or infrastructure that may require years of experimentation.

With no product revenue or published performance data, the $6 billion valuation rests primarily on the founders, their prior work, and the prospect of rising demand for limited computing capacity. Ben Spector summarized the market premise directly: “The basic thesis is demand for AI is going to outpace chip and data supply.”

Two efficiencies, two tests

Kernel fusion targets hardware efficiency, measured through utilization, throughput, latency, memory use, energy consumption, and total training cost. Sample efficiency measures how much data an algorithm needs to reach a given level of performance. Improvements in one category do not establish gains in the other, so the company’s systems and algorithmic claims require separate benchmarks.

The company’s name reflects its broader research argument. Spector has compared current AI development with early attempts to imitate birds, while successful aviation emerged from understanding flight and engineering a different structure. Applied to machine learning, the analogy suggests that new systems primitives could enable algorithms with lower data and compute requirements.

Verified gains in either category could affect teams outside the largest AI labs. Robotics, scientific machine learning, and specialized enterprise models often face limited data, compute budgets, or both. Better GPU utilization could lower operating costs immediately, while genuine sample-efficiency gains could expand the range of problems those teams can address.

Where the pressure lands

• Model developers: A usable framework could reduce kernel-launch overhead and increase GPU utilization without requiring each team to build its own low-level runtime.
• Robotics and scientific-ML teams: These fields could benefit from algorithms that learn from fewer examples, provided Flapping Airplanes demonstrates sample-efficiency gains independently of systems speedups.
• Inference-optimization startups: A well-funded entrant with whole-workload scheduling could compete with companies whose advantage comes from custom kernels and operator fusion.
• Open-source projects: The Luce Megakernel project reports running all 24 layers of Qwen 3.5-0.8B in one CUDA launch at 1.87 generated tokens per joule on a 2020 GPU. Such projects show that megakernel techniques already extend beyond a single company, though their results need comparable hardware and workload baselines.
• Nvidia and compiler vendors: GPU platforms could incorporate similar scheduling and fusion techniques into their own compilers and runtimes, narrowing the proprietary advantage available to an independent framework.

The benchmarks that would settle it

1. Scope: The company should define whether “one kernel” covers a model step, many steps in a persistent kernel, or a complete run including the optimizer, checkpoints, data input, and communication among GPUs.
2. Baselines: End-to-end comparisons should include standard PyTorch and CUDA implementations, compiler-optimized stacks, CUDA Graphs, and strong hand-tuned kernels.
3. Measurements: Results should report training throughput, inference latency, GPU utilization, memory use, energy consumption, compile time, and total cost.
4. Generality: Tests should cover multiple model architectures, sequence lengths, batch sizes, numerical formats, and GPU generations.
5. Operations: A production release should explain debugging, profiling, checkpointing, fault recovery, scheduling, and multi-GPU support.
6. Algorithmic gains: Sample-efficiency claims should compare models at equal compute budgets and equal target quality, with reproducible datasets and evaluation methods.
7. Delivery: Developers still need to know whether the framework will ship as open-source software, a hosted service, a licensed runtime, or an internal system used for the company’s own models.

Public code, customer deployments, and independently reproducible benchmarks would provide the evidence currently missing from Flapping Airplanes’ megakernel claim. Until then, the Series A prices a technically ambitious research program whose performance, portability, and commercial model remain unproven.