On the Death of MVP, the Birth of MPL, and How Value Will Flow Next

“Make something people want.” Four words. Paul Graham put them on the wall at Y Combinator, and the companies built on that line are worth more than most countries. The advice was right. Build a minimum viable product, put it in front of people, watch what they do, iterate until the market pulls it out of your hands. Fifteen years of it worked.

All of it existed to answer one question. Does anyone want this. You couldn't afford to build the real thing just to find out, so you built a cheap fake and read the signals off it. The MVP was never a product. It was a question you could afford to ask.

The real thing cost too much to use as a question for two reasons: building it, and running it once built. The agentic era is collapsing both. An operation can run end to end now with no human inside it.

I build these things, so I'm not guessing from outside. Most mornings I write code that runs an operation end to end, no human anywhere in it, and for a business like that, the MVP question is the wrong one. You don't build a smaller version to test it. You run it. The first thing I build now isn't a product. It's a loop.

MVP is dying. What's about to replace it is what I call the MPL: the Minimum Profitable Loop. The smallest run of operations that clears a margin with no human inside it. The MVP guessed at demand. The loop counts the money. The unit of validation moved from one to the other.

A loop that makes something nobody buys isn't an MPL, it's a hobby. Clearing a margin means the output reaches someone who pays for it, so a minimal distribution is baked into the loop from the start. Just enough to reach the first paying buyer. The scaling-and-defending kind belongs in the moat layer. Reaching a buyer is part of what makes a loop a loop.

And I think this is the part that breaks the old playbook. Product-market fit collapses into a single act. PMF was a proxy. You couldn't see demand, so you inferred it from retention curves and interviews and how far a buyer leaned in during a demo, every signal standing in for a number you couldn't reach until you'd already spent the money to reach it. A loop hands you the number directly. A loop clears a margin only if someone paid more than it cost to run. That is demand, realized, on the ledger. You don't establish fit and then build. You run loops until one pays, and the one that pays is the fit. The search and the business become the same act. And fit stops being a place you reach and hold. The run that uncovers it is the run that starts competing it away. It's decaying the moment you read it.

So you find a loop that pays. Then comes the real question. What do you actually own. The answer starts with the margin.

So where does it come from? Same place, every time. A loop pays because it produces at machine cost what the economy still prices at the cost of a human doing it. The output sells at the human price, the input runs at the machine price, and the gap is the whole business. I call it a substitution loop, a machine doing for less what a person did for more. It's the common case, and it has a problem.

It owns nothing but a cheaper method, and a cheaper method gets copied. It takes time, less than it used to, but time. The moment a loop pays it shows, and then it gets found, copied, and undercut by the next entrant willing to run it on a thinner margin than yours. It keeps paying while that happens, N times over, on a margin that decays toward the floor with every copy that lands. For most of business history, copying a proven approach was the slow, expensive part, and that slowness was the moat. That's what collapsed. The loop is the smallest asset you can build now, and with nothing else behind it, it has a short half-life.

But the loop doesn't disappear when the margin goes. It hardens. A loop competed down to the floor by the rules of the open market becomes cheap, reliable, and available to everyone, which is the definition of a primitive. It stops being a business and becomes a part. Document extraction earns a margin for as long as it's scarce, and the moment it isn't, it's a component that makes the next thing cheap to assemble.

And the parts pile up. Every loop that commoditizes is a block the next loop gets built from. Compute gets cheaper every year and the models get more capable, and a loop too complex to run last year becomes runnable this one, partly because the layer beneath it just turned into cheap components. The frontier climbs on the loops that died under it. Early on, the runnable loops are mostly substitution. Later they're mostly new, things no human could do at any price, assembled out of whatever commoditized along the way. All of it is one moving line: substitution hardening into primitives below, creation at the edge, and the line never stops rising.

That climb is the engine. Businesses get autonomized not because anyone decides they should be, but because cost keeps falling and competition keeps pushing, until the loop costs less than the people it replaces. One rung at a time.

