Wink Pings

Your Agent Is Not Autonomous—You Are Its Loop

Karpathy has released a free 2.5-hour course on building AI from scratch. But if you're already using agents, this 7-layer framework is more worth reading: your agent is not autonomous—you are its loop.

Andrej Karpathy has released a free course: 2.5 hours, building neural networks, language models, and agents from scratch. Course path: Scratch → Neural Net → Language Model → Agents → How It Actually Works. He says: “Let's build it from scratch, so you understand every single piece.” Head of Tesla Autopilot, co-founder of OpenAI—and the course is free.

One commenter put it bluntly: this course is worth ten thousand dollars, and he released it for free.

But today I'd rather talk about another piece. m4lka (@m4lkxx) wrote a long article: “Harness, Loops, Graphs: What Each Layer Fixes and What It Breaks.” The opening line hits hard:

“Your agent is not autonomous. You are its loop.”

Your agent is not autonomous. You are its loop.

m4lka divides agent systems into 7 layers. The core is three words: Harness (environment), Loop (loop), Graph (graph). They are not parallel tools; they are a ladder. Each layer exists because the layer below it breaks in some specific, predictable place.

He uses one example throughout the piece: a bug report comes in, and the agent has to fix it and open a PR.

Level 0: Chat
You paste the bug report, the model gives suggestions, you copy them into the editor, run tests, paste the errors back, and ask again. The model is just a very smart function; you are the entire program. One-off problems are fine; repeat it twice and it's a disaster.

Level 1: Harness (giving it hands)
Let the agent touch the world: shell, file access, test runner, git. But more tools is not better. Ten narrow tools beat forty overlapping ones. The cleanest definition: take the model out of the architecture diagram, and what's left is the harness.

Level 2: Harness (memory and walls)
The context window is RAM; the harness is disk. PROGRESS.md, git commits, passing artifacts by reference. Models forget; files don't. Walls are permissions, not wishes like “please don't touch that.” Least privilege, sandboxes, command allowlists, budgets.

Level 3: Loop (checks that can fail)
The loop has four steps: produce, check, correct, repeat. Only “check” matters. Without a check that can fail, “repeat” just repeats mistakes. Evidence is ranked by how hard it is to fake: deterministic tests are strongest, self-reports are weakest. A check is only as strong as the weakest evidence it accepts.

Level 4: Loop (feedback that converges)
“Wrong” is a verdict; “wrong here, wrong this way, you already tried that” is feedback. Write EXPECTED and SAW, add FENCE and DEAD ENDS. The loop needs exit conditions: green, the same result twice, budget exhausted.

Level 5: Graph (the shape of the work)
Nodes are single tasks; edges are real dependencies. Many arrows are habits, not dependencies. If B can start before A finishes and nothing is affected, that line is waste. Every node needs its own context. Four agents sharing one context is not a team; it's one agent wearing four hats.

Level 6: Graph (gates and return paths)
Freeze results that have passed. On failure, rerun only the failed node. Classify by undo cost: one-click undo, undo after cleanup, irreversible. Human attention goes only where things are irreversible. You are the most expensive, slowest node in the system—don't put yourself on things that can be undone with one click.

Level 7: Learning
Every failure belongs to a layer, and the lesson must land on that layer. Don't feed logs; feed rules. The test is simple: the same class of failure no longer costs you twice.

m4lka also includes a self-assessment table. If you're still copy-pasting between chat and terminal, you're missing Level 1. If the agent keeps using the same bad method, you're missing Level 2. If “done” means nothing before you check it, you're missing Level 3. If retries burn money on the same error, you're missing Level 4. If every step is right but the whole thing is slow, you're missing Level 5. If one failure causes everything to be redone, you're missing Level 6. If the same mistake shows up every week, you're missing Level 7.

The honesty of this framework is rare. It doesn't pretend agents are already autonomous; it clearly admits that behind almost every “autonomous” setup, there is a person quietly doing the three jobs the system should be doing: giving the model a place to work, telling it whether it's right, and deciding what to do next.

The course is free. The article is free. But both are worth more than most paid content.

If you haven't started using agents yet, watch Karpathy's course first. If you're already using them, read m4lka's article first.

发布时间: 2026-11-20 01:49