There is a meeting that every Agent Architect walks into in 2026, sometimes more than once a quarter. The CFO has the slide deck. The CRO has the wishlist. Procurement has the Sierra term sheet, the Decagon proposal, the Glean enterprise quote, the Harvey license PDF, and a half-finished build estimate from the platform team. Everyone is looking at the architect. The question on the table is the oldest question in enterprise software dressed up in 2026 vocabulary: do we build on a workflow platform, do we buy a vertical agent that has already done the hard work in our domain, or do we compose — buy the vertical for the 80% it does well and build the 20% it cannot reach? The wrong answer costs eighteen months, several million dollars, and a credibility hole the program does not climb out of. The right answer is not a preference. It is a math problem with a few hard rules. This lesson is the math, the rules, and the three case studies that show what each path looks like when it works and when it breaks.

The Three Paths and Why the Question Is Not Binary

For a decade, enterprise software bought-vs-built. AI agents added a third path that did not exist for SaaS — composability. The path matters because each path has a different cost curve, a different time-to-value, a different risk profile, and a different exit cost.

Build on a workflow platform

You take a horizontal platform — n8n, Lindy, LangGraph on AWS, a custom stack on top of Vercel's AI SDK, or a vendor-native shell like Salesforce Agentforce or Microsoft Copilot Studio — and you assemble the agent yourself. You write the prompt. You wire the tools. You define the eval set. You own the runbook.

Cost shape: high upfront engineering, low marginal cost per request. Time to value: 3-9 months for the first production agent. Exit cost: you own the IP; the migration cost is mostly tool re-wrapping and prompt rewrites (see lesson 4). Risk: the agent is only as good as your team's craft. If the team is junior, the agent is junior.

Buy a vertical agent

You write a check to Sierra (customer service), Decagon (support and concierge), Clay (GTM and outbound), Glean (enterprise search), Harvey (legal), Hebbia (financial research), or any of the 40-odd vertical agent vendors that closed Series B funding by Q1 2026. They bring a pre-trained agent, an integration playbook for your stack, a domain-aware eval suite, and an SLA. You configure the persona, plug in the data, and ship in weeks.

Cost shape: high per-conversation or per-seat license, low engineering. Time to value: 4-12 weeks for the first production deployment. Exit cost: high — you do not own the prompts, the tool wrappers, the eval sets, or the fine-tunes. The migration cost is rebuilding the whole thing. Risk: vendor lock-in and the price-pressure curve at year three.

Compose

You buy the vertical for the workload it does best and you build the satellite agents around it. Sierra handles tier-1 and tier-2 customer service; you build a Lindy agent on top to handle the back-office workflow that escalations trigger. Glean indexes the enterprise corpus; you build a custom agent on top of Glean's search API for the executive-briefing workflow that has formatting and brand requirements Glean cannot meet. Harvey drafts the contract; you build the diligence-tracking agent that lives in your DMS.

Cost shape: license + engineering. Time to value: 6-16 weeks across the composition. Exit cost: lower than pure-buy because you own the composition layer. Risk: integration complexity, vendor API change.

The most common mistake in 2026 is to treat build-vs-buy as the question. The real question is which workload sits in which path. Most departments end up in the compose pattern not because they planned it but because that is what the math forces them into after the second or third decision.

The 100K Units-Per-Month Break-Even

This is the number that came out of the 2025-2026 data and the number you will quote in every meeting for the next two years. Below 100,000 units per month (conversations, tickets, queries, drafts — pick the unit that matches the workload), vertical buy is cheaper than horizontal build for the same outcome. Above 100,000 units per month, horizontal build catches up, and somewhere between 100K and 250K it overtakes.

