In one sentence: Building an agent is easy and building the platform around it is hard, so the smartest build-versus-buy decision is rarely all or nothing: buy the commodity foundations and build only what truly differentiates your business.
Few debates in enterprise AI generate more heat than build versus buy. Engineers point to the open-source frameworks that produce a working agent in an afternoon. Operations leaders point to the calendar and the risk register. Both are right about something and both are often arguing about the wrong thing. This post reframes the question. Using the STAR format (Situation, Task, Action, Result), we show what you are really choosing between, give you a way to decide and offer a design that keeps your options open.
A Prototype in Six Weeks and a Question Nobody Can Answer
Picture a regional energy provider we’ll call Lakeshore Utilities. As in our earlier posts, this is a composite scenario, not a customer case, but the argument will sound familiar to many technology and operations leaders.
Lakeshore’s engineering team has been experimenting with an open-source agent framework. In six weeks, they produce a prototype that answers billing queries and drafts outage notices. It is genuinely good and it cost almost nothing beyond engineering time. The chief technology officer is encouraged and suggests the company simply build its own platform.
The chief operating officer is not so sure. A vendor has shown her a platform that already includes permissions, audit trails, a knowledge base and connectors to the company’s systems. She asks a simple question: if the prototype took six weeks, why would we pay for a platform at all? The CTO asks an equally fair one: if we buy, how do we avoid being locked into a product that does not fit how we work?
Each question has merit and the meeting ends without a decision. The reason is that both leaders are comparing different things. The CTO is comparing a working agent with a license fee. The COO is comparing a governed production capability with a prototype. Until the comparison is made on equal terms, the debate will repeat itself every quarter.
The central insight is this: the agent is the small, visible part. What surrounds it is large. Figure 1 shows what sits beneath the waterline when an organization decides to build.
Figure 1. The build iceberg
WHAT THE PROTOTYPE SHOWS
+--------------------------------------+
| Instructions + model call + 2 tools |
~~~~~~+--------------------------------------+~~~~~~ waterline
| Per-user identity and permissions |
| Tool allow/deny rules, approvals |
| Traces, audit logs, replay |
| Versioning, testing, rollback |
| Knowledge base, citations, updates |
| Integrations, auth, rate limits |
| Evaluation sets and cost tracking |
| Data redaction and retention |
| Monitoring, alerts, on-call support |
| Admin UI, onboarding, documentation |
+--------------------------------------+
WHAT PRODUCTION REQUIRES
None of the items below the waterline is exotic. Each is a solved problem. But each takes real engineering time to build, secure, document and maintain and the list grows as more agents and more teams join. The cost of building is not the first agent. It is the long tail of everything the first agent quietly assumes.
Buying has its own hazards. A platform may fit your needs less well than a custom build, may constrain how you design agents and may make leaving expensive. These are real costs too and a fair evaluation counts them.
There is also a hidden people cost. Engineers who maintain a homegrown platform become its permanent custodians. Every upgrade of a model, every change in a connected system and every new security requirement lands on the same small team. Over time, the people hired to create new capabilities are consumed by keeping existing ones alive and the organization loses the innovation it hoped to gain by building.
Figure 2. Build, buy and hybrid at a glance
Pause and check: Take your most successful AI prototype. List everything below the waterline in Figure 1 that it does not yet have. How many engineer-months would that list take?
Make the Decision on Equal Terms
Your task is to compare the options fairly, capability by capability, rather than as a single, all-or-nothing choice. Three principles help.
• Compare production to production. Weigh a governed, supported, auditable system against another system of the same kind, not against a prototype.
• Decide by layer. Different parts of the stack deserve different answers. Commodity layers favor buying; differentiating layers may justify building.
• Count the years, not the weeks. Total cost over three years includes people, operations, security and change, not only licenses or first-build effort.
The test for any component is simple. Ask whether doing it better than everyone else would make your customers choose you. Identity, audit and connectors rarely pass that test. Your proprietary pricing logic, or the way your best coordinators resolve complex outages, might.
For Lakeshore, the task becomes concrete: map the components of an agent capability, decide for each one whether to build, buy or combine, estimate three-year cost on equal terms and design the choice so that it can be reversed if circumstances change.
A Practical Way to Decide
Step 1: Split the stack into layers
Start by separating what you would be building into layers. A useful split has four: the foundation (identity, permissions, tool controls, traces, deployment), the connective tissue (knowledge, integrations, document processing), the agents themselves (instructions, workflows, orchestration) and the business logic unique to you (rules, models, data). Most organizations find that the first two layers are commodity, the third is a blend and the fourth is where genuine differentiation lives.
This split already points toward a hybrid. Buy the foundation and the connective tissue, where mature products exist and where mistakes are costly. Build the agents and the business logic on top, where your knowledge of the work is the advantage. Figure 3 summarizes the pattern.
Figure 3. What to rent and what to own
Step 2: Estimate cost on equal terms
Next, put numbers on each option. Be careful to include the items that are easy to forget: engineers to maintain the system, security and compliance work, on-call support and the cost of delay. Now the technical part. The snippets below are simplified, illustrative Python. The first is a three-year cost model. We have deliberately left the figures empty, because only your own quotes and salaries can fill them honestly.
Figure 4a. A three-year cost model, ready for your own numbers
def three_year_cost(option: dict) -> float:
one_time = option["setup"]
per_year = (
option["licences"]
+ option["cloud_and_model_usage"]
+ option["engineers_fte"] * option["cost_per_fte"]
+ option["security_and_compliance"]
+ option["support_and_operations"]
)
return one_time + 3 * per_year
build = {"setup": 0, "licences": 0, "cloud_and_model_usage": 0,
"engineers_fte": 0, "cost_per_fte": 0,
"security_and_compliance": 0, "support_and_operations": 0}
Copy the dict for buy and hybrid, then replace every 0 with your own figure.
The model is plain on purpose. Its value is that it forces both camps to fill in the same lines. Very often, the engineering line in the build column is the one that surprises people, because maintaining a platform is a standing commitment, not a project.
Step 3: Score the strategic fit
Cost is only half of the decision. Figure 5 lists the strategic criteria that most often tip the balance, along with the direction each one pushes.
Figure 5. Criteria that tip the decision
When you apply the criteria, resist the urge to average them into one verdict. A single decisive factor can outweigh the rest. If your regulators require a deployment model that no available product supports, that constraint settles the question regardless of cost. Likewise, if you plan dozens of agents across many teams, the economics of sharing one governed foundation tend to dominate everything else.
The second snippet turns those criteria into a rough, transparent scoring function. It is not a substitute for judgment, but it makes the reasoning visible and challengeable, which is exactly what a committee needs.
Figure 4b. A transparent decision score
Each factor is rated 1 (low) to 5 (high) by the decision team.
Weights show how strongly a factor pushes toward each option (-1 to +1).
WEIGHTS = {
# build buy hybrid
"differentiation": ( 1.0, -1.0, 0.4),
"engineering_capacity": ( 1.0, -0.8, 0.3),
"time_pressure": (-1.0, 1.0, 0.3),
"governance_burden": (-0.6, 0.8, 0.5),
"agent_count": (-0.5, 0.8, 0.6),
"integration_uniqueness":( 0.7, -0.6, 0.6),
}
def lean(ratings: dict) -> dict:
totals = [0.0, 0.0, 0.0]
for factor, rating in ratings.items():
push = (rating - 3) / 2 # maps 1..5 to -1..+1
for i, w in enumerate(WEIGHTS[factor]):
totals[i] += w * push
return dict(zip(["build", "buy", "hybrid"], totals))
Step 4: Design the exit before you enter
Whichever way you lean, protect yourself against being wrong. Lock-in is not an accident; it grows when your agents, instructions and integrations are tangled with one provider’s specifics. The remedy is a thin layer of your own between your agents and the things that can change, such as the model provider or the tool interface. The third snippet shows the idea.
Figure 4c. A thin adapter layer to keep options open
from typing import Protocol
class ModelProvider(Protocol):
def complete(self, messages: list, tools: list) -> dict: ...
class VendorAModel:
def complete(self, messages, tools): ... # calls vendor A’s API
class VendorBModel:
def complete(self, messages, tools): ... # calls vendor B’s API
def build_agent(model: ModelProvider, tools: dict, instructions: str):
return Agent(model=model, tools=tools, instructions=instructions)
Swapping providers becomes a configuration change, not a rewrite.
The same thinking applies to platforms. Favor open standards such as the Model Context Protocol (MCP) for tools, keep your instructions and knowledge in portable formats and ask any vendor exactly how you would export your agents and data. Figure 6 lists the main sources of lock-in and the habit that limits each.
Figure 6. Reducing lock-in
What Good Looks Like
As in our previous posts, we will not promise a saving or a delivery date. The result of a sound decision process is not a number; it is a choice that survives scrutiny, made on equal terms, with its risks named and its exits planned.
For Lakeshore, that likely means a hybrid. The company adopts a platform for the foundation and connective tissue, which removes months of undifferentiated engineering. Its engineers focus on the agents themselves and on the outage-prediction logic that is genuinely theirs. A thin adapter layer and open standards keep the door open if the vendor relationship changes. The CTO keeps his engineers on interesting work and the COO gets governance and audit without waiting a year.
A hybrid is not a compromise that pleases nobody. Done well, it concentrates your scarce engineering time on the places where your knowledge of the work is the advantage and it leaves the heavy, repetitive infrastructure to a team whose entire business is maintaining it. The discipline lies in drawing the boundary clearly and writing it down, so that nobody drifts into rebuilding the foundation by accident.
Figure 7. A scorecard for the decision itself
Three pitfalls to avoid
• Treating the prototype as the plan. A six-week prototype tells you the model is capable. It says nothing about the cost of everything below the waterline.
• Framing it as a single decision. The choice is made layer by layer. An all-or-nothing debate hides the good hybrid options.
• Ignoring the second year. Maintenance, upgrades, security patches and on-call support continue long after launch day. Count them.
Figure 8. STAR recap
Where should you start?
Gather the people on both sides of the debate and run the exercise together. List the layers, mark each as commodity or differentiating, fill in the cost model with real figures and score the six criteria honestly. Then ask a final question: if we are wrong in a year, what will it cost us to change? If the answer is frightening, adjust the design before you commit.
Build versus buy is not a contest between engineers and procurement. It is a question of where your organization’s effort creates the most value. Spend your scarce engineering talent on what only you can do, rent what everyone needs and keep the connections between them loose enough to change your mind.
Visit www.intellibooks.io.






