Build vs Buy AI Agents: The TCO Math Nobody Shows You

Why do vendors' build-vs-buy numbers disagree by 100x?

Because each vendor's threshold sits where its pricing model needs it. Fin, which sells per-outcome AI agents, says building only breaks even around one million conversations a month. OpenNash, which sells custom builds, says custom wins above ten thousand. That is a 100x disagreement about the same decision — and neither side publishes a formula you can check.

Here is the buy side. Intercom — rebranded as Fin — published its position in February 2025, in a post by Darragh Curran:

"To make the previous example more realistic, I've factored in a conservative $50,000/month for an engineering team to own this. To just break even on ROI, you'll need to match the performance of best-in-class tools you can buy and you'll need massive volume (approximately one million conversations per month) to offset the ongoing costs of your team."

And here is the build side. OpenNash, an agency that sells flat-retainer custom agents, published the opposite in April 2026:

"Above 10,000 support interactions per month, custom builds win on a three-year basis in nearly every scenario."

One of these numbers is off by more than an order of magnitude. Possibly both. The rest of this article derives the crossover from published prices and public wage data, with every assumption labeled, so you can rerun it with your own inputs.

One disclosure before the math. Visione Edge sells custom agent engineering, and we also build Visione Flow, an agent platform. We make money on either answer to this question. That is precisely why the formula below is published with every input visible: you should not have to trust us — or them.

What does "build vs buy" actually mean for AI agents?

Buying an AI agent means paying a vendor a subscription or per-outcome fee for a hosted agent you configure but don't own — pricing scales with usage, and the vendor carries maintenance. Building means paying engineers a fixed cost to create and operate an agent you own — usage barely moves the bill, but the engineers never stop being paid. The crossover is where usage fees outgrow payroll.

The same arithmetic governs the wider decision — custom AI solution vs off-the-shelf platform, build vs buy for AI tools generally. Agents just make the fee side unusually measurable, because vendors price them per outcome.

That framing matters because almost every page ranking for this question is written by someone selling one side of it. Dust's contribution to the genre is literally titled "What 1,000+ enterprise deployments taught us about the real costs" — a buy-tilted piece by a platform vendor, with no crossover math in it. The build-side agencies do the mirror image. Calculators exist off the search results, but no page ranking for these queries publishes a neutral, source-cited crossover formula. So here is one.

What does buying an AI agent actually cost?

The cleanest published example is Fin's outcome-based pricing: $0.99 per resolution, procedure handoff, or disqualification, $9.99 per qualification, with a 50-outcome monthly minimum and, per its pricing page, no setup or platform fees. You pay for results, not seats. At meaningful volume the bill is effectively outcomes × $0.99 — which is the entire buy side of the crossover formula.

All figures below are from Fin's live pricing page, retrieved July 4, 2026. Fin bills one outcome per conversation, even when the agent takes several actions.

Two dated caveats. First, Salesforce signed a definitive agreement to acquire Fin for $3.6 billion on June 15, 2026; the deal is expected to close in the last quarter of Salesforce's 2027 fiscal year — early calendar 2027 — and hasn't closed as we write. Pricing under new ownership is anyone's guess, which is itself an argument this article makes later: a buy decision includes the vendor's future, not just its rate card. Second, per-outcome pricing varies across the market. OpenNash's own comparison uses $1.50 per resolution as a conservative cross-vendor average, with quoted rates from $0.99 to $5.00 — treat Fin's $0.99 as the aggressive end, not the market.

We use Fin because its price is public, per-outcome, and load-bearing for its own one-million-conversation claim. Prices on this page carry retrieval dates, and we re-verify them on a scheduled refresh; if the numbers have moved when you read this, the formula still holds — swap in current prices.

What does building an AI agent actually cost?

Building has two very different cost lines. The fixed line is engineering: the U.S. Bureau of Labor Statistics (BLS) median software developer wage was $133,080 in May 2024, which at a 1.4x fully-loaded multiplier (our labeled assumption — benefits, payroll taxes, tooling) is roughly $15,500 per month for one engineer. The marginal line is inference, and it is almost comically small: about a cent per conversation at July 2026 prices.

Here is the cent, shown rather than asserted. We modeled the scripted booking conversation from our public Flow demo — a WhatsApp appointment request, an availability check against a calendar tool, a slot offer, a confirmation — as four model calls with a 472-token system prompt and tool schemas, context re-sent on every call (no caching, which overstates cost). Counted with tiktoken, OpenAI's open-source token-counting library (o200k_base encoding): 2,663 input tokens and 190 output tokens, roughly 2,850 tokens per booked appointment.

Model prices are from the live Anthropic and OpenAI pricing pages, both retrieved July 4, 2026. Our token count is a modeled figure, not a production measurement — tokenizers differ between providers, and real traffic includes retries and off-script turns. It cross-checks well against Anthropic's own published example of ~3,700 tokens per support conversation (about $37 per 10,000 tickets on Haiku 4.5). Note that these prices move: Anthropic's Sonnet 5 currently carries introductory pricing of $2/$10 per million tokens through August 31, 2026, rising to $3/$15 after.

Call the marginal cost $0.01 per conversation — roughly three times the Haiku-class figure, within a rounding error of even Sonnet 4.6's $0.011 — and hold it fixed in every calculation below. Add infrastructure: OpenNash budgets $18,000 over three years — $500 a month — for hosting and monitoring in its build scenario, a figure we adopt here as the published reference point. Everything else is payroll. What a custom build costs upfront — discovery, integration, the first three months — is its own topic, and we've priced it separately.

Where is the real crossover point?

