The Autonomous Middle
How to build a sandwich around knowledge work, not just code
How much of your work an AI agent can run on its own has surprisingly little to do with how capable the model is. It comes down to a skill almost none of us have been trained for, and the people who build it can get far more out of the same agents than most. What that skill is, and why the iterative knowledge work that supposedly can’t be handed off is exactly where it pays off.
You can hand a coding agent a well-specified task, walk away, and come back to working software. Try the same thing with a strategy memo or a market analysis and you’re back in five minutes, untangling what it got wrong. Ethan Mollick named the reason a few weeks ago: coding agents are “software-brained,” and most knowledge work isn’t. The end product of code is the source of truth, so the loop closes fast. For research, analysis, and strategy, the process matters as much as the output, and you work in learning loops, refining as you go. The feedback signal for “correct” doesn’t arrive fast enough to just hand off.
He’s right about the disconnect, but when I replied to him I realized I’d already been working on the answer. Most of the leverage comes from separating the work: you isolate the parts that are genuinely repeatable and let those run, and you pull the judgment-heavy decisions out to decide up front.
I’ve asked a version of the question before, in The Leash Length Problem (how long can you let an agent run before you step in), but that was about trust and permission, what the agent is allowed to do. This is the other half: how much of the work is even hand-off-able in the first place.
Judgment is the bread, the agent runs the filling
The clearest version of the shape comes from Kieran Klaassen at Every, who built a whole practice around it: compound engineering, the idea that each cycle of work should make the next one easier. Kieran pushes it about as far as it goes: stay in the loop and ask questions at the top, trust the agent to run the work phase, come back to elevate what’s nearly finished. In a recent podcast interview, it got a name: the AI sandwich. Your judgment goes on the top and the bottom, and the agent runs the middle. (I’d been pushing toward it from the other direction, trying to run more agents at once, when I came across it and recognized it.) He argues the pattern reaches well past engineering, into knowledge work broadly, and my own work says the same. What the pattern leaves open is how wide that middle gets.
The sandwich maps onto the decomposition I wrote about in The Judgment Layer. Most work is a bundle: a set of verifiable parts where “correct” is quick to check, plus a thinner layer of irreducible judgment where there’s no fast way to know if you got it right. The hard skill is unbundling the two correctly. The judgment is the bread, the part that stays human. The filling is execution and verification, the work where “correct” is checkable fast enough that the agent can stay on track without you in the loop. Widening the middle means pushing all the judgment out to the two ends, so the filling is nothing but work the agent can run on its own.
None of this makes the directing-and-reviewing work disappear. That’s the verification tax I’ve written about: as your output scales, review becomes the thing that limits you. The sandwich doesn’t pay that tax down; it relocates it, out of the middle where it stalls you turn by turn, to the edges where it doesn’t.
How wide the middle gets is a skill you build
So how much of the middle can actually run on its own? The width is set by how well you can do three things:
You isolate the consequential judgment calls and decide them up front.
You get the model to catch the foreseeable problems before they reach you, by running the plan through a set of predefined lenses, fixed checks for the ways this kind of work usually goes wrong.
And you accept that some judgment, maybe the last ten or twenty percent, can’t be foreseen, so you let it surface at the review on the way out.
The lenses don’t start out sharp: you learn where the work goes wrong by watching what comes out the other end, then fold each lesson back into the upfront review so the next run catches it before it reaches you. Front-load, run, review, harden, and the middle gets a little wider each time, because each correction is what sharpens the next check.
I went looking for evidence of where my own time actually goes. Over a month, I went back through fifteen of my own work sessions and sorted every one of my interventions into three buckets: the irreducible judgment (taste, positioning, the lived facts only I have), the mechanical overhead (screenshots, copy-paste, link-wrangling), and correcting the agent’s mistakes. The corrections were the largest bucket by a wide margin. A review step would wave through writing I’d have caught on a casual read; the agent would invent an attribution, or talk itself out of a problem it had already flagged.
For a while I read that as the ceiling: more output just means more to police. But the corrections weren’t random. Each one was a judgment call I hadn’t pulled forward, a decision about what “good” meant here that I’d left for the agent to guess, and it guessed wrong. The correction load was the price of the judgment I’d failed to front-load. The fix is to move that judgment to the edge, or harden it into a standing check, so it stops coming back.
This is the part that doesn’t dissolve as models improve. A better model runs the verifiable middle faster, but it can’t close a loop that doesn’t close in time. Whether a founder is right, whether the timing is there, whether this is even the market worth sizing, none of those has an answer to check against yet. The judgment layer is irreducible by definition. So the limit on autonomy was never really the model. It’s how cleanly you can separate the judgment from the routine.
The system that wrote this post runs on the same skill
This essay was produced by a system that runs on exactly this shape, a stack of small, single-purpose tools I had to wire together by hand. There’s a step at the outline stage where I make every judgment call I can anticipate before anything runs: what the post argues, which stories carry it, what to cut. The one call that never goes near the machine is whether the argument is worth making at all. The first draft of this post got that wrong: it argued something I’d basically already published, and the real work was noticing, not writing. There’s a set of review agents that read each draft cold through fixed lenses, one for accuracy, one for voice, one for whether it actually lands for the reader. The drafting, the reviewing, and the cover all run without me. I come back to a near-finished package, read it, and finish it. And when I correct something, it becomes a new rule the system enforces next time. It’s a learning loop I built to do for writing what compound engineering does for code: a mistake gets caught once, then never again.
Writing essays is knowledge work, not code. The process is iterative, the feedback loop is slow, and it’s exactly the kind of work Mollick says resists this. It runs the middle on its own anyway, because the iterative part, the judgment, has been moved to the edges.
The payoff is running several at once
Once the judgment lives at the edges and the middle holds, you stop being the bottleneck between one agent and the next. You can set several going at once, each running its own middle, and meet each one at the end, which is where the real leverage shows up. This is where the “my agents do work for me at night while I sleep” becomes closer to reality. (I’m now pushing this further, front-loading whole plans so they run start to finish, but that’s a story for when it’s run long enough to report honestly.)
The skill is the bottleneck
The thing that limits your leverage from agents, whether you’re one person or a whole firm, is this skill of breaking work into parts, and most knowledge workers haven’t built it. It asks you to think a little like an engineer: break the work down, say what “done” means, anticipate where it breaks. That’s the muscle Mollick is right that most of us don’t yet have.
Which is where I think the opportunity is. Right now, to get the autonomous middle, you have to author the whole stack yourself, the way I did. And it’s not just essays: the analyst building a model, the strategist writing a recommendation, the researcher chasing down sources all hit the same wall, each wiring their own version by hand. The thing worth building, and worth backing, is the layer that comes pre-built and opinionated: front-loading that already knows what to ask you, the review lenses, and the hardening already wired in, so someone gets the sandwich without assembling it themselves or thinking like an engineer to use it. The skill is the scarce part, which is why the opportunity is to package it.
So whether you’re running more of your own work without babysitting it, or building the product that lets other people do the same, the question was never whether the model is good enough. It’s how much of the judgment you’ve moved to the edges, and whether each correction you make teaches the system or just costs you the same hour again.