Skip to main content

Build, buy, or wrap: the decision framework with your organization's real budget

The short answer

Three options, one accountability

Build means you own the machine, buy means you rent a finished product, wrap means you own a thin app around a rented general-purpose model. The option changes what you build and what you rent. It never changes who answers for the outcome: you do.

What you will be able to do

  • Distinguish the three ways to get an AI capability, build, buy, and wrap, and state in one sentence what your organization owns and what it rents in each.
  • Analyze a real capability your organization needs and recommend build, buy, or wrap using explicit decision axes, not gut feel or vendor charisma.
  • Estimate the total cost of ownership (TCO) of each option, the full lifetime cost including the run cost, the maintenance cost, and the supervision cost, not just the sticker price.
  • Name the supervision tax (the recurring human-oversight cost) as a required line item, and explain why removing it, as Michigan did, is what turns a cheap build into an expensive disaster.
  • Weigh control against speed, differentiation against commodity, and lock-in against convenience, and defend the tradeoff you chose.
  • Locate where liability lands in each option, so you know before you sign whether a failure is yours to answer for, the vendor's, or split. (see Topic 8.4)
  • Classify the decision as reversible or hard to reverse, and favor the reversible path when the evidence is thin. (see Topic 0.4)
  • Choose the shape of human oversight the decision needs, human-in-the-loop or human-on-the-loop, and price it, so the supervision cost matches the stakes rather than the option you preferred.
  • Audit a build, buy, or wrap proposal that someone else hands you, finding the missing cost buckets, the over-weighted axis, the assumed volume, and the absent exit before you approve it.
  • Produce a one to two page decision memo that a skeptical finance officer and a skeptical regulator could both read and find defensible.

The ideas, one by one

Price the life, not the sticker

Total cost of ownership has four buckets: Acquire, Run, Maintain, and Supervise. The sticker is only Acquire, usually the smallest over a system's life. The decision lives in the other three, and most disasters live in the last one.

The supervision tax is set by stakes, not by acquisition route

A consequential decision about a person needs human oversight whether you built, bought, or wrapped. Choosing to buy or wrap changes who supervises, never whether supervision is required. Any low TCO that leaves Supervise near zero for a high-stakes system is not cheap, it is unpriced risk.

Michigan proves the tax comes due either way

MiDAS was a 47 million dollar build whose entire saving was deleting the human adjudicators; about 93 percent of the fraud determinations the auditor checked were wrong, roughly 40,000 people were falsely accused, and the state settled for 20 million dollars (Michigan sources, 2016 to 2022). The oversight you refuse to pay for as salary returns as harm and liability, larger.

Run the six axes in order

Differentiation, control, speed, lock-in, data sensitivity, liability. Differentiation, control, and liability push high-stakes crown-jewel work toward build; speed and commodity push everyday work toward buy or wrap. When the axes conflict, say so and defend the tradeoff.

Speed is one axis, not the decision

"We need it now" is the sentence most often used to skip the other five axes. Speed breaks ties among safe options; it rarely wins the argument alone.

Price the exit before you enter

Every option locks you into something: a vendor, a model version, or your own maintenance burden. Ask what it costs to leave in two years and whether leaving is possible. An option you cannot exit is a decision you cannot reverse. (see Topic 0.4)

Renting the model does not rent the blame

In a wrap, you are the party the public and the regulator hold responsible, because you deployed it under your name. The comfortable myth that the model provider absorbs liability is exactly the myth that ends in a settlement. (see Topic 8.4)

The labels blur; price what you actually get

A "custom model" can be a wrap in disguise, a cheap buy can hide an expensive integration, and a wrap's model can change under you. Ask what you own, what you are locked into, and what happens when the underlying model changes.

The memo is the artifact, and it will be attacked

Your build, buy, or wrap decision memo feeds the vendor interrogation and the shipping plan, and a hostile board pulls it out in Module 11. Write it today as a first-class record a CFO and a regulator could both read, not a throwaway.