The math is straightforward when you write it out. Take a customer service workload at 80,000 conversations per month. Sierra in 2026 sells at roughly $1-$2 per resolved conversation for enterprise contracts (the public-anchor prices, your real number depends on volume, deflection guarantee, and competitive pressure from Decagon). Call it $1.40 blended. That is $112,000/month for the vendor, or $1.34M/year. The build alternative on a horizontal stack: $0.04-$0.12 of LLM cost per conversation depending on model mix and tool calls (call it $0.08), $6,400/month in tokens. Plus platform: $5K/month for the agent platform, observability, and proxy. Plus engineering: a team of three (one senior agent engineer, one ML/eval engineer, one integration engineer) at fully loaded $250K/year each, so $62,500/month. Plus on-call rotation, eval review, prompt iteration. Total horizontal cost month-over-month after the build is done: ~$80K/month. Build cost amortized over 24 months: roughly $40K/month for the first nine months, declining to $80K/month steady state.

At 80K conversations: buy at $112K/month vs build at $80K/month steady state. Build wins by $32K/month — but only after the 9-month build is done. The break-even for the build is around month 14 when the cumulative cost overtakes the cumulative buy spend.

Now scale it. At 200,000 conversations/month: buy at $280K/month vs build at $96K/month (tokens scale, platform doesn't). Build wins by $184K/month. Break-even at month 5.

At 30,000 conversations/month: buy at $42K/month vs build at $74K/month steady state. Buy wins. Build never breaks even at this volume.

That is the curve. The exact crossover depends on your model mix, your tooling, and the deflection guarantee in the vendor contract. But the shape is consistent across the data: between 80K and 120K units per month is the buy-vs-build inflection. Pick 100K as the heuristic. Quote it in the meeting.

What the break-even hides

The 100K number is the cost break-even. It is not the right answer break-even. Several factors push the answer in either direction independent of unit volume.

• Time to value. If the agent has to ship in 60 days to meet a board commitment, buy wins regardless of cost. The build does not exist at month two.
• Domain depth. If the vertical vendor has 18 months of training data, fine-tuned models, and pre-built integrations for your domain that you cannot replicate, the quality gap may justify a permanent price premium. Harvey's legal-grounding is the canonical example.
• Engineering supply. If you cannot hire three senior agent engineers in your region for the salary you have authorized, the build math is theoretical. Buy is the only real option.
• Strategic IP. If the agent is a differentiator for your product (the agent is the product, not internal tooling), you build. The buy path gives the vendor a wedge into your customer relationship.
• Eval and compliance burden. Some regulated workloads (clinical, legal, financial advisory) require an eval and audit trail that a vendor's stack ships with by default but that you would have to build from scratch. The compliance work alone can equal the engineering work.

The Vertical Agent Landscape in May 2026

Naming names so the rest of the lesson lands. The vertical-agent market in May 2026 has roughly five horsemen and a long tail. The horsemen are the ones a CFO has heard of. The long tail is where you find domain-specific tools that often beat the horsemen for narrow workloads.

Sierra — customer service

Founded by Bret Taylor and Clay Bavor. Series C closed at $4.5B valuation in late 2025. The dominant vertical for tier-1 and tier-2 customer service deflection at enterprise scale. Strong voice and chat. Pricing model: per-resolved-conversation, typically $1-$2 enterprise blended. Best-fit customer: high-volume B2C support (telco, retail, fintech, marketplace).

Decagon — support and digital concierge

Series C at $4.5B valuation, also closed in late 2025. Direct competitor to Sierra with slightly different positioning around customer experience and digital concierge (proactive outreach, account management agents alongside reactive support). Pricing similar to Sierra. Best-fit: brands where customer engagement is a profit center, not a cost center.

Clay — GTM and outbound

The category leader for sales prospecting and outbound agents. Combines data enrichment (Apollo, ZoomInfo, custom scrapers), researcher agents, and outbound personalization. Pricing model: credit-based, $349/month entry, enterprise contracts in the $50-$200K range. Best-fit: sales orgs with a defined ICP and a hungry SDR team.

Glean — enterprise search and knowledge agent

Sells the enterprise search layer and the agent platform that sits on top. Indexes every enterprise system the employee touches. Strong permission-model story. $40-$50 per user per month at enterprise scale. Best-fit: companies with sprawling knowledge across SaaS systems where employees waste time searching.

Harvey — legal

The legal vertical agent. Strong in contract drafting, diligence, research, and litigation workflow. Used at most of the Am Law 100 firms by Q1 2026. Pricing premium — enterprise contracts in the $200-$600K range. Best-fit: law firms and corporate legal departments where the workflow is structurally legal.

The long tail

Hebbia for financial research. Bardeen and Ema for ops automation with vertical depth. Cresta and Observe.AI for call-center coaching. Cognosys and Lindy for citizen-developer-built agents in horizontal but managed spaces. EvenUp for personal-injury law specifically. Spellbook for contract drafting (mid-market alternative to Harvey). The long tail is where you find the right answer for a narrow workload that the horsemen treat as a feature.

The Decision Framework: Five Questions

The framework. Run it for each workload. The answers compose into a build, buy, or compose recommendation.

Question 1: What is the unit volume?

Below 30K units/month: buy. The build math does not work at this volume; you cannot amortize the engineering. 30K-100K units/month: usually buy, sometimes compose. 100K-300K units/month: compose or build. Above 300K units/month: build, with vertical-buy as a fallback for new workloads while you build.

Question 2: Does the vertical agent exist and is it production-credible for your domain?

Some workloads have a clear winner (Harvey for legal contract draft, Sierra/Decagon for customer service, Clay for outbound). Some workloads are still horizontal-build territory because the vertical agents are immature (most engineering and IT workflows). If the vertical agent does not exist or is below quality, you build. If you have a real choice, run the rest of the questions.

Question 3: How fast do you need to ship?

If shipped-in-60-days is a hard constraint, buy. If shipped-in-six-months is acceptable, build or compose. If the agent is part of a regulatory deadline (in-house counsel agent for the new SEC disclosure rule, KYC agent for a banking deadline), buy almost always wins on the timeline.

Question 4: How strategic is the workload?

If the agent is internal tooling (customer service, ops, internal IT), the strategic case for build is weak. If the agent is part of the product the company sells (in-app assistant, customer-facing concierge that drives revenue), the strategic case for build is strong. The vertical vendor sees your customer data; your CIO has feelings about that.

Question 5: What is the exit cost you are willing to accept?

Buying creates lock-in proportional to the depth of the integration. Sierra holds your conversation logs, your custom flows, your fine-tunes. Migrating off Sierra in year three is a six-month project at minimum. Buying with eyes open is fine. Buying without an exit plan is malpractice. Lesson 4 covers the migration cost math in detail.

Case Study One: The 150K-Conversation Fintech That Bought Sierra

A consumer-fintech with 4M customers, growing 80% year-over-year, was running 150,000 support conversations/month across email, chat, and voice. The agent program was 18 months old. The internal team had built a horizontal agent on top of a major LLM with a custom RAG stack. It was solving 22% of tier-1 conversations cleanly. The CFO wanted 60%. The CRO wanted shipping in 90 days.

The architect ran the framework. Volume: 150K, above the break-even — build math could work. Vertical agent existence: Sierra was credible for the domain. Time to ship: 90 days, too tight to rebuild the agent from scratch. Strategic: support was a cost center, not the product. Exit cost: high but tolerable for a workload they were not currently doing well.

They bought Sierra for tier-1 and tier-2 conversation handling. They kept their internal team focused on tier-3 escalation tooling and the agent-to-agent handoff. Sierra deployed in 11 weeks. Deflection in month four hit 54% (against the 60% target). License cost: $186,000/month against an internal team cost of $94,000/month plus tokens. The CFO winced. But the savings on outsourced human agents ($340,000/month before Sierra) more than covered it. Net annual savings: $1.8M.

The story did not end there. By month 14 the architect was already running the migration-readiness review (see lesson 4). The plan: keep Sierra for two more years while building a horizontal-stack alternative in parallel for the workloads where Sierra's margin was unjustified. Year three vendor negotiation would be informed by a credible build-in-flight.

Case Study Two: The Mid-Market SaaS That Built on Lindy

A 400-person B2B SaaS company. The CTO wanted an internal IT agent — password resets, license provisioning, SSO troubleshooting, employee onboarding. Volume: 4,000 tickets/month. Time horizon: nice to have, not on the board's radar. Engineering bandwidth: one senior developer at 50% time for two quarters.

Volume below 30K screams buy. But the vertical agent for internal IT (Moveworks, Espressive, the long tail) was priced for enterprises and demanded six-figure annual contracts even at this volume. The math made vertical buy a non-starter at $4K/month worth of tickets.

They built on Lindy. Configuration time: nine weeks at half-utilization. Deflection at month three: 41% of tier-1 IT tickets. License cost: $480/month for Lindy at this scale plus $200/month in tokens. Total: $680/month against $7,500/month in IT agent salary previously dedicated to tier-1. Net savings: $6.8K/month. Build break-even: month 3.

The lesson: below the volume break-even, the right tool is usually a horizontal platform built by a small team, not a vertical buy. The vertical agents are not priced for mid-market workloads; the math forces the horizontal build.

Case Study Three: The Asset Manager That Composed

A $40B AUM asset-management firm. Five distinct agent workloads identified in the program plan: legal contract review, financial research/diligence, internal compliance Q&A, IT helpdesk, and client communications. Volume varied wildly across workloads — legal at 800/month, financial research at 12K/month, compliance at 2K/month, IT at 8K/month, client comms at 90K/month.

The architect refused to make one decision. Workload by workload:

• Legal contract review: bought Harvey. Volume too low to justify build; Harvey's legal-grounding eval beat anything an internal team could replicate inside a year.
• Financial research/diligence: bought Hebbia, layered a custom agent on top for the firm's proprietary research template. Pure compose pattern.
• Internal compliance Q&A: built on Glean. Glean indexed the policy corpus; a custom Glean Apps agent answered employee questions with citations. Compose, leaning on the platform.
• IT helpdesk: built on Microsoft Copilot Studio. The firm was M365-heavy; the data gravity made Copilot Studio the only sensible choice for IT (see lesson 2).
• Client communications: built on a horizontal stack with LangGraph and a custom eval suite. The workload was strategic, customer-facing, and 90K/month — right at the build break-even and strategically important enough to own.

Total annual cost across five workloads: $2.1M (license + engineering + tokens + observability). Estimated cost if they had bought a vertical for everything: $3.4M. Estimated cost if they had built everything from scratch on a horizontal stack: $2.8M (with 14-month delivery instead of 7). The compose pattern won on both cost and timeline.

This is the typical outcome at enterprise scale. The architect who insists on a pure build or a pure buy is usually wrong by 30-50%. The architect who composes per workload is usually right within 10%.

When Build Still Wins Even Below the Break-Even

The 100K break-even is necessary but not sufficient. There are conditions where build wins at lower volume.

The agent is the product

If you sell the agent to your customers — your product is an in-app assistant, a copilot, a domain-specific concierge — you build. The vertical vendor cannot become a part of your product without becoming a strategic threat. The economics flip because the agent is generating revenue, not deflecting cost.

The data is the moat

If your competitive advantage is proprietary data — a unique corpus, transaction history, a relationship graph the vertical vendor cannot replicate — you build. Letting the vertical vendor train on your data weakens the moat. Letting them not train on your data weakens the agent.

The workload is novel

If the workload does not map to any existing vertical agent, you build by default. There is no vertical to buy. The framework collapses to build-or-not-build.

The cost of error is asymmetric

If the cost of an agent error is catastrophic (regulatory, safety, customer-trust), you may need control over the eval, the prompt, and the fine-tune that a vertical vendor will not give you. You build because you have to own the failure modes.

The Compose Pattern Is the 2026 Default

The pattern most enterprises will land on by Q4 2026 is not build and not buy. It is compose. You buy the verticals for the workloads that have a credible vertical (customer service, legal, GTM, enterprise search). You build the satellite agents on a horizontal platform for the workloads that do not (internal ops, custom workflows, novel domains). You own the orchestration layer that routes work between them.

What composition looks like architecturally

An orchestrator-router agent (built on LangGraph, CrewAI, or your platform of choice — covered in lesson 4.2.1) at the top. It receives the work item, classifies the intent, and routes it. Sierra handles the customer service. Glean handles the enterprise search. Harvey drafts the contract. A custom Lindy agent handles the back-office workflow. Each agent has its own eval suite, its own runbook, its own SLA. The orchestrator handles the handoffs.

The compose pattern's risk: API contract management

You are now managing five vendor APIs, each with its own version cadence, its own breaking-change policy, its own pricing curve. The integration layer is the place where the compose pattern can break expensively. Treat the integration tools (the wrappers that talk to Sierra, Glean, Harvey, etc.) as first-class code that you version, test, and own. MCP servers (covered in lesson 1.3.6) are the 2026 way to normalize this surface area.

The compose pattern's gift: incremental migration

When Sierra raises your renewal 60% in year three, you do not migrate the whole program. You migrate the one workload that no longer makes sense, and you negotiate with Sierra knowing you can credibly walk on one workload at a time. The compose pattern is the architecture that gives you negotiating leverage at renewal. Pure-buy gives the vendor the leverage.

How to Present the Decision to the CFO

The CFO does not want your 80-slide framework. The CFO wants three numbers and a recommendation.

1. Total cost of ownership over 24 months for the path you recommend, with a +/-20% confidence band. Lesson 3 is the full TCO model.
2. Time to first value in weeks, with the assumptions that make that number real.
3. Exit cost if the path turns out to be wrong, expressed as months of work and dollars to migrate. Lesson 4 is the migration model.

Then a single sentence: "I recommend X because at our volume and timeline, the alternatives are 30% more expensive over 24 months and ship 8 weeks later, and I have a credible migration plan if X stops being right in year three." That is the architect's answer. Everything else is supporting evidence.

Failure Modes to Avoid

The "we'll build it ourselves" trap

Pride is not a procurement strategy. If a vertical agent exists, is mature, and serves your volume, the build that "we could do better" is almost always 50% over budget and six months late. Use the framework, not the ego.

The "let's just buy the vendor" trap

The vendor demo looks magic because the vendor controls the demo. Production looks different. The vendor's eval suite is calibrated for the vendor's standard customer; your customer base will be 15% off in ways the demo did not show. Always pilot on a meaningful slice (10K real conversations minimum) before signing the multi-year deal.

The "we already bought Salesforce so we have to use Agentforce" trap

Existing platform investments create gravity but do not dictate decisions. Agentforce makes sense when Data Cloud is the agent's primary data source and the workload is Salesforce-native. It is a bad choice for workloads outside the Salesforce data gravity. Lesson 2 unpacks this in depth.

The "compose everything from day one" trap

Compose is the destination for most enterprise agent programs, not the starting point. Start with the highest-value workload, build or buy the right answer for it, ship it, learn what you got wrong, then add the second workload. Architects who try to design the full compose stack in the first quarter ship nothing in the first year.

Key Takeaways

• The build-vs-buy-vs-compose decision is per workload, not per program. Most departments end up in compose by accident; the good architects end up there by design.
• The 100K units-per-month break-even is the heuristic. Below it, vertical buy almost always wins on cost. Above it, build can catch up. Between 80K and 120K is the inflection band.
• Five questions: unit volume, vertical credibility, time to ship, strategic importance, exit cost. Run them per workload.
• The vertical-agent horsemen in May 2026: Sierra (customer service), Decagon (support/concierge), Clay (GTM), Glean (enterprise search), Harvey (legal). Sierra and Decagon at $4.5B valuations is the price you pay for the deflection numbers.
• Compose is the 2026 default for enterprise. Buy the verticals where they win, build on horizontal platforms where they do not, own the orchestration layer.
• Strategic IP, novel workloads, asymmetric error cost, and proprietary data moats can override the cost math. The agent is not always a cost decision.
• The CFO answer is three numbers (24-month TCO, time to first value, exit cost) and a single-sentence recommendation. Everything else is appendix.
• The failure modes are pride (build it ourselves), demo-blindness (buy the vendor), data-gravity captivity (Agentforce because Salesforce), and over-engineering (compose everything from day one).