Which is where the value goes. You capture the margin while the curve lasts, and then the curve flattens and the margin is gone. But the loop you ran is now a cheap, reliable part, and the value it still holds, more than the margin ever was, belongs to whatever gets built on top of it. A commoditized loop is a cheap input for the loop climbing past it. The value didn't disappear when the margin did. It moved up, into the layer your loop made possible.

That's the direction value flows now. Up. Out of each loop as it hardens, into the more complex loop its hardening just enabled. Nothing you hold stays where the value is. The value is always one layer up from wherever you're standing.

The cycle is short enough to write out:

1. A loop starts paying.
2. Competitors find it, copy it, undercut it.
3. The margin bleeds toward the floor.
4. The loop hardens into a primitive loop.
5. New value forms one layer above.

Then it runs again on the new floor.

So what's a moat now? You can't own a copyable loop. You can only run it. What's left to own is what wraps it or the primitives it runs on. The old kind of moat held a position still. You found a profitable spot, walled it off, and the wall kept the margin yours, as long as competition was slow. It isn't slow anymore, and a wall around a sinking position is worth nothing. The way I've come to see it, a moat isn't a wall now, it's a brake. It can't stop the margin from bleeding, nothing can. It sets how fast. The question about any moat flipped with that: not whether it protects you, but how many cycles it buys before the loop hits the floor. Being first stopped being a moat once copying a running loop went cheap. But finding a loop worth running was never the cheap part, and now that building has gotten cheap too, that search is the scarce part. Being first to it wins the front of the curve, not the position after.

Most of what people call moats are brakes. Proprietary data a rival can't get, distribution that reaches the buyer first, a brand a buyer won't second-guess. They share one property: a competitor can copy your loop exactly and still not have them, so they slow the copying without stopping it. The slowest brakes are the human ones. A buyer keeps paying a law firm, an auditor, a bank long after a machine could do the work, because what they're buying isn't the work, it's an institution willing to be liable for it. Trust and accountability decay slower than anything else, because the thing being sold was never efficiency in the first place. The frontier rises past them too, just later.

The move I'd make is putting the human back on purpose. Doc extraction on its own is a primitive now, almost no margin left in it. Wrap it in a legal-processing company, with an account manager, an SLA, someone the buyer can call and someone who's liable when it's wrong, and the margin comes back, because now they're paying for the wrapper, not the extraction. The machine still runs the loop. The human carries the relationship and the risk. Putting the person back is how you climb the margin on top of automation, not a retreat from it.

And a brake is only worth the cycles it buys if you spend them climbing, building the next loop on the floor your last one just became, before anyone else gets there. Sit still behind a good brake and all you've bought is a slower death.

There's one moat that doesn't behave like a brake at all, because it doesn't decay with the loop. It compounds. It's owning the primitive everyone's next loop has to run on. The floor under the loop: the model they call, the data they train on, the rails they settle through, the identity they authenticate against, the standard they have to speak. Own a primitive and every loop built on top of you pays to use it, and the higher the stack climbs, the more of them there are paying. A brake fights the decay of one loop. A primitive feeds on the decay of all of them. It's the only position I know of that gets stronger as everything around it commoditizes, and it's the one I'd build toward.

And it doesn't settle. Each hardened loop feeds the layer above it, that layer hardens and feeds the next, and the frontier, which is just wherever the live value currently sits, never stops rising. This is the cycle. My bet is it runs until it runs out of room: until the loops have worked their way up through the whole human economy and there's almost nothing left that a person used to price and a machine can't now run. Arbitraged, optimized, improved, one hardened layer at a time, all the way up.

MVP asked what to build. The agentic era's first answer is to stop building products and find a loop that pays. The asset that lasts isn't the loop. It's being where the value is, a rung ahead of the commoditization rising under you, and the loop is just what you hold while you're climbing. I haven't made a dollar from any of this yet, so weigh it however you like. But the question has changed, and from where I sit, almost nobody is building for the new one.