Demo accuracy is not deployment accuracy

The performance the vendor showed was measured on the vendor's chosen data. On your real population it will almost always be lower, and the gap is the exact size of the supervision you must fund to catch the errors the demo hid. Price the gap, do not admire the demo. (see Topic 4.6)

Audit the proposal, do not just approve it

When someone hands you a build, buy, or wrap recommendation, find the missing buckets, the over-weighted axis, the assumed volume and stakes, and the absent exit. The governance skill is taking a proposal apart, not signing the flattering slice its author happened to see.

Price over the same horizon, or the comparison lies

A build front-loads cost; a buy or wrap compounds it. Over one year the build looks dearest; over five the subscriptions overtake it. State the horizon you will actually run the capability and price all three options on it, or you will reach whichever answer you started with.

The answer can be all three

A capability is often several components, and the defensible call is frequently to build the one part that is your differentiator, buy the commodities around it, and wrap the flexible layer. Decompose the capability and run the framework per component, so build budget goes only where it is earned.

Match the oversight shape to the harm

Human-in-the-loop review on every output is right when a single mistake is severe and irreversible, and wasteful when it is not. Spend the expensive review where the harm is; use lighter on-the-loop monitoring where errors are visible and recoverable.

Listen to it

The same lesson, talked through by two hosts as episode 18 of the podcast.

Real cases

These examples show the decision, and its consequences, in real deployments. Real anchors are cited; the pattern each teaches is stated plainly.

Example 1: Michigan MiDAS, a build that deleted its supervision (2013 to 2015). Michigan paid a contractor about 47 million dollars to build a bespoke unemployment and fraud-detection system, and configured it to issue fraud determinations with no adjudicator review (Michigan Ford School STPP, 2024). It falsely accused about 40,000 people; the Auditor General found roughly 93 percent of a 22,000-determination sample were not fraud (Michigan Office of the Auditor General, 2016). The state settled Bauserman v. Unemployment Insurance Agency for 20 million dollars in 2022 (Michigan Attorney General, 2022). The decision failure was not "build versus buy." It was pricing the build without the supervision tax the stakes demanded. This is the module's anchor case and it owns the deep treatment here; other topics reference it.

Example 2: A commodity capability, correctly wrapped. Consider a mid-size logistics firm that needs to summarize inbound customer emails into a ticket. Summarization is a pure commodity: no customer chooses the firm because of it, the stakes of a wrong summary are low and recoverable, and speed matters. The six axes point cleanly at wrap: low differentiation, low control needs, low liability, high speed value. Building a summarization model here would be burning money to reinvent a commodity. The correct call is a thin wrap over a general-purpose model, with a light human check on the ticket before action. (Illustrative pattern, not a named incident; grounded in the axes in Section 3D.)

Example 3: A high-stakes decision that a buy cannot make safely alone. A hospital procuring an AI tool that flags patients at risk demands the opposite treatment. Even a bought product must be validated on the hospital's own population and kept under clinical review, because external validation has repeatedly shown vendor accuracy claims do not survive contact with a new population. (see Topic 4.6) The lesson: buying does not outsource the supervision tax for a consequential decision. The stakes, not the acquisition route, set the oversight. A buy here is defensible only with the Supervise bucket funded and staffed.

Example 4: The government build overreach that never worked as sold. A telehealth company built its business around a proprietary AI symptom checker and scaled on the promise it would replace clinical triage; the capability never matched the demonstration, and the company collapsed. (see Topic 3.1) for the deep treatment. The build-decision lesson: building your differentiation is right only if you can actually build the thing to the standard the stakes require. A build you cannot deliver is worse than a buy you can, because you have spent the money and still do not have the capability.

