Build vs Buy: AI Agents for Your Business

Most build-vs-buy decisions for AI agents are made on the wrong axis. Teams argue about who writes the code. The code is the cheapest part. The expensive part is everything that happens after the demo works: the agent that confidently quotes last year's price, the one that goes silent when the model provider deprecates the snapshot you built against, the one nobody is on the hook for when it fails in front of a customer.

So change the question before you pick a side. "Build vs buy" is not one decision — it's at least five, and a sane plan answers them differently. Get this wrong and you don't just overspend. You ship something no one owns.

An AI agent is a stack, not a thing

A production agent is several layers, and "build or buy" applies separately to each. Lumping them together is how careful teams end up building the part they should have rented and renting the part they should have owned.

• The model — the LLM doing the reasoning. You are buying this. Nobody sane is training a frontier model to answer support tickets, and the gap between the best model and the second-best closes every few months anyway.
• The orchestration runtime — how the agent plans, calls tools, retries on failure, and stays inside guardrails. Buy or build, and the line moves every quarter as platforms absorb what used to be custom.
• The data layer — what the agent knows about your business, your customers, your inventory, and crucially what it's allowed to see per the user asking. This is yours. It can't be bought, only connected.
• The integrations — the actions the agent can take in your systems of record: write the case, apply the credit, book the slot. Mostly build, because they're specific to you and the blast radius is real.
• The accountability layer — evals, monitoring, escalation when confidence drops, and the human or org that owns the number. Almost always under-resourced, regardless of build or buy.

The mistake is treating the model's intelligence as your differentiation. It isn't. Every competitor can rent the same model from the same handful of providers. Your edge is in the data layer and the actions — the two layers nobody can buy off a shelf because they're a map of how your business actually works.

What "buy" actually buys you

Buying a platform — Agentforce, or an agent framework bolted onto the stack you already run — gets you the boring, load-bearing things that are tedious to build and easy to underestimate: identity and row-level permissions, audit logging, model version pinning, a topic-and-guardrail system, and a deployment surface your security team has already reviewed. That's real value. It's most of the first six months you'd otherwise spend on plumbing instead of on the problem you actually have.

What it does not buy you is a working agent. A platform is a kitchen, not a meal. The vendor demo runs on clean sample data and three happy-path questions. Your business has fifteen years of messy records, three fields that all claim to be "status," duplicate accounts, and edge cases that only surface under load. The platform won't fix that, and the slide deck won't admit it.

“

Buying the platform removes the easy 60% of the work. The hard 40% — your data, your actions, your accountability — is still yours. That 40% is where the ROI lives or dies.

What "build" actually costs you

Building from raw frameworks seduces engineering teams because the first version is genuinely fast. A capable engineer can wire a tool-calling loop to an API in an afternoon and demo something that looks finished. The cost shows up later, and it isn't the code.

It's the eval harness you now own, because without one you can't tell whether a prompt change made things better or quietly worse. It's the version drift when the provider retires the model snapshot you tuned against and your guardrails shift under you overnight. It's the on-call rotation for a system that takes real actions in production. You didn't ship an app. You hired a non-deterministic employee, and now you own its management forever. Most build estimates price the wedding and forget the marriage.

The honest decision rule

Here's the heuristic I'd hand a CTO and a chief architect sitting in the same room, because they need different things from the same answer — one wants the business case, the other wants to know what they're committing to maintain.

• Buy the layers that are commodity and regulated — the model, identity, audit, guardrail infrastructure. You gain nothing by hand-rolling what a platform already hardened and a vendor already passed through compliance.
• Build the layers that encode your business — the data connections, the actions into your systems, the policies for what the agent may and may not do. This is the work that makes the agent yours rather than a generic chatbot with your logo on it.
• Never outsource the accountability layer to a tool. Ownership of the outcome is an organizational commitment, not a feature you can purchase or a dashboard you can install.
• If a capability is core to how you compete, lean build. If it's table stakes every competitor also needs, lean buy and spend the saved months on the part that's yours alone.
• When genuinely unsure, buy the platform and build on top. Outgrowing a buy is a planned migration; reversing a deep build is a rewrite.

Notice this rule almost never lands on pure build or pure buy. The right answer for most businesses is buy the runway, build the differentiation. The debate, framed as a binary, is mostly a category error.

The third option nobody costs out: run

Build and buy both quietly assume the same thing — that once the agent ships, someone keeps it healthy. In practice that's the line item cut from the budget and the box missing from the org chart. The agent that was sharp at launch drifts as your products change, your pricing moves, and the underlying model updates beneath it. Accuracy decays slowly, then a customer notices before your dashboards do.

Running an agent is a discipline, not a maintenance window: continuous evals against real conversations, a feedback loop from those conversations back into the data and the prompts, escalation paths when confidence is low, and one named owner for the number it exists to move. This is why we frame our work as build and run, and why our fee is tied to the client's return — if the agent stops producing, that's our problem to fix, not your change order to approve. An agent you only build is a liability with good intentions.

Data before agents, always

Whichever way the build-vs-buy call breaks, it's the wrong first question if your data isn't ready. An agent is only as good as what it can see and trust. Point a brilliant model at fragmented, stale, permission-ambiguous data and you get a confident liar — fast, fluent, and wrong, with the tone of authority that makes people believe it. In our Green Subsidy work — a speed-to-lead agent for solar — the lift wasn't a cleverer model. It was getting the right lead data to the agent fast enough to act while the prospect was still warm enough to answer the phone. The agent was the last mile. The data was the road. Decide the data layer first; the agent decision gets easier the moment you do.

How to actually decide this week

Skip the vendor bake-off for a moment. Take one workflow — a single painful, repetitive thing your team does all day — and answer four questions. What number does a working agent move, in dollars? Where does the data for it live today, and can the agent legally reach it? Who is on call when it's wrong? And what does it cost you every month it doesn't exist? Say a queue of inquiries each takes a rep ten minutes and half could be resolved end to end — that idle half is the number, and it's illustrative until you put your own figures in. If you can't answer those four, no platform choice saves you. If you can, the build-vs-buy split for that one workflow usually answers itself.

Run that loop on one workflow, prove the number, then expand. That's the whole game — not picking a side in a debate, but knowing which layers to own, which to rent, and who stays accountable when the agent is wrong at 2 a.m.