For about a year, I held a quiet belief that I'd describe to anyone who'd listen at dinner: vertical agents were a doomed category.
The argument felt airtight at the time. Every "AI for X" product I opened looked the same on the inside — an agent loop borrowed from Claude Code or Codex, a system prompt longer than most blog posts, a handful of MCP servers, a few skill files. The product was a thin shell around a model that someone else trained. And the model kept getting better, for free, every six months.
So I'd say something like: 95% of the value is in the model, 5% is in the wrapper, and the wrapper is a depreciating asset. It sounded like a clean piece of analysis. It got nods. I believed it.
I now think that belief was lazy. Not wrong in the way that contrarians enjoy — half-right, in the most dangerous way, where the math checks out but the variables are mislabeled.
This is what I had to see to change my mind.
The belief I held
The mental model went roughly like this.
A vertical agent — say, a sales-outreach agent, a legal-review agent, a customer-support agent — is, when you strip the marketing away, three things stacked on top of an LLM:
- A loop that reasons, calls tools, and loops again.
- A set of integrations (MCP servers, today) that give it access to email, CRMs, docs.
- A bundle of domain skills — prompt templates, playbooks, evaluator rubrics — encoded as files the loop can read.
None of those three components is hard to replicate. The loop is a commodity now; you can ship one in an afternoon. MCP servers are increasingly off-the-shelf. Skills are markdown files, and Anthropic ships a marketplace.
So when a horizontal agent — Claude Code, Codex, whatever comes next — adds a skills marketplace and an MCP registry, the vertical product's surface area shrinks to "we wrote the prompt." That's the 5%. And prompts don't compound.
Worse, every time the underlying model jumps a generation, the careful prompt engineering the vertical team spent six months on becomes obsolete in a weekend. The model just does the thing now, no scaffolding needed. The wrapper isn't just thin — it's actively eroding.
I thought this argument was strong because I could point at examples. I could open ten Y Combinator demo-day pages in a row and rehearse it.
What broke the frame
The crack came from a product I expected to dislike.
A friend was building what I would have called, dismissively, a "thin wrapper" — an agent for a specific kind of regulated workflow. I sat through a demo prepared to nod politely. The loop was unremarkable. The prompts were fine. If you'd shown me the codebase I would have estimated, accurately, that two engineers could clone the surface in a week.
But I couldn't clone what the product actually was.
The product was an entity that had spent eighteen months getting approved as a vendor inside three Fortune 500 companies. It carried errors-and-omissions insurance underwritten by a real insurer who had read the model card. It had read-write access to systems that don't expose APIs to anyone who hasn't passed a procurement review. When something went wrong, there was a human on a phone, on a SOC2-audited support rotation, with a contract that said "we will pay if we are wrong."
None of that lived in the agent loop. None of it would be ported by switching the underlying model from one provider to another. And — this is the part that finally landed — none of it would be commoditized by Claude Code adding more skills.
I had been reading the wrapper as a piece of software. It was a piece of software and a wrapper around a business. The software part was 5% of the value. The wrapper-around-a-business part was the other 95%.
I had the ratio right and the labels exactly backward.
What I had actually been measuring
Here is what I think the error was, said plainly.
"95% of the intelligence is in the model" is true and getting more true. "95% of the value is in the model" does not follow. They are different axes, and I had collapsed them into one because the words sounded close enough.
The intelligence axis is what gets benchmarked. It's reasoning, code, math, vision, tool use. It belongs almost entirely to the lab that trained the weights, and it cheapens predictably. Anyone betting their product on a slice of this axis is racing a depreciation curve they don't control.
The value axis is different. It's made of things that don't get cheaper when the next model ships:
- Data access. Permissioned reads and writes into systems that don't expose themselves to general-purpose agents. EHRs, ad accounts, internal CRMs, ERPs, legacy databases that require a signed BAA before anyone sees a row.
- Distribution. Being the tool that an industry already buys, already trusts, already has a procurement contract with. Replacing that is a sales motion, not a model upgrade.
- Accountability. Someone to sue, an SLA, an audit trail, regulated entity status, insurance. A horizontal agent cannot grow this by training harder.
- Workflow lock-in. Not the kind that traps users — the kind where the agent's outputs become someone else's inputs, and ripping it out means redoing six adjacent processes.
None of those are reducible to a prompt or a skill file. None of them are on the depreciation curve.
A vertical agent whose moat is on the intelligence axis is, in fact, dead. I was right about that product. I was wrong to extend the verdict to the whole category.
So which vertical agents actually die?
The honest test, I think, is this: if the underlying model became free tomorrow, would this product still have customers?
If the answer is yes, it was never really a wrapper. The model was an input — an expensive, important input — but not the product. The product was the access, the trust, the contract, the integration that took eighteen months to land.
If the answer is no, then yes, it's dead. And the timeline is shorter than its founders think, because every horizontal agent release narrows the moat at the same time the underlying model widens its capability.
The agents that die are a specific subspecies:
- Products whose only differentiation is a clever system prompt.
- Products whose integrations are all on standard, public APIs that a generic agent will also reach.
- Products whose users are individuals making personal purchasing decisions, where switching cost is one cancelled subscription.
- Products whose "domain expertise" is encoded as ten thousand words of markdown that any competitor could rewrite in a weekend.
These are real. There are a lot of them. They are mostly funded. The 95/5 critique was built to describe them, and within that scope it's accurate.
But that scope is a slice of the category, not the category.
The bias I had to notice in myself
There's a particular reason this took me a while to see, and I think it's worth naming.
I spend most of my time looking at consumer-shaped agent products — things you can sign up for in a browser, demo in five minutes, evaluate by vibes. That whole region of the market is mostly 95% model and 5% wrapper, because the customer in that region buys intelligence and nothing else. They don't need anyone to sign a BAA. They don't have a procurement process. They don't have a CISO. Their switching cost is zero.
If your reference set is the consumer-shaped region, the 95/5 frame is approximately correct and it generalizes beautifully — to the rest of the consumer-shaped region. It does not generalize to the regions you weren't looking at.
I had been generalizing from a sample. The sample was the one I happened to use every day.
There's a related bias I had to give up: the engineer's bias that says, if I could rebuild it in a weekend, it can't be valuable. I could rebuild the agent loop in a weekend. I could not rebuild eighteen months of vendor review in a weekend. The thing I couldn't see was the thing that mattered.
What I'd tell past-me
The "everything is a wrapper" frame was sharp because it was simple. Sharp is not the same as correct. The frame collapsed three different axes — intelligence, value, defensibility — into one number, and the elegance of the number was what made me trust it.
The better question to ask a vertical agent isn't "how thick is the wrapper." It's: what does the wrapper own that the model cannot grow into?
If the answer is "a really good prompt," the wrapper is dead and the founders just haven't priced it in yet.
If the answer is "a signed contract with the only buyer in this market, plus the integration nobody else can pass procurement for, plus the insurance, plus the audit log nobody else can produce," then the model getting better is a tailwind, not a threat. Every capability jump makes the same wrapper more valuable, not less, because the bottleneck moves further away from intelligence and closer to the boring parts of being a real company.
Closing thought
Vertical agents aren't dead. The lazy ones are — and they were always going to be. The mistake I made was assuming the lazy ones were the whole category, because they were the ones I'd been looking at.