—
monthly savings building DIY (vs vendor)—vendor / month
—DIY total / month
—resolved conversations / month
—vendor cost / resolution
—DIY cost / resolution
Vendor vs DIY, by monthly conversation volume
Same resolution rate, vendor price, token cost and DIY build/maintenance inputs as above, swept across conversation volume. DIY's fixed engineering cost stays flat while the vendor's bill scales linearly with resolved conversations — the highlighted row is closest to your break-even volume.
| Conversations/month | Vendor cost | DIY total | Cheaper option |
|---|
How this connects to other tools
This calculator prices one specific decision: whether to pay a named vendor per resolution for AI customer support or build your own bot on a raw LLM API. If you just want to know what an AI chatbot saves versus human agents at a flat cost-per-chat, without naming a vendor or modeling a DIY build, the AI Support Deflection Savings Calculator answers that simpler question. If you already know you're building your own bot and just need to size the token spend across a broader range of use cases beyond support, the Chatbot Cost Calculator prices that token cost directly. And the engineering-hours-vs-subscription framing used for the DIY side here — build hours amortized against a recurring vendor bill — is the same build-vs-buy shape used in the AI Coding Tool ROI Calculator, just applied to a support bot instead of a coding assistant.
How this calculator works
The AI Customer Support Cost Calculator compares two cost shapes for the same job — resolving customer conversations with an AI bot instead of a human agent. The vendor side is a straight line: monthly conversation volume multiplied by the autonomous resolution rate gives the resolved conversations the bot actually closes without a human, and that count multiplied by the $ per resolution price gives the vendor's monthly bill — Intercom Fin publishes $0.99 per outcome, and the vendor preset selector loads publicly reported rates for a few named vendors, editable if your own quote differs. The DIY side has a different shape. Every conversation, not just the resolved ones, has to be read and answered by the model, since the bot can't know in advance which ones it will successfully close — so the token cost (input tokens times input price, plus output tokens times output price, per conversation) is multiplied by total volume, not resolved volume, to get the monthly token bill. On top of that, the one-time build hours multiplied by your hourly rate and spread across the amortization window, plus ongoing maintenance hours at the same rate, add a fixed monthly engineering cost that barely changes with volume. Summing token cost and fixed engineering cost gives the DIY total, and vendor minus DIY gives your monthly savings — often negative at very low volume, since a vendor's small per-resolution bill can undercut even a lean DIY build's fixed engineering overhead.
The number worth remembering is the break-even resolved-conversation count: the point where the extra savings a resolved conversation earns you on the DIY side — the vendor's per-resolution price minus the token cost it took to earn that resolution — is enough, multiplied across all resolved conversations, to cover the DIY build's fixed monthly cost. Below that volume, the vendor is cheaper because you haven't resolved enough conversations yet to earn back the engineering investment. Above it, DIY is cheaper and stays cheaper by a widening margin, because the vendor's bill keeps climbing in a straight line with every resolution while the DIY line is nearly flat. If the vendor's per-resolution price is so low, or your token cost so high relative to your resolution rate, that this per-resolution saving is zero or negative, DIY never wins on cost alone no matter the volume — the calculator flags that case directly instead of showing a meaningless break-even number. This is a cost-floor comparison: it doesn't weigh setup time to reach production quality, ongoing prompt and retrieval tuning, or the accuracy gap between a mature vendor product and a bot you built yourself, only the direct dollar cost of the two ways to run it.
Frequently asked questions
Why do Intercom Fin and similar AI support vendors charge per resolution instead of a flat fee?
Because it lets the vendor tie price directly to value delivered instead of raw usage. Intercom bills Fin at $0.99 per outcome (a resolution, a handoff, or a disqualification), so you pay when the bot actually does something for a customer rather than for every message it sends. That sounds attractive until you look at real resolution rates: Intercom's own published case studies put Fin's real-world resolution rate between roughly 42% and 50%, not 100%, so a large share of conversations still end up with a human agent and the associated cost of that agent on top of whatever Fin charged along the way. The per-resolution price is the easy number to compare across vendors; the resolution rate you'll actually get is the number that determines your real monthly bill, and it's worth pressure-testing with a pilot before committing to a contract sized around an optimistic assumption.
When does building your own support bot on a raw LLM API beat paying a vendor per resolution?
Once your resolved-conversation volume crosses a specific break-even point, because the two options have different cost shapes. A per-resolution vendor's bill is almost pure variable cost — it climbs in a straight line with every resolution, no ceiling. A DIY bot built on a raw LLM API has the opposite shape: a large fixed cost (engineering time to build it, amortized over months, plus ongoing maintenance hours) and a tiny variable cost (token price per conversation, often just a few cents). At low volume the fixed engineering cost dominates and the vendor's small per-resolution bill is cheaper. As volume grows, the vendor's linear cost keeps climbing while the DIY line barely moves, since token cost is a small fraction of a cent times conversation count. The crossing point between the two is the break-even volume this calculator solves for — below it, pay the vendor; above it, and by a growing margin the higher volume goes, building your own wins.
Why does the DIY cost calculation charge token cost for every conversation, not just the ones the bot resolves?
Because a bot can't know in advance which conversations it will successfully resolve. Every incoming conversation has to be read and processed by the model to attempt a resolution, so the input and output tokens are spent regardless of whether that particular conversation ends in a clean resolution or a handoff to a human. That's a real structural difference from vendor pricing: a per-resolution vendor only bills you for the successful outcomes, effectively bundling the cost of the attempts that didn't resolve into the price of the ones that did. A DIY build has no such bundling — its token cost is a function of total conversation volume, and its effective cost per resolution is that total token spend divided by however many conversations the bot actually resolved, which is why a lower resolution rate quietly makes DIY look more expensive per resolution even though the token bill itself didn't change.
How is this different from the AI Support Deflection Savings Calculator on this site?
The Support Deflection Savings Calculator answers a different, more generic question: what does an AI chatbot save versus routing the same tickets to human agents, using a flat AI-cost-per-chat input and a flat human-cost-per-ticket input, with no named vendors and no option to model building your own bot. This calculator names actual vendor billing structures — Intercom Fin's published $0.99-per-outcome price, Zendesk AI's reported per-resolution range, Chatbase's credit-based pricing simplified to an effective per-resolution figure — and puts a second, fully-modeled option on the other side of the comparison: building your own bot on a raw LLM API, with its own token cost, engineering build cost and maintenance overhead. The output isn't just a savings estimate, it's a specific break-even conversation volume where DIY starts beating a named vendor's linear per-resolution pricing, which the deflection calculator has no way to compute because it doesn't model a build-your-own cost structure at all.