Example 5: The vendor whose "autonomous AI" was mostly people. A restaurant-technology vendor marketed drive-thru voice ordering as autonomous AI while offshore staff handled a large share of orders; a securities regulator charged it with misleading statements. (see Topic 3.3) for the deep treatment. The buy-decision lesson: the sticker on a buy is only honest if the product does what the deck claims. Interrogating that claim before you sign is the subject of the next topic, and it is why "buy" is never "buy and stop thinking."

Example 6: The reversible wrap as a first move. A common and defensible 2026 pattern (established) is to wrap a general-purpose model for a new feature precisely because it is the most reversible option: a small first commitment, a low switching cost if the provider disappoints, and real production learning about whether the capability is worth a later build. The organizations that use wrap well treat it as a two-way door and a data-gathering exercise, not a permanent architecture. (see Topic 0.4) The lesson: matching the size of your first commitment to the thinness of your evidence is itself a governance decision.

Example 7: The buy whose sticker hid a build. A recurring pattern, seen across public-sector and enterprise procurement, is the low-sticker product whose real cost lives in integration: connecting it to legacy identity systems, reformatting data, and building the glue that keeps it talking to everything else. The buyer then maintains that glue forever. The subscription looked like a buy; the total effort was a build hiding inside a subscription. The decision lesson: price integration inside the Acquire and Maintain buckets, not as a free afterthought, or the cheapest-looking option quietly becomes the most expensive. (Illustrative procurement pattern, grounded in the TCO buckets of Section 3C.)

Example 8: The GPAI upstream you inherit without choosing it. When you wrap a general-purpose model, you inherit the model provider's data choices and legal exposure whether or not you examined them. A downstream deployer's risk is shaped by decisions made far upstream, in the training data and terms of a model it did not build. (see Topic 5.5) for the deep treatment of what a foundation-model vendor's choices expose a downstream deployer to. The build-buy-wrap lesson: the wrap column of your memo must price not only the API bill but the inherited exposure, because renting the model rents its upstream problems too.

Example 9: The differentiator that justified building. Organizations whose core product is an AI capability, where the model itself is the reason customers pay, routinely and correctly build, because owning the model is owning the moat. The build-decision lesson is the mirror of the commodity case: when a customer genuinely chooses you because of this specific capability, renting it means renting your own differentiation from a provider who can rent it to your competitor tomorrow. Differentiation is the one axis that can justify the full cost and responsibility of a build, provided you can deliver and maintain it. (Illustrative pattern, grounded in the differentiation axis of Section 3D.)

Example 10: The self-hosted wrap forced by data law. An organization handling data that cannot lawfully be sent to an external provider, but wanting the flexibility of a general-purpose model, may run an open-weight model on its own infrastructure: a self-hosted wrap. The Acquire and Run buckets grow, because you now operate the model yourself, but the data never leaves your control, which is the only lawful path for that data. The lesson: sometimes the law, not the budget, selects the option, and the memo must say so plainly rather than let a cheaper but unlawful external wrap sit in the comparison. (see Topic 5.5) (Illustrative pattern, grounded in the data-sensitivity axis.)

