Imagine Kepler as a high-temperature language model—trying random relationships for twenty years, some completely wrong, until one works. That reframe, from a conversation between Dwarkesh Patel and Terence Tao, cuts to the heart of today's most important debate. Can AI actually do science? And separately—what happens when you give agents the ability to run science on themselves?

The Verification Problem: Why AI Scientific Discovery Is Harder Than It Looks

Tao and Patel spent two hours pulling apart a deceptively simple question. People assume AI will accelerate scientific discovery because of tight verification loops. But Tao's Kepler story complicates that immediately.

Copernicus's heliocentric model was actually less accurate than the geocentric model it replaced. The better theory survived—not because of data, but because of judgment, narrative, and heuristics we still can't fully articulate. That's a verification loop measured in decades. You can't reinforce-learn your way through it.

Tao's core argument is sharp. AI has driven the cost of idea generation down to nearly zero—the same way the internet drove communication costs to zero. That sounds great. But it shifts the bottleneck. Now we're drowning in hypotheses and starving for verification. Journals are being flooded with AI-generated submissions. Human reviewers are overwhelmed. We can generate a thousand theories a day. We can't evaluate them at that speed.

Here's the number that grounds the hype. Tao has tracked AI progress on the Erdős problems—roughly eleven hundred unsolved combinatorics challenges. About fifty were solved by AI tools over recent months. Then it stopped. Three separate attempts to have frontier models attack every remaining problem simultaneously produced almost nothing. The success rate on any given problem is roughly one to two percent. The wins get amplified on social media. The failures stay quiet. That's selection bias masquerading as a breakthrough.

What AI can do is breadth—and Tao is genuinely excited about that. AI can map an entire field rapidly. It can apply every known technique to every open problem simultaneously. Human experts provide depth. Those two things are complementary, not competing. But—and this is the crucial caveat—we haven't yet redesigned scientific workflows to take advantage of this combination. The paradigm doesn't exist yet.

There's another observation from Tao that's easy to miss. His papers are getting richer and broader because of AI. More plots, more code, deeper literature searches. But the core mathematical insight—the hardest twenty percent of any proof—he still works out on pen and paper. AI has made his papers better. It hasn't yet made them deeper.

The Loopy Era: When Agents Run Science on Themselves

While Tao describes AI's ceiling in formal science, Andrej Karpathy is busy dissolving that ceiling in a different domain. His framing for where we are right now: the loopy era. Agents running continuous self-improvement loops on code and research.

His AutoResearch project makes this concrete. One markdown prompt, roughly six hundred thirty lines of training code, a single graphics processing unit. In two days, it ran seven hundred experiments. It discovered twenty optimizations—including novel architecture tweaks like reordering query-key normalization and rotary position embeddings. No human in the loop. The agent edited the training file, tried ideas, learned from failures, and kept going.

This is the thing Tao says AI can't do—build cumulative partial progress. Karpathy is claiming it's starting to happen, at least in code. The agent isn't just jumping and failing. It's staying on the handhold and pulling.

Karpathy describes a parallel shift in how he works. Coding agents—Claude Code, OpenAI Codex—crossed what he calls a coherence threshold around December of last year. He now runs grids of agents in parallel using tmux—a terminal multiplexer that lets you manage multiple sessions simultaneously. He's building watcher scripts to keep them looping. His next project is an agent command center—because the single-file IDE is dead, and the new unit is teams of agents.

The vocabulary shift he's proposing is useful. Vibe coding—where you describe what you want and get working software—was twenty twenty-five. Agentic engineering is twenty twenty-six. Humans no longer write most code. We direct, supervise, and orchestrate. Technical expertise still matters—it's a multiplier on what you can get out of the agents. But the bits humans contribute are sparse and rare.

Simon Willison offers a vivid illustration of where this is right now. He took the Turbo Pascal three-point-oh-two executable—a thirty-nine-thousand-byte file from nineteen eighty-five that somehow contained a full text editor and Pascal compiler—and asked Claude to decompile it from the raw binary. Claude did it. Then Simon had it build an interactive artifact annotating the assembly, showing which bytes correspond to which parts of the application, with reconstructed readable code. A forty-year-old binary, fully disassembled, in a single conversation. That's not agentic engineering. That's just a very good tool. But it shows the floor rising.

Who Owns the Agent Layer

The third thread running through today's content is a strategic question. As agents become real infrastructure, who captures the value?

David Singleton—former Stripe CTO, now building Dreamer with Hugo Barra of Android fame—has a clear thesis. Agents need an operating system. His platform's core insight is that the sidekick, the personal AI at the center of Dreamer, acts like a kernel. Agents and apps are like user-space processes. They don't talk to each other directly—they route through the sidekick, which enforces permissions and aligns actions with user interests.

This matters for trust at scale. Without that kernel layer, Singleton argues, you get vibe-coded apps that grab your data indiscriminately and can't collaborate. The OS abstraction is what makes agents safe enough for consumers who don't want to think about permissions.

Karpathy frames the same dynamic from a different angle. Applications like Cursor bundle and orchestrate multiple model calls into increasingly complex directed acyclic graphs—networks of model calls with dependencies between them. They do context engineering, provide a vertical-specific interface, and offer what Karpathy calls an autonomy slider. He suspects model labs will produce generally capable graduates. But LLM apps will organize those graduates into deployed professionals in specific verticals—by supplying private data, sensors, actuators, and feedback loops.

Ben Thompson, in a brief aside, calls agents the reason he no longer believes we're in an AI bubble. The demand they create for compute changes the shape of everything. And he flags an interesting crack in a thesis he's held for a while. He previously argued OpenAI and Anthropic are sustainably differentiated because they integrate the model with the harness—the scaffolding around the model. But he thinks the emergence of OpenClaw—open-source alternatives to frontier model tooling—is evidence that integration might not be as defensible as he thought.

The open model ecosystem is asserting itself in another way too. Cursor's Composer Two, a coding assistant, was built on top of Kimi K-two-point-five—a model from Chinese lab Moonshot. The foundation model was open. Cursor did continued pretraining and high-compute reinforcement learning on top of it. Inference was handled by Fireworks AI. Three different organizations, one product. That's what the open model stack looks like when it works.