A new breakdown every week — read the newsletter →
ΘNavigator
PeopleBusinessesToolsNewsletter
StrategiesMental ModelsDecision ToolsBusiness ModelsFrameworksMoats
LearnBook SummariesReading ListsGuidesQuote Collections
Artificial Intelligence Learning PathsWhat should I study? AboutContact
Framework

FRAMEWORK — Vertical AI Agents

Frameworks · Build/opportunity framework (2026-native) · 21 min read

Thesis: The money in AI isn't in building models — it's in building the agent that does one industry's specific, high-value, annoying job end-to-end. Pick a workflow deep in a single vertical, wrap a frontier model in that vertical's data, tools, and guardrails, and sell the outcome, not the software.

1. The idea

A vertical AI agent is a narrow, deep application of a general model to one job, in one industry, done all the way to the finish line. Not "AI for legal" — but "draft, cite-check, and redline this specific type of contract the way this firm does it." Not "AI for healthcare" — but "listen to the visit, write the clinical note, and push it into the EHR." The bet is that the last mile of any real workflow — the domain data, the tool integrations, the compliance, the edge cases, the system of record — is where the value and the defensibility live, and that a general model alone will never traverse it for you.

The framework is a reaction to a hard 2026 lesson: thin wrappers die. A prompt over a chat box gets vaporized the moment the base model ships the same feature for free. What survives is the agent that owns a workflow so specific, so entangled with a customer's data and systems, that swapping it out means re-plumbing the business. The general model is the engine; the vertical agent is the whole car, built for one road.