Where people go wrong

  • "The cheapest sticker is the cheapest option." The sticker is only the Acquire bucket. A cheap buy with a compounding subscription and a costly integration, or a cheap wrap with a Supervise bucket the stakes demand, can be the most expensive option over its life. Compare on total cost of ownership, never on the sticker.
  • "If we buy or wrap, oversight is the vendor's job." The stakes set the supervision tax, not the acquisition route. A bought fraud detector or a wrapped model still needs your humans reviewing consequential outputs. Renting the model does not rent you an exemption from watching it.
  • "Renting the model rents the blame." In a wrap, you are almost always the party the public and the regulator hold responsible, because you deployed it under your name. Michigan could not blame the contractor to the 40,000 people it wrongly accused. Deployers answer for deployments. (see Topic 8.4)
  • "Build gives us the most control, so build is the safe choice." Build gives the most control only if you can actually build the thing to the standard the stakes require. A build you cannot deliver, or cannot maintain, is more dangerous than a competent buy, because you have spent the money and still lack a safe capability. (see Topic 3.1)
  • "We need it this quarter, so speed decides." Speed is one axis of six, and the one most often used to stampede a bad decision. "We need it now" justifies choosing the faster option among safe ones; it never justifies skipping differentiation, control, liability, or the supervision tax.
  • "Accuracy in the demo is the accuracy we will get." Demo accuracy is measured on the vendor's chosen data, not your real population. External validation repeatedly shows vendor claims shrink on contact with reality. (see Topic 4.6) Price the supervision that catches the errors the demo did not show.
  • "A wrap is basically free once it is built." The API bill scales with usage and can surprise you badly at production volume, the model can change or be deprecated under you, and the Supervise bucket is set by stakes, not by how thin the layer is. Price the run cost at real volume and pin the model version as a dependency.
  • "This is a one-time decision." A commodity today can become differentiating tomorrow as you accumulate proprietary data, and a wrap you chose for speed may justify a build later. Revisit the decision when the differentiation math changes; treat it as reversible where you can. (see Topic 0.4)
  • "If the vendor calls it a custom model, it is a build." Some "custom AI" is a thin wrap over a general-purpose model wearing a build's price tag, carrying the lock-in of both. Ask what base model it uses and what happens when that model is deprecated. (see Topic 3.3)
  • "The excluded options belong in the comparison to be fair." If an option is unlawful for your data or jurisdiction, it is not a live option, and including it to improve the numbers is how you end up defending an illegal deployment. Name the exclusion and its ground; compare only the lawful options. (see Topic 5.5)
  • "The proposal on my desk already did the analysis, so I just approve it." A proposal usually prices the sticker and leans on the one axis its author cared about. Approving it as written means inheriting its blind spots. Find the missing Maintain and Supervise buckets, the over-weighted axis, the assumed volume, and the absent exit before you sign.
  • "A pilot that worked proves the option works." A pilot runs at low volume, on friendly data, often with the team watching closely. Production is high volume, real data, and ordinary attention. A wrap that was cheap and accurate in a pilot can be costly and error-prone at scale. Treat the pilot as evidence about feasibility, not as the deployment cost or accuracy.

Questions people ask

What is build?
Acquiring an AI capability by developing and owning it end to end, either in-house or through a contractor building to your specification, including the model, code, and data pipeline. Gives the most control and differentiation and carries the most cost and responsibility. Michigan's MiDAS was a build.
What is buy?
Acquiring an AI capability by licensing a finished vendor product, typically as software as a service (SaaS), where the vendor hosts and maintains it and you pay a subscription. The fastest path to a working capability and usually the one you understand the least, because the product is often a black box.
What is wrap?
Acquiring an AI capability by building a thin application layer (prompts, guardrails, your own data, a user interface) around a general-purpose AI model you reach by application programming interface (API) and do not own. You own the layer and rent the model. Faster than build, more flexible than buy, and dependent on a model provider whose behavior, price, and terms you do not control.
What is total cost of ownership (TCO)?
The full lifetime cost of an AI capability across four buckets: Acquire (getting it working once), Run (operating it daily), Maintain (keeping it working as it drifts and models change), and Supervise (the recurring human-oversight cost). The sticker price is only the Acquire bucket; the decision lives in the other three. More on Total cost of ownership (TCO)
What is supervision tax?
The recurring cost of keeping a human meaningfully in or on the loop of an AI system, reviewing outputs, sampling decisions, and being ready to intervene. It is set by the stakes of the decision, not by whether you built, bought, or wrapped, and it does not go away by choosing to rent the capability. Removing it to lower cost, as Michigan did, is what turns a cheap capability into an expensive disaster. More on Supervision tax

Keep going

Watch the lesson and prove it

Proving it happens inside the program: watch, explain it in your own words, and it goes on a record employers can check.

Watch the lesson and prove it →