The AI labs won’t follow you down. Go build the hard thing.
The models are great. Infrastructure built. Capital committed. What's missing is what makes it move.
Let me start with the receipts, because they matter for what comes next.
In January 2024 I wrote that vertical SaaS was about to get smashed, that AI would collapse the cost of replicating specialised software, compress those famous 80–90% gross margins back toward the 45% the rest of the economy lives on, and force a shift from per-seat subscriptions to outcome pricing. People thought that was spicy. Two years on, the financial press has a name for what happened: the “SaaSpocalypse.” Software lost its premium for the first time in two decades, the SaaS Capital Index fell from around 7x ARR at the start of 2025 to roughly 3.8x by March 2026, the software ETF dropped about 30% from its September 2025 peak, and somewhere on the order of $2 trillion in market cap came off the sector. The seat-based model, Salesforce, Workday, Atlassian, is the explicit thing analysts are now downgrading, because once an agent does the work of ten seats, the link between headcount and revenue doesn’t just slow, it reverses.
If anything, it arrived more completely than I described. I said companies would stop buying specialised software and start building it in-house, because the cost of building was about to collapse. I pictured the low-code of the day, dragging blocks on a canvas. What actually showed up was more total than that: natural-language app-builders like Lovable, Bolt and v0, where a non-technical founder describes the tool they need and watches it get built and deployed, no engineers, no seat licences, no canvas. The wrapper wave softened the ground first: thousands of thin AI products that died fast but proved, publicly, how cheap software had become to produce. Then the build-it-yourself tools removed the last excuse to pay $100 a seat for something you could now just make. Same deflationary force I named, arriving harder than I’d dared predict. The destruction came, and it came early.
By November 2024 I was writing about the other half: if the old thing is dying, here’s the new thing. Software stops being a tool you operate and becomes a service that delivers the outcome, Service as Software, $4.6 trillion of work that used to need a human, done by software. Outcome pricing, agents that complete tasks rather than assist with them. I wasn’t the first to put a name to it, the idea was already moving through the VC world by late 2024, but I was on it early, while it was still a niche thesis rather than the wallpaper it’s become. It’s the consensus take of 2026 now, which is a polite way of saying it stopped being controversial.
So I’m not here to walk any of it back. Both halves landed. The destruction and the replacement both arrived roughly on schedule. I’m writing now because the part that actually matters has come into focus, the part neither of those pieces had: where the defensible thing is. Everyone can see the category. Almost nobody’s saying the right thing about the moat.
Here’s the thing though. “Go vertical” gets said a lot, but almost nobody’s actually doing it in a tight enough space to matter. They say it, then they flinch, because they’re convinced the labs will crush anything they build. That fear is the whole opportunity. The gap isn’t that nobody knows where the moat is. It’s that everybody knows, and almost nobody’s brave enough, or frankly equipped enough, to go and take it. So let me spell out exactly why the labs can’t follow you down. Once you see the mechanism, the fear looks misplaced.
The asymmetry nobody’s pricing in
OpenAI and Anthropic sell open loops. They have to. A model that serves a billion people can’t close a loop, because closing a loop means owning the outcome, the permissions, the exceptions, the liability, the write-back into someone’s real system, the moment your software becomes the system of record. “Be a safe, general assistant to everyone” and “form a specific opinion about your specific business and act on it” are opposite postures. The first is their entire franchise. The second is the only thing a real business actually wants. So they hand you intelligence and let you do the last mile.
And the last mile isn’t a mile. It’s the whole job. The distance between an AI that can tell you how to build a financial model and an AI that builds yours, watches your edits, catches the contradiction three rows down, recomputes everything downstream, and then holds a view you have to argue with, that distance is the entire business. Everything before the loop closes is a demo. Only the closed loop is a product.
Open loop vs closed loop
An open loop ends with advice. A closed loop ends with the work done, and then goes round again.
Open loop: “Here’s how you’d structure your cap table.” You now go and do it.
Closed loop: the cap table exists, it’s right, it updated when your round terms changed, and the system flagged that your new option pool breaks an assumption in the model you signed off last week.
The labs live on the left. Every business problem worth money lives on the right. The chatbot that explains the thing is commoditised the day a better model ships. The system that owns the thing end to end, with the right permissions, handling the exceptions, carrying the liability, holding state, gets more valuable that same day.
But here’s where most people, including me in 2024, get the word “outcome” wrong. We sold Service as Software as outcomes, deliver the result, not the tool. True, but incomplete, because “outcome” smuggles in a finish line. Deal closed. Model built. Task done. Loop ends. That’s not how a business works. A business doesn’t shut down the day it closes a deal, it books the deal, learns from how the deal went, adjusts, and goes again. And again. The outcome isn’t the end of the loop. It’s one turn of it.
That’s what closed actually means. Not “finished”, completes the circuit and comes back round. An organic loop, the way a living business is organic: every turn feeds the next, it compounds, it gets better the more it runs, and it never stops. A one-off outcome is just an open loop with a tidier ending. The thing worth building is the loop that learns from its own outcome and uses it to make the next one sharper.
And notice this is precisely what a single brilliant answer can never be. The labs are the apex of the one-off: ask, receive, done, forget. Stateless by design. The most powerful one-shot outcome machine ever built, and structurally incapable of going round again on your specific business, because going round again means remembering, and remembering everyone’s business is not a product you can ship to a billion people.
That’s the part I want to nail, because it inverts the usual moat argument. Most moats erode as models improve. A thin wrapper gets more disposable with every release. A closed-loop business gets stronger, because the expensive part the loop, the state, the proprietary corpus, the texture of a workflow you understand better than anyone alive, is precisely the part a model upgrade doesn’t touch. A better engine makes an open loop cheaper and a closed loop deadlier. You want to be on the side of that trade where the giants’ progress is your tailwind, not your obituary.
Why the labs can’t follow you and why nobody’s exploiting it
So if a closed loop is the whole game, why is almost nobody building one? Because it’s an engineering beast, and the reason it’s hard isn’t the number of parts, it’s that they stack, each one depending on the one above it.
At the top sits the goal, the outcome the business actually exists to move. Not a task. A direction. This is the part every harness diagram going around right now leaves out, and leaving it out is why those systems never close: a loop with no goal to measure against is just a hamster wheel. It acts, but it has no standard to judge the result by, so it can’t learn.
Below the goal sits intent, the goal broken down into the move that matters right now. What is the founder actually trying to do, as opposed to the words they typed? Get intent wrong and everything downstream executes the wrong thing perfectly.
Then memory, which is not one thing but two. Short-term, what happened in this thread, this session, the last five minutes, is cheap, volatile plumbing. Long-term, every decision, correction, contradiction and exception accumulated across months, is the opposite: durable, curated, and the single hardest thing to build. Fold them into one “memory” box, as everyone does, and you hide the fact that the long-term one is the entire moat.
And only then, at the bottom, action, actually doing the thing, with permissions, in the real world, handling the cases where reality doesn’t match the plan.
Goal, intent, the two memories, action, each one load-bearing for the next, and the whole stack measured against the goal at the top so the loop can close and come round sharper. That’s not a prompt. It’s a system, and a genuinely hard one. (How you actually wire it, and why the standard “model in the middle” diagram has the topology backwards, is its own piece. Next one.)
Which is exactly why the opportunity is sitting there unexploited. It’s not that people haven’t spotted the gap. It’s that building this is genuinely difficult, and the fear of the labs gives everyone a convenient excuse not to attempt the hard thing. So they build another open-loop wrapper, ship a single-answer chatbot, and wonder why the next model release eats them. The people who’ll win are the ones willing to do the masterpiece-level engineering the labs structurally won’t, because doing it would mean abandoning the thing that makes them labs.
The new blocker isn’t the model. It’s the knowledge.
Here’s what changed underneath all of this, and almost nobody’s saying it out loud. The models got good, shockingly good, shockingly fast. The blocker to automating real work is no longer intelligence. It’s domain knowledge.
Every company runs on know-how that lives nowhere you can point to. Some of it is in people’s heads. The rest is scattered across old email, Slack threads, support tickets, a database nobody fully understands, and a process three people half-remember. The business functions because humans vaguely know where the knowledge is and how to apply it. That’s fine for humans. It’s useless for an agent. You cannot hand an AI “we kind of do it like this, ask Dave.” An agent needs the actual rules, how a refund gets handled, how a pricing exception gets decided, how an engineer triages an incident at 3am, structured, current, and executable.
So the missing layer isn’t a smarter model and it isn’t search-over-your-documents with a chat box on top. It’s a living map of how a company actually works, turned into something an AI can execute against safely and consistently. Pull the knowledge out of all those fragmented sources, structure it, keep it current, and you’ve built the thing that sits between raw company data and reliable automation. Every company in the world is going to need that layer. Most don’t have it and can’t build it.
And here’s the wedge, the bit that’s mine. Everyone chasing this is building it for companies that already exist: a decade of Slack to excavate, ten years of tickets to mine. The whole job is archaeology, dig the knowledge out of where it’s buried.
A startup at pre-seed has nothing to dig. There’s no buried corpus. The company’s brain doesn’t exist yet, it’s being formed in real time, usually half-wrong, in the founder’s head. So you don’t excavate it. You build it from zero, as the company comes into existence. And because it’s being built rather than retrieved, it can do the thing archaeology never can: it doesn’t just record how the company works, it holds a view on whether the company is working. A map tells you where things are. This forms an opinion about a business the founder hasn’t fully figured out yet, and pushes back. That’s not memory. That’s judgment. Memory is for companies with a past. Judgment is for companies that only have a future.
Notice this is the same closed loop, one level down. A company brain that only answers questions is still an open loop, it tells you how your company works, you go act. Close it, and the brain forms the view, drives the action, watches the result, and corrects. The knowledge layer is the substrate. The closed loop is what you do with it. The corpus accreting underneath is what makes it impossible to copy.
“Vertical” was the floor, not the destination
So go vertical, but understand it’s the floor you start from, not the moat itself. Owning “legal” or “finance” isn’t narrow enough to be safe; those are still categories a lab could credibly wave at. The defensibility sits one or two levels below that: in the specific, annoying, regulated-adjacent workflow the labs will never bother to learn the texture of, where closing the loop requires knowing the exceptions that aren’t written down anywhere.
Not “accountancy.” The exact three-statement model a pre-seed founder actually needs, in their jurisdiction, with their messy assumptions, that recomputes when reality moves. Not “founder tools.” The continuous loop of observing a founder, forming a view of their company, and driving the next concrete action without waiting to be asked. That’s a closed loop by construction, and it’s not one a general assistant can ship, because forming an opinion about one company and acting on it is the opposite of being everyone’s safe co-pilot.
The loop underneath the loop
I buried this in the 2024 piece as a single section called “eating our own medicine.” It should have been the whole article. Your first 100 users teach the system things your 101st gets for free, automatically, in a way nobody outside can reconstruct. Every closed loop you run leaves a deposit, the correction a founder made, the exception that broke the template, the pattern that only shows up across hundreds of real companies. That corpus is the only asset on the board a competitor cannot buy, scrape, or prompt their way into. And it compounds.
The orchestration, master agents coordinating sub-agents, is essential. You can’t build a real vertical service without it, and it’s exactly how I’m building Arthur. What I got wrong in 2024 was treating it as the moat. It isn’t. It’s table stakes now, the labs and the frameworks ship the pattern for free. The defensibility was never the conductor. It’s the closed loop the conductor drives, and the corpus that loop is quietly building underneath.
The three objections you’re already forming
If you’ve followed this far you’ve got three rebuttals loaded. Good. Here they are, and here’s why none of them lands.
“Context windows are huge now, just feed the whole company in.” A bigger window makes the model a better reader. It does nothing to make it a writer. You can paste your entire operating history into a million-token context and the model will hand you a brilliant answer, and then the turn ends and nothing in the world changed. It didn’t write the corrected number back, reconcile the three systems that disagree, or commit a change the next turn builds on. Reading context is not owning state. The window lets the model see your business; it never lets it run it. An open loop with an infinite window is still an open loop, it just reads more before it forgets. And every improvement in context size upgrades the cheap, readable half of my loop for free while leaving the expensive half, state, write-back, reconciliatio, exactly where it was.
“Owning liability is ruinous, you’ll pay for every cleanup.” Only if “owning the outcome” means letting a probabilistic model make the consequential decision and then insuring the wreckage. It doesn’t. You earn the right to own the outcome not by being brave enough to absorb the losses, but by building the system so the losses can’t happen: the cap table isn’t generated by a model that might be off by a factor of ten, it’s computed by deterministic code that’s right every time, with the founder signing off the consequential write before it commits. The liability I’ll take on is precisely the liability the labs structurally can’t, because their architecture is the probabilistic thing that makes the number unguaranteeable in the first place. Owning liability isn’t the cost of closing the loop. It’s evidence you closed it properly. (How that architecture works is its own piece, the next one.)
“Pre-seed founders have no money, selling to startups is a graveyard.” It is, for anyone whose startups are the revenue. Mine aren’t. The pre-seed founder is the forge, not the market, the cheapest, most varied training ground there is to perfect the loop, where a founder who fails still leaves their corrections in the corpus. The company dies; the learning doesn’t. And they’re not even the buyer: the accelerators and funds who back them pay, because they want a whole portfolio executing faster, founder as distribution surface, not wallet. The ones who survive don’t graduate off the product onto a “real” enterprise tool; they grow into the enterprise tier of it, because by then the system is their company’s operating history and ripping it out means ripping out their own memory. The graveyard kills tools you can leave. You can’t leave the thing that remembers how your company works.
So, practically
If you’re building in AI right now, the question isn’t “what’s my vertical.” Everyone has a vertical. The question is: where does my loop close, and who else could possibly close it?
If your answer ends in advice, you’ve built a demo, and a model release will end you. If it ends in the work done, owned, with the liability, the exceptions, the write-back, and a corpus accreting underneath that the next customer benefits from for free, then every time OpenAI and Anthropic get better, so do you.
And stop waiting for permission. The reason this opportunity is still open isn’t that it’s hidden, it’s that the engineering is hard and the fear of the labs gives everyone an excuse to flinch. That fear is misplaced. The labs aren’t going to come down into your closed loop; they can’t, without ceasing to be the labs. The only thing standing between you and the moat is whether you’re willing to build the hard thing.
Three pieces, two years, one direction of travel: the old model dies, the new one takes its shape, and the moat turns out to live in the closed loop and the corpus underneath it. I’ve called each step before it was obvious. I’m calling this one too. And this time I’m not just writing it, I’m building it.
Go find the ugliest, most painful, most specific loop you understand better than anyone. Then close it.
For the ❤️ of startups.
✌🏼 & 💙 Derek
Thank you for reading. If you liked it, share it with your friends, colleagues and everyone interested in the startup Investor ecosystem.
If you've got suggestions, an article, research, your tech stack, or a job listing you want featured, just let me know! I'm keen to include it in the upcoming edition.
Please let me know what you think of it, love a feedback loop 🙏🏼
🛑 Get a different job.
Subscribe below and follow me on LinkedIn or Twitter to never miss an update.