Build vs buy, with the receipts
A demo-grade copilot is a weekend project. A production-grade agent is not: one that acts on your own systems for signed-in customers, in their language, without leaking data between accounts. Here is the arithmetic, with named sources.
What production-grade actually includes
The gap between the weekend demo and something you can put in front of customers is exactly the part that never shows up in the demo:
- The surface itself, twiceAn embeddable chat that streams, matches your product’s look, and stays accessible, plus a connection so people can drive your product from Claude, Cursor, or ChatGPT. Two clients, one set of behaviors to keep consistent.
- Tool definitions that track your APIEvery capability described and typed for the model, and kept in sync as your product changes. Drift here does not fail loudly. The agent just quietly stops being able to do things.
- End-user authenticationThe agent must act as the signed-in user, which means verifying who they are, honoring what they are allowed to do, and asking again before anything sensitive. Teams report this part takes longer than the agent itself.
- Action safetyWrite and destructive actions need server-enforced confirmation gates. An agent that deletes without asking generates the tickets it was meant to prevent.
- Keeping customers separateEvery query, cache, log, and metric scoped per customer, and provable, because your buyers' security reviews will ask.
- Multilingual, right-to-left includedYour end users do not all read English. Prompts, UI, and error states in every market language, with right-to-left layouts that actually mirror.
- Evals and regressionsModel and prompt changes need a way to test them before release, or every upgrade is a gamble taken in production.
- Security patching and upkeepStreaming protocols, spec revisions, dependency advisories: the maintenance starts the day the demo ends.
How the build year actually goes
Teams that build this in-house describe the same curve:
- The weekend demoA model, your docs, a chat box. It answers questions impressively, and it convinces everyone the remaining work is small.
- Month threeThe first write action. Now it needs real authentication, a confirmation step, an audit trail, and your security team’s sign-off. This is where the calendar goes.
- Month twelveIt works. The engineers who built it now own it permanently: model releases, spec revisions, streaming protocols, dependency advisories, none of which was on their roadmap.
The published failure data
Building means carrying the delivery risk yourself, and that risk is well documented. The published figures on in-house AI initiatives:
- 95%
- of enterprise GenAI pilots fail to reach production.MIT NANDA, Aug 2025
- 17% → 42%
- abandonment of AI initiatives, year over year.S&P Global, 2025
- 40%
- of agentic AI projects forecast to be canceled by 2027.Gartner, Jun 2025
- 57%
- of buyers expect AI ROI within three months.G2, 2025
When to build, and when to buy
Both answers are real. Where each one genuinely wins:
The case for building
- The agent is your productYou are selling the agent itself, not adding an agent surface to a product that does something else. Then you need to own every layer of it.
- You already run an AI platform teamThe eval discipline and the security ownership exist in-house, and this surface is worth a permanent slot on that team’s roadmap.
- No vendor can meet your constraintsAn isolated network, a mandated set of AI models, a regulator with opinions. If your requirements genuinely rule out every vendor, the decision has made itself.
The case for buying
- The agent is a feature, not your productYour users want to ask, act, and get on with their day. Your engineers’ time is worth more on the product those users came for.
- You want it live this quarterNot after a build year. The chat surface goes in with one script tag, the setup maps what your product can do, and nothing acts until you have reviewed and enabled it.
- You would rather hand over the security reviewA documented threat model, provable separation between customers, and published pricing, from a vendor for whom this surface is the whole roadmap.
Industry consensus puts the build threshold near 1M conversations per year. Below it, buying is the defensible call, and most product teams sit well below it.
The two paths, side by side
| What matters | Building it in-house | Buying Syncanix |
|---|---|---|
| Time to production | Quarters. The sign-in, safety and isolation work is most of it. | The same week. Add the widget, run the one-off scan, review what it found, switch it on. |
| Who builds and keeps it | One or two engineers, permanently, because the upkeep does not end at launch. | Nobody new. Your team reviews capabilities and sets the rules. |
| Cost before anything ships | A loaded engineer-year ($200K) before the first customer-safe action. | From $299/mo, published. Stop paying if it does not earn its keep. |
| Model churn and spec revisions | Land on your roadmap, every time. | Land on ours. |
| Your buyers’ security review | You write the threat model and defend it in every deal. | You hand over a documented threat model and isolation posture. |
| Control | Total. Every layer is yours to shape. | Bounded. Your catalog, your rules, your voice, on rails you do not own. |
The in-house math
An in-house build starts at one AI engineer ($200K/yr loaded, if you can hire one) plus the months before anything customer-safe ships. Syncanix starts at $299/mo, runs the same week, and every allowance is published.