Wink Pings

Karpathy Went 70 Minutes Without a Single Slide: The AI Agent Gap Is Outside the Model

Karpathy spends 70 minutes demonstrating his day-to-day AI workflow without slides. Whitemon breaks agent failure into three layers—harness, loop, and graph: first give the model an environment, then give it evidence it can fail on, and only then discuss multi-node collaboration.

Andrej Karpathy opened his screen and talked for 70 minutes without a single slide. The video was recommended by @0xoctocat, and it covers prompts, context, tools, and workflows. Screen sharing leaves behind mouse trails, window switches, and hiccups. Slides tend to smooth over the process.

The tweet says this is worth more than a $2,000 AI course. That sounds more like marketing spin. What is really worth watching is the long post Whitemon published afterward: he breaks agent failure into three layers—harness, loop, and graph. The same model and the same prompt can produce different results, and the reason is often the system outside the model.

Don't Rush to Swap Models

Whitemon describes a common loop in the article: the agent fails, so you change the prompt; it fails again, so you switch models; the third time it fails, you add all-caps IMPORTANT and hope it gets better. One commenter added in a reply that this feels like the bargaining stage of agent development.

The problem is usually not the prompt. Most of the time, it is not the model either. The problem is the system around the model. The article quotes a Karpathy tweet in which he says he has never felt so behind as a programmer, and that programming is being restructured. He lists a string of terms: agents, subagents, prompts, contexts, memory, modes, permissions, tools, plugins, skills, hooks, MCP. Whitemon says these terms look like synonyms, but they actually mix three layers.

Harness: Give the Model Hands, Memory, and Walls

Harness is everything outside the model. Take the model out of the architecture diagram, and what remains is the harness: terminal, tests, browser, project memory, permissions.

The article gives an example: fixing a login redirect loop, issue #482. Before starting, turn the request into a contract with a finish line: goal, inputs, outputs, constraints, and completion conditions. The most important field is done_when. Without it, the agent will quietly solve a simpler task and then say it is done.

Context is more like an attention budget. Treat it as a warehouse and it will be exhausted quickly. Don't stuff all the documentation into the window; give the agent a short root file that tells it where things are, and load more when needed. Tools are not a case of the more the better. Ten narrow tools beat forty overlapping tools. Each tool needs inputs, outputs, failure states, and a permission level.

Permission walls need to actually block things. Writing 'please don't touch migrations' is just a wish. A permission the agent does not have is a wall. The model can suggest an action; policy outside the model decides whether it can run. The same system cannot invent the plan, approve the risk, and execute the side effect.

There is also memory. Decisions, dead ends, and unresolved risks go into files and git commits, not into the chat. That way the next session inherits the state of the work, not a summary of the conversation.

Loop: Don't Loop on Confidence, Loop on Evidence

With a harness, the agent can work on its own for an hour. Then it says: fixed, the tests should pass. Note the word 'should.' The system has given it capability, but not correctness.

A loop is a feedback system with goals, evidence, and stopping conditions. Whitemon gives a hard rule: don't loop on confidence, loop on evidence. The agent saying it is done is not a stopping condition. Tests passing is.

Evidence has strength levels. The strongest is deterministic checks: test exit code 0, schema passing, build compiling. Next is concrete observability: a trace showing it actually ran the tests. Independent review is also strong. The weakest is self-assessment: looks good, I'm confident, it should pass. A check is only as strong as the weakest evidence it accepts.

Write the check before writing the code. First define what green means, and put in a test that fails on the current code. A test that passes before the fix proves nothing. If you can't write the check, the task isn't thought through yet.

Feedback also can't just be a verdict. Red tells the agent almost nothing. Useful feedback spells out expected, actual, where to look, and what was tried. Expected vs. actual turns a red light into direction. A list of dead ends prevents the third attempt from quietly returning to the first.

A loop needs an exit. If the same result appears twice, it should escalate to a human. A loop can fix the work; it cannot fix the problem itself.

Graph: One Agent Does the Work and Another Agent Scores It—That's Not Enough

Every step is correct, but the whole ticket is still slow. A real task is not one step: fix the bug, check whether billing and admin use the same helper, update the docs. One agent does it all in one context, and the second agent audits by reading the first agent's notes, repeating the same viewpoint. It does the work itself and scores itself.

A graph is three things: nodes are bounded work, with one input and one output; edges are real dependencies, where one node's output feeds another node's input; state is what survives between nodes. A loop is one node plus an edge back to itself. A graph does not replace a loop. You need a graph only when multiple loops have to hand work off to each other.

Every arrow has to pass the early-start test: if B starts before A finishes, what breaks? If the answer is nothing, delete the arrow and run them in parallel. The billing audit can start before the fix lands, so those run in parallel. The PR cannot be opened before the fix, so that arrow is real.

Not every task needs a graph. If five nodes can collapse back into one loop without losing anything, collapse them back. LangGraph and Google ADK have long supported nodes, edges, and shared state. The terminology is new; the shift from a single loop to coordinated nodes is real.

Where You Should Sit

At level zero, you are the entire system. Your hands run the code, your eyes check the results, and your brain decides the next step. The model is the only part not doing the heavy lifting.

The goal is not to build an agent that never needs you. You are the slowest and most expensive node in the graph. Put yourself where mistakes cannot be undone. Set gates by the price of undoing, not by model confidence: docs, tests, a single function—ship when green; shared helpers, auth, schema—require green plus trace plus a second opinion; migrations, deletions, sending emails, spending money—a human signs off. The final layer has no score. It is not 0.95, and it is not 0.99. The model has no number to game, so there is nothing to argue about.

Fix the First Symptom

Whitemon gives a symptom table: copying and pasting between chat and terminal—fix the harness's tools; retrying things already tried—fix the harness's memory; done doesn't count unless checked—fix the loop's checks; the same mistake burns budget—fix the loop's feedback and exit; every step is correct but the whole thing is slow—fix the graph's shape; one failure causes everything to rerun—fix the graph's gates.

The most common mistake is drawing the graph too early. First watch the agent do the work once, collect traces, and then formalize the parts that are truly worth formalizing. Also, if the same model writes and reviews, it shares its blind spots. Tests first, independent-context review second, and bring in a human for things that cannot be undone.

Next time an agent says done, first ask which layer is saying it. The harness gives it capability, the loop makes it honest, and the graph gives it organization. Models will change every quarter; contracts, tools, tests, state files, and gates will not. If failures are attributed to the right layer, the system gets better.

Reference links: Whitemon's article, original tweet.

发布时间: 2026-11-21 07:57