At Fin's published $0.99 per outcome and an 80% billable-outcome rate, a build carried by one loaded engineer reaches fee parity near 20,000 conversations a month. A half-time engineer moves that to about 10,000; Fin's own $50,000-a-month team assumption moves it to roughly 64,000. None of these is one million, and only the leanest case touches 10,000. Both vendors' numbers sit at the edges of the defensible range.

The formula is one line. Let E be your monthly all-in engineering cost, r the share of AI-handled conversations that produce a billable outcome, and c the marginal cost per conversation ($0.01 from the previous section). Monthly fee parity sits at:

V* = E ÷ (0.99 × r − c) conversations per month.

Crossover volume in AI-handled conversations per month. Cell basis: $0.99/outcome is Fin's published price (retrieved 2026-07-04); c = $0.01/conversation is our rounded working figure (modeling method in the previous section); E and r are reader-supplied — the BLS anchor and the 1.4x loading are labeled assumptions, not measurements. Divide every cell by ~10 for lead-qualification workloads billed at Fin's $9.99 outcome.

Now the worked example, in dollars over three years. Take a support-and-booking agent handling 10,000 conversations a month, with 80% producing a billable outcome. Buying on Fin costs 10,000 × 0.8 × $0.99 = $7,920 a month — $285,120 over three years. Building with one full-time engineer costs $15,500 + $500 infrastructure + $100 of inference (10,000 × $0.01) = $16,100 a month — $579,600 over the same period. At this volume, buying wins by roughly 2x, and OpenNash's "custom wins above 10,000" only survives if your entire build-and-babysit operation fits in half an engineer.

Triple the volume and the story flips. At 30,000 conversations a month, Fin's fees are $23,760 a month — $855,360 over three years — while the build's costs barely move: $16,300 a month, $586,800 total. The build now saves about $268,000, and every additional conversation widens the gap.

Assumptions as in the sensitivity table: r = 80%, c = $0.01, infrastructure $500/month (OpenNash's published build budget), engineering at $8,000 or $15,500/month. Upfront build cost excluded — add yours to the build column.

Against the two vendor claims, the math adjudicates roughly down the middle. Fin's one-million-a-month break-even doesn't follow from its own $0.99 price and $50,000 team — fee parity for that team lands at 51,000–86,000 conversations a month across the table's full 100–60% outcome-rate range, more than 10x lower. OpenNash's 10,000 threshold holds only in its cheapest-possible-build scenario. The honest crossover for most teams is in the tens of thousands of conversations per month. And past roughly 50,000 conversations a month, the fee line alone — $39,600 at an 80% outcome rate — exceeds the entire monthly cost of a two-engineer build operation ($32,000): above that volume, building usually wins on fees alone.

Build vs buy is a staffing decision wearing a technology costume.

What does the crossover formula leave out?

Plenty — and most of it favors buying at the margin. Fee parity is not outcome parity: the formula assumes your build resolves conversations as well as a specialized vendor's product, ships without delay, and never pulls your engineers off revenue work. None of those is guaranteed. Treat the crossover as the point where building starts deserving a business case, not where it wins.

Be honest about the failure base rate before trusting either side's optimism. Gartner predicts that "over 40% of agentic AI projects will be canceled by the end of 2027, due to escalating costs, unclear business value or inadequate risk controls" — its June 25, 2025 press release, and the single most misquoted number in this market. A canceled build is pure loss; a canceled subscription is a line item.

Who should not build: teams under roughly 10,000 AI-handled conversations a month; teams without an engineer who will own the agent for years, not quarters; teams whose agent is a commodity support workflow with no proprietary data or process in it. Buy, negotiate the per-outcome rate, and revisit annually.

Who should not buy without modeling first: teams already past ~30,000 conversations a month, where three-year fees approach seven figures; teams in the $9.99-per-outcome lead-qualification tier, where crossover volumes are ~10x lower; teams with hard data-residency or deep multi-system integration needs that per-outcome vendors price poorly. And anyone signing a multi-year contract with a vendor mid-acquisition should price in the possibility that the rate card doesn't survive the new owner.

What we don't know: your true loaded engineering cost, your outcome rate, and whether a build would match vendor-grade resolution quality in your domain. Those three inputs move the answer more than anything we can publish. That is why the formula is the deliverable here, not the verdict.

How do you decide without trusting a vendor?

Run the formula with your numbers, then interrogate both paths with the same tests. Ask the platform vendor for its pricing at 3x your volume, in writing. Ask the build estimate who maintains the agent in year two, at what fraction of an FTE. Then gate either choice on pre-agreed acceptance evals — pass rates on your real conversations — before any contract or final invoice is signed.

Three checks that catch most bad decisions:

1. Recompute the crossover quarterly. Model prices are moving as we write — Anthropic's Sonnet 5 introductory pricing alone is scheduled to rise from $2/$10 to $3/$15 per million tokens after August 31, 2026 — and per-outcome rate cards tend to move after acquisitions close. The formula is stable; the inputs are not.
2. Demand acceptance criteria and evals either way. A vendor who won't agree to a measured pass rate before you sign is selling you the demo. A build team that won't is selling you a forever project.
3. Score the operational substrate, not the demo. Whether bought or built, the agent needs state recovery, approval gates, and observability — the things that make a framework production-ready rather than a toy. A missing substrate turns the build column's $500/month infrastructure line into a second engineer.

If you want a second pair of eyes on the math itself, that's what we do. Book a 30-minute architecture call — no pitch. Bring your volumes and your engineering costs; we'll run the crossover with you and tell you plainly which side of the line you're on, including when the right answer is a subscription and not us.