Richard Teachout // Teachout.com
← All writing

Build, Buy, or Rent Is the Wrong Question. Ask Where the Leverage Compounds.

Richard Teachout
Richard Teachout CTO at Ashley Furniture Industries - Executive Tech Leader, Entrepreneur, AI leader, Architect, Problem Solver, Ex-Developer. November 17, 2026
AI
Build, Buy, or Rent Is the Wrong Question. Ask Where the Leverage Compounds.

Every quarter someone asks me whether we should build our own AI capability, buy a product, or rent a model through an API. It's a reasonable question, and it's the wrong one. Build versus buy is a procurement frame. It assumes the thing you're acquiring is static — a tool that does a job. AI isn't that. AI is a capability that gets better or worse depending on what you feed it and who's operating it, and the right question is: where does the leverage compound, and do we own that part?

I think about any AI capability as three layers, and I answer build/buy/rent differently at each one.

The model layer: rent, with an exit. Frontier models are a commodity that improves every quarter whether you do anything or not. Building one is out of the question for almost everyone, and buying one — locking into a single provider — means betting that your pick stays ahead. Rent through a gateway that lets you swap, run evals across providers, and route by cost and quality. The exception is local models for data that can't leave or latency that can't wait, and even then you're renting the weights and owning the operations.

The context layer: build, always. This is your data, your retrieval, your process knowledge, your evals, your prompts, your permission model. It's the part that makes a generic model useful for your business specifically. It's also the part that compounds: every month of operation produces more labeled examples, better evals, tighter prompts. If you rent this — if a vendor owns your retrieval index and your prompt library — you're paying someone to accumulate your leverage.

The application layer: buy where it's generic, build where it's differentiating. Meeting transcription, document summarization, code assistance — buy it. Nobody wins by building their own meeting notes. The agent that runs your returns process, the model that plans your factory floor, the system that knows your product catalog better than your merchandisers — build it, because that's where you're different, and difference is the only thing worth owning.

For any capability, ask: twelve months from now, is this better because we operated it? If yes, it's leverage, and you should own the part that improved. If no, it's a utility, and you should rent it from whoever's cheapest.

A vendor's customer-service bot gets better because the vendor operates it across a thousand customers. Your share of that improvement is small. Your own agent on your own tickets, with your evals and your escalation data, gets better because you operate it — and all of that improvement is yours.

That doesn't mean you build everything. It means you're deliberate about where the learning accrues.

Once you frame it this way, the vendor conversation changes. I'm no longer asking "does the product work." I'm asking:

Where does my data live, and can I take the index and the labeled examples with me? If a vendor's answer is that the context layer is proprietary, that's a hard stop no matter how good the demo is.

Can I swap the model underneath? If the application is welded to one provider's model, I'm renting a dependency, not a capability.

What improves from my usage, and who owns the improvement? If the answer is "the product gets better for everyone," that's a utility, and I'll pay utility prices for it.

It also disciplines the build side. Engineers want to build everything; it's what they're for. The compounding test tells them where to spend. Build the eval framework — it compounds across every system. Build the retrieval layer over your own data. Build the permission model. Don't build the chat interface, the transcription, or the model.

The platform team's backlog should be almost entirely context-layer work. If it's full of application features, you're building what you should buy. If it's full of model work, you're building what you should rent.

So: build, buy, or rent? Rent the model. Build the context. Buy the generic applications and build the differentiating ones. And at every layer, ask who ends up owning the leverage after a year of operation.

Most organizations get this backwards. They lock into a model, rent their context from a vendor, and build applications nobody will remember in three years. The ones that get it right look boring from the outside — commodity models, a lot of unglamorous data and eval work — and in two years they have something nobody can buy.

Think this argument fits your event? Tell me about the room — the calendar is selective.

Start a conversation