2. Why it works now (and didn't in 2021)

Three things became true at once: - Models crossed the reliability threshold for real work in bounded domains. A 2023 model could draft; a 2026 model can draft, use tools, check its own work against sources, and act — well enough that a professional will let it touch the workflow. - The cost of the intelligence collapsed while its capability rose, so the unit economics of "let the agent do the whole task" finally close. - The buyer's frame flipped from software to labor. Enterprises stopped asking "what tool should my team use?" and started asking "what work can I hand off?" That reframe is worth trillions, because a labor budget dwarfs a software budget — and a vertical agent is sold against the labor line, not the SaaS line.

The window is a classic Takeoff-stage opportunity: the vertical is being defined right now, and the agent that establishes the workflow, the data loop, and the system-of-record relationship first will be very hard to dislodge later. Miss it and the share gets expensive forever.

3. The anatomy of a vertical agent (what you're actually building)

A defensible vertical agent is a stack, and the model is the least proprietary layer:

  ┌─────────────────────────────────────────────┐
  │  OUTCOME / SYSTEM OF RECORD  ← the moat       │  owns the workflow + data of record
  ├─────────────────────────────────────────────┤
  │  GUARDRAILS · EVALS · COMPLIANCE              │  domain-specific correctness + liability
  ├─────────────────────────────────────────────┤
  │  TOOLS · INTEGRATIONS · ACTIONS              │  it *does* the job, not just talks about it
  ├─────────────────────────────────────────────┤
  │  PROPRIETARY / WORKFLOW DATA                  │  the non-substitutable fuel
  ├─────────────────────────────────────────────┤
  │  FRONTIER MODEL (rented, swappable)          │  the commodity engine
  └─────────────────────────────────────────────┘

The strategic instruction that falls out of this diagram: build up from the bottom, but defend from the top. Anyone can rent the model. Your durability comes from the data only you have, the integrations only you've built, the correctness bar only you've earned, and — above all — becoming the system where the work is recorded.

4. How to run it — the build sequence

  1. Pick a workflow, not a vertical. "Legal" is a market; "cite-checking litigation briefs" is a wedge. Choose a job that is (a) high-value, (b) repetitive, (c) currently done by expensive humans, and (d) bounded enough that correctness is checkable.
  2. Find the pain that's also measurable. The best wedges have a number attached — hours saved, tickets resolved, claims processed, revenue recovered — because that number becomes your pricing and your proof.
  3. Get the proprietary data. Design partners, private corpora, real-world outcome data — whatever a general model can't acquire off the shelf. This is the fuel that makes your last-mile better than a raw model's.
  4. Wrap the model in tools and integrations. The agent must act: read and write the systems of record, call the APIs, move the work forward. Talking is table stakes; doing is the product.
  5. Build the guardrails and evals as a first-class product, not an afterthought. In regulated verticals, correctness and liability are the moat. The agent that can prove it's right (and safe) wins the deal the flashier demo loses.
  6. Sell the outcome; price on it. Land against the labor budget, not the software budget. Where you can, meter on resolutions/outcomes so your revenue tracks the value and your quality gains become growth (see the Usage-Based / AI-Metered business model).
  7. Become the system of record. Once the work runs through you and lives in you, switching means re-plumbing the business — and your wedge has become a moat.

5. Worked example — a claims agent in insurance

  • Workflow, not vertical: not "AI for insurance," but "intake, triage, and adjudicate first-notice-of-loss for auto claims."
  • Measurable pain: each claim costs $X in adjuster time and days of cycle time; both are trackable.
  • Proprietary data: partner with three carriers to train on their historical claims and outcomes — data no general model has.
  • Tools/actions: the agent reads the claim, pulls policy data, checks the fraud signals, drafts the adjudication, and writes it back into the claims system.
  • Guardrails: every decision is explainable and audit-logged; edge cases escalate to a human; the compliance layer is the pitch.
  • Pricing: per adjudicated claim, priced far below the loaded human cost — so the carrier saves money and you capture a slice of the saving.
  • Moat: after a year, the carriers' claims run through you and are recorded in you. Ripping you out means rebuilding the claims pipeline. The general model that could "do insurance" can't do this — it lacks the data, the integrations, the audit trail, and the trust.

6. Where it wins

  • High-value, high-volume, checkable work — support, coding, claims, clinical documentation, legal drafting, sales development, accounting reconciliation.
  • Regulated or liability-heavy domains — where correctness, audit trails, and compliance are hard for a horizontal tool to match, so the vertical specialist's guardrails become the differentiator.
  • Fragmented professional markets — lots of firms doing the same job slightly differently; the agent that encodes the best practice sells to all of them.
  • Wherever the buyer thinks in labor, not tools — because the agent competes against a salary, which is a far bigger and less price-sensitive budget than a software line item.

7. Traps & failure modes (why most vertical agents die)

  • Thin-wrapper risk ("the model ate my feature"). If your whole product is a prompt and a chat box, the next base-model release is your obituary. Defend with data, integrations, workflow ownership — not cleverness.
  • Demo-to-reliability gap. A vertical agent that's 95% right is often worse than useless in a domain where the 5% is a lawsuit. The last few points of reliability are the whole job, and they're the expensive part.
  • Distribution, not model, is the bottleneck. In regulated verticals the hard part is trust and procurement, not tokens. Founders who fall in love with the model and ignore the sales motion lose to worse products with better distribution.
  • Building horizontal by accident. The pull toward "let's also do the adjacent workflow" dilutes the very depth that made you defensible. Win the one job completely before you expand.
  • Owning the outcome you can't control. Outcome pricing is powerful, but if you're paid on a result that depends on factors outside the agent (the customer's data quality, their process), you can deliver perfectly and still not get paid. Define the outcome you actually control.
  • Liability you didn't price. In healthcare, law, and finance, being wrong has legal weight. If your guardrails and human-escalation aren't first-class, one bad output can end the company.

8. Real examples (2026)

Vertical agents are the dominant AI-application pattern of the moment, one deep workflow at a time: legal (contract and litigation drafting/review), healthcare (ambient clinical documentation that writes the note and files it into the EHR), customer service (Sierra, Decagon, Intercom's Fin — resolving tickets end-to-end and priced on resolution/outcome), sales development (agents that research, draft, and sequence outreach), coding (agents that read the repo, write, test, and open the PR), and accounting/finance (reconciliation and close automation). The through-line: each owns one professional workflow, integrates with that profession's systems of record, and increasingly gets paid per outcome rather than per seat.

9. Related frameworks & mental models

  • Business-model arbitrage / Wrap-a-model (framework) — applying a new capability to an old workflow before the old-workflow incumbents adopt it.
  • Niche down (framework) — the discipline of winning one narrow workflow completely.
  • Counter-Positioning (moat) — the incumbent SaaS vendor can't fully adopt outcome-priced agents without cannibalizing its seat revenue; that's your opening.
  • Switching Costs & Data/AI Network Effects (moats) — the two powers a vertical agent is trying to build via system-of-record ownership and proprietary-data loops.
  • Do Things That Don't Scale (mental model) — how you get the first design-partner data and the first trust.
  • Usage-Based / AI-Metered Pricing (business model) — the native monetization for this framework.
  • Jagged Frontier / Bitter Lesson (2026 mental models) — why you build around the model's uneven capabilities rather than betting your moat on beating it.

10. Analyst's Take

The vertical-agent gold rush is real, but the graveyard is filling just as fast, and the dividing line is almost always the same: depth of last-mile ownership. The winners look boring from the outside — they've spent eighteen months on integrations, evals, and compliance in one unglamorous workflow, and they've become the place the work is recorded. The losers had a better demo and a thinner moat.

Three convictions:

First, the model is the commodity; act like it. Founders fall in love with the intelligence layer, which is precisely the layer they don't own and can't defend. Assume the base model gets better and cheaper and swappable, and put every ounce of proprietary effort into the layers above it — data, tools, guardrails, and workflow ownership. If your competitive advantage would evaporate the day a frontier lab ships an update, you don't have one.

Second, sell against the labor budget, and mean it. The reason vertical agents can be enormous businesses is that they're priced against salaries, not software. But that framing is a promise: you are claiming to do the work, which means you inherit the standard — the correctness, the accountability, the escalation path a human professional would provide. The companies that treat "we replace the labor" as a marketing line rather than a product spec are the ones whose 5% failure rate becomes a lawsuit.

Third, get to system-of-record or get out. A vertical agent that merely assists is a feature; one that owns the workflow and the data of record is a company. The whole strategic arc is to start as a helpful tool at the edge of a workflow and end as the place the workflow lives. Everything — the design partners, the integrations, the outcome pricing — should be pointed at that one destination, because that's the only place the moat actually is.

11. 2026 and beyond

Expect the pattern to eat one professional workflow after another, moving from the checkable, high-volume jobs (support, coding, documentation) into the higher-stakes, judgment-heavy ones (adjudication, diagnosis, advisory) as reliability and trust catch up. Expect agent-to-agent workflows — your vertical agent calling another company's vertical agent — to become the new integration surface, and whoever owns the system of record to sit at the center of it. Expect a consolidation as the base-model tide lifts the thin players out and leaves the deep ones standing. And expect the enduring question to be the one this framework is built around: not "can the model do it?" — increasingly it can — but "who owns the last mile, the data, and the place the work is recorded?" That ownership, not the intelligence, is the business.

12. Top Resources

  1. "Software Is Eating the World" → "AI Is Eating Software" — the a16z line of argument. The clearest framing of why the value moves to applications, not models.
  2. Public post-mortems on thin AI wrappers (2024–25). The best negative examples of what happens without last-mile ownership.
  3. The 7 Powers — Hamilton Helmer. For mapping a vertical agent's wedge to a durable moat (Counter-Positioning, Switching Costs, Network Economies).
  4. The Cold Start Problem — Andrew Chen. For getting the first design partners and data before the loop self-sustains.
  5. Vendor engineering blogs on evals & guardrails in regulated verticals. The state of the art on the correctness layer that actually wins enterprise deals.