Should Your Company Build or Buy AI?

Build or buy is the question every leader eventually asks about AI, and it's the wrong one, because it assumes AI is one thing you acquire one way. It isn't. It's a stack of layers, and each layer has a different right answer. You don't build or buy. You assemble: source the intelligence from the labs that make it, closed or open, because nobody should train their own model, and build the thin layer that makes that intelligence work inside your specific business. We call that the assembly answer, and companies that land on it skip both failure modes the binary produces: the build project that never ships, and the shelf of bought tools that never adds up to a system.

Why is build versus buy the wrong question?

Because it imports software-era procurement thinking into a technology that splits into layers with opposite economics.

When leaders say build, they usually picture training or heavily customizing their own model, a project measured in years and specialist salaries. When they say buy, they picture subscribing to finished AI products and being done. Both answers fail, and they fail for the same reason: they treat the whole stack as one decision. The build camp ends up funding a science project that's obsolete before it ships, because the frontier moved while they were building. The buy camp ends up where we've described in the bundled premium: a dozen subscriptions, each doing one slice of a job, none sharing context, with the same capability purchased five times. The stack has to be split before the question makes sense. Some layers you should never build. One layer you should never hand over.

What should you never build?

The models themselves. Sourcing intelligence beats creating it, every time.

The labs spend billions a year making models better, and every dollar they spend improves what you can source without a line item on your budget. No company outside that race should be in it, and very few should even fine-tune before they've exhausted what context and good architecture get them. Sourcing comes in two modes, and the choice between them is the weight line: rent a closed model through an API, or hold an open-weight model on infrastructure you control, where privacy needs and volume math decide which. Either mode keeps you free to do the highest-return thing in AI architecture right now: mixing models by role, open-weight models on volume work and a frontier model on the judgment tier, swapping either as the leaderboard changes. You can only run that play if you never married a model in the first place, and that's true whether the model lives behind an API or in your own racks.

What should you never just buy?

The layer where your business actually lives: the seams.

The seams are everything between the model and your operation. The pipes that feed your data in, the boundary that keeps your data home, the workflow logic that turns model output into finished work, and the accumulated context that makes outputs correct for your business instead of generic. Off-the-shelf tools bundle their own version of each seam, which is exactly why they don't compose: every subscription is an island holding its own copy of your context. Worse, when you rent the seams, everything your team learns about making AI work flows into the vendor's product instead of your own system, the pattern we covered in the learning ledger. Rent the seams and you're renting your own operations back, which is the same trap, one level down, as rented control. The seams are where your advantage compounds. They should be yours.

What is the assembly answer?

Buy the intelligence. Own the seams. Build only the thin layer that connects them.

In practice, assembly means one architectural spine: a boundary every model plugs into, which we've written up as the model socket, plus your data plumbing and your workflow integration living on your side of it. Models come and go through the socket as guests. Your data, your context, and your accumulated learning never cross it. The word build oversells what this takes: an assembly layer is not a platform project, it's connective tissue, smaller than a typical enterprise software implementation, and it's built once and then amortized by every workflow you add. What it returns is everything the binary can't deliver from either end: current-generation capability on tap, swap freedom when pricing or politics move, the option to pull sensitive workloads onto self-hosted open weights without rearchitecting anything, and learning that accrues to your ledger instead of a vendor's.

Doesn't assembly require an engineering team most companies don't have?

Less than the word implies, and the honest version of this answer has a floor.

The floor first: a small company with one workflow and no sensitive data can start pure-buy, run a single tool, and be right to do it. Assembly earns its cost as stakes rise, when the workflows multiply, the data matters, and the subscriptions start to sprawl. Past that point, the build is smaller than leaders fear. The heavy machinery already exists as rented parts: models behind APIs, mature open-source frameworks for orchestration, infrastructure by the hour. What you're actually constructing is the arrangement, weeks of work, not quarters, and it's the kind of build a partner can construct and hand you the keys to, as opposed to the kind you subscribe to forever. The test of whether you got the real thing is simple to state: when the engagement ends, do you own something that keeps working, or did you just add one more vendor to the pile?

How do you decide what to own?

Sort every piece of your AI stack by a single test: does it compound, or does it depreciate? Own what compounds. Rent what depreciates.

Your data, your workflow logic, your integration layer, and your accumulated learning all compound: they get more valuable as your business runs, and they're worthless to anyone else and irreplaceable to you. Own those. Model capability depreciates, in the best possible way: whatever's best today is second-best in a quarter. So source it and keep it swappable, rented through an API or held as open weights behind your socket, and never sink years into creating it. The one unforgivable move at the intelligence layer is building the thing that's about to be free. Generic applications sit in between: buy them where the job is truly generic, and pull the job into your owned layer the moment it becomes core to how you compete. Then start where we always advise starting, with a beachhead workflow, and let the assembly grow one proven workflow at a time rather than as a big-bang platform. The companies that get AI right this decade won't be the ones that built the most or bought the most. They'll be the ones that knew the difference.

If you want to know what assembly looks like for your operation, mapped workflow by workflow with an owner's architecture behind it,

reach us at contact@theyor.com