Verifiability Is the New Frontier: What Karpathy's 2026 Framework Means for Engineers

At Sequoia Ascent 2026, Andrej Karpathy said something that's been quietly reshaping how I think about agent work.

"AI automates fastest in domains where output can be verified."

That's it. One sentence. And it explains almost everything weird about where AI is succeeding right now.

Why Coding Agents Feel Different

If you've used a coding agent lately, you know the experience is qualitatively different from a chatbot. It runs for an hour, makes a hundred decisions, comes back with a working PR. Compare that to asking a chatbot to summarize a meeting — and getting prose that sounds right but might be subtly wrong.

The difference isn't raw model capability. It's feedback loops.

A coding agent gets a flood of cheap, binary signals: tests pass or fail, the build exits 0 or 1, the diff applies cleanly or it doesn't. Every iteration tightens the loop. A summarization agent gets… nothing. No ground truth. No atomic verification. Just vibes.

Karpathy's framework names this. Automation speed is bounded by verification speed. When verification is cheap, automation is fast. When verification is expensive or subjective, automation crawls.

The "Jagged Intelligence" Problem

Karpathy also called out a related phenomenon: jagged intelligence. Models spike to expert-level in domains with dense training signal — math, code with tests, games with scores — then fall off a cliff in adjacent domains where the signal is sparse or noisy.

This isn't a bug. It's the geometry of the training data. And it predicts exactly which industries get disrupted first: anywhere verification is automatic, structured, and scalable.

• Coding with tests ✅
• Math with proofs ✅
• Game playing with scoreboards ✅
• Customer service with deterministic playbooks ✅
• Long-form research writing ❌
• Subjective design critique ❌

What This Means for Your Workflow

Here's where the framework becomes useful as a decision tool. Before you delegate a task to an agent, ask one question: can I verify the output in under five minutes without redoing the work myself?

If yes — delegate it. You'll get leverage. If no — you're not automating, you're gambling. The agent will produce something plausible, and you'll spend an hour auditing it. Net negative.

The teams winning right now aren't the ones throwing agents at everything. They're the ones ruthlessly picking tasks where the verification loop is tight, then compounding from there. Coding, test generation, refactoring, log analysis, schema migrations. Boring on paper. Massive in aggregate.

Where to Bet Next

If you're trying to predict the next agent capability wave, don't watch the model releases. Watch where cheap verification is becoming available.

• Static analysis + type checkers made refactoring agents viable.
• LLM-as-judge benchmarks made certain kinds of evaluation agents viable.
• Browser automation assertions made web-testing agents viable.

Every new verification primitive unlocks a new automation frontier. The model weights are almost incidental — the verification infrastructure is the bottleneck.

The Bottom Line

Karpathy's framework is simple enough to fit on a sticky note and sharp enough to reorganize how you spend your engineering hours.

Pick the work where you can verify quickly. Delegate it. Compound the gains. Leave the rest to humans for now — not because AI can't, but because the verification cost is still too high.

The frontier isn't model capability. It's how cheaply you can tell right from wrong.

---

What's the cheapest verification loop you've found that unlocked real automation? I'd love to hear about it.