10 min read

B1
Operation · Economics & ROI

Build vs Buy vs Orchestrate

The agent loop is an MIT commodity, the runtime is billed in vCPU-hours, and the product is billed per outcome — so the only layer left worth owning is the one nobody sells you.

Five of the six biggest agent frameworks ship under MIT or Apache-2.0 — the sixth ships MIT in Python and all-rights-reserved in TypeScript — and on 30 November 2026 OpenAI retires its own visual Agent Builder in favour of its MIT-licensed SDK — which means "build" no longer means writing the loop, and the build-versus-buy argument you inherited is about a layer that stopped costing money. What is still unpurchasable is your eval set, your labels, and the verifier that decides what "done" means. Everything below prices the other layers, as of November 2026, so you can see how small they have become.

Step 1Three branches, and the line between them has moved down the stack.

Buy a finished product when the workflow is generic and your differentiation is elsewhere. Build when the agent's behaviour is the product. Orchestrate — assemble a model, a framework and managed tools into a system that is yours — when you own the workflow, the data and the evals but rent the machinery. That structure still holds; what changed is that the machinery is close to free, so orchestrating is no longer a middle path but the default, and "build" has shrunk to the thin core above it.

Check the licences rather than the marketing, because the commoditisation is verifiable. As of November 2026 openai-agents-python, langgraph, pydantic-ai and crewAI ship MIT, and Google's adk-python ships Apache-2.0. OpenAI is winding down Agent Builder and Evals on its platform on 30 November 2026 and pointing users at the SDK: the largest vendor in the category has stopped selling a product wrapped around the loop.

One exception, and it is the one most likely to catch you. Anthropic's Claude Agent SDK ships MIT in its Python repository, but both its Python and TypeScript READMEs route use of the SDK through Anthropic's Commercial Terms of Service, "including when you use it to power products and services that you make available to your own customers" — and the TypeScript package carries no open-source licence at all, just an all-rights-reserved notice. "Open source framework" is a claim to verify per repository, not per vendor.

Step 2Price the branches with current numbers, because the hidden costs moved too.

Renting the runtime is cheap per unit and complicated per invoice; the variance between providers is not the unit price but how many separate meters you have to model.

  • Amazon Bedrock AgentCore: Runtime v1 at $0.0895 per vCPU-hour plus $0.00945 per GB-hour, per second; Gateway at $0.005 per 1,000 tool invocations; short-term memory at $1.00 per GB ingested, $0.20 per GB retrieved, $0.10 per GB-month stored (moved from flat per-event metering on 6 October 2026); long-term memory at $0.75 per 1,000 records a month. Roughly eight meters, all separate from model tokens.
  • Google Vertex AI Agent Engine: $0.085 per vCPU-hour, $0.009 per GiB-hour and $0.30 per GiB-month of storage — with session and Memory Bank operations converted into vCPU-hours at one per million writes and one per three million reads. One unit, unusual arithmetic.
  • Microsoft Foundry Agent Service: no additional charge at all for Foundry-native agents built from prompts and workflows. You pay models and tools; the orchestration layer is free.
  • Cloudflare Durable Objects, under Cloudflare Agents: $5 a month minimum, 1 million requests then $0.15 per million, 400,000 GB-s then $12.50 per million GB-s. Two meters, runtime only.

Buying the product is where the money is, and its shape moved from seats to consumption. Per-seat list prices are now the floor, not the bill.

  • GitHub Copilot moved to usage-based billing in June 2026, retiring the old premium-request model. Business is $19 per user per month including 1,900 AI credits, Enterprise $39 including 3,900. A credit is $0.01, so the included allowance is literally your seat fee returned in credits; credits pool at the billing entity, do not roll over, and overage at $0.01 per credit is enabled by default.
  • Microsoft 365 Copilot is $30 per user per month; Copilot Studio capacity is $200 a month for 25,000 Copilot Credits billed annually, or $0.01 per credit pay-as-you-go — so a fully consumed pack is about 20% cheaper per credit, and wasted if under-consumed, since unused credits expire.
  • Salesforce Agentforce publishes an unusually complete card: Flex Credits at $500 per 100,000 ($0.005 each), where a standard action consumes 20 credits ($0.10) and a voice action 30 ($0.15), alongside a still-live $2 per conversation model and editions from $195 to $550 per user per month. An org runs one consumption model at a time.
  • Intercom Fin charges $0.99 per resolved outcome ($9.99 for a sales qualification), at most one per conversation, and nothing for escalations to a human. Sierra publishes no rate card, and ServiceNow meters Now Assist in "assists" whose per-action values and pool sizes are not publicly disclosed — treat an unpublished price as a cost, not a blank.

Build the comparison on cost per successful task rather than the quoted unit and the models become commensurable: a $0.99 resolution and twenty $0.10 actions are the same bill only if the twenty actions resolve the case. See agent unit economics for why the verifier that decides "successful" moves this number more than any token saving.

Step 3Own the eval set, because it is the one layer with no vendor.

Stack the agent into layers and price each. The model is a commodity deflating fast (STEP 4). The runtime is $0.085 per vCPU-hour. The framework is MIT. The tools are a catalogue. What is left is the part with no price, because nobody can sell it to you: the task set that represents your work, the labels on it, and the verifier that decides what counts as done.

You can rent the instrument that displays it, and should. As of November 2026 the free allowances alone span an order of magnitude for broadly similar telemetry: LangSmith is free at 5,000 base traces a month with Plus at $39 per seat for 10,000; Braintrust's Starter is free at 1 GB processed and 10,000 scores, overage $4 per GB and $2.50 per 1,000 scores, Pro $249 a month; Langfuse's Hobby tier is free at 50,000 units, then $29, $199 and $2,499, with overage from $8 per 100,000 units falling to $6; Pydantic Logfire is free at 10 million spans a month, $2 per million beyond.

Two licence facts matter if owning the layer means self-hosting it. Arize Phoenix is under Elastic License 2.0, not an OSI licence: it says plainly that "you may not provide the software to third parties as a hosted or managed service." Langfuse is split — MIT outside its ee/ directories, a separate enterprise licence inside. Both are fine for your own use and both constrain resale, which is the distinction a build-versus-buy memo should make instead of writing "open source".

The eval set also carries a maintenance bill the tool does not: a suite decays on its own, and the measurement that catches it is a reference run against your own ceiling. Budget it alongside the cost of evaluation — the only line item on every branch of the tree.

Step 4How fast a layer commoditises depends on how old its capability is.

"Rent what commoditises" is right and incomplete, because the deflation rate is not a constant — and knowing its shape tells you when building a lower layer is merely unwise versus actively absurd.

Epoch AI's series is the rigorous one. The price of reaching a fixed capability level has fallen at a median of about 50× per year across benchmarks, roughly 200× when pre-2024 data is excluded, with individual benchmarks spanning 9× to 900×; averaged differently it runs about 47% per quarter since 2023. The important part is the curve, not the average: cost falls about 66% per quarter (≈75× a year) while a capability is new, and only about 32% per quarter (≈4.7× a year) two years later, because vendors charge a premium for a newly reached performance level until competition erodes it. A March 2026 analysis by Gundlach and colleagues, which Epoch calls the most thorough to date, puts it at 5–10× a year.

Read the consequence for the decision:

  • An asset built on a brand-new capability loses about two-thirds of its cost advantage per quarter, so self-hosting to beat today's inference price, at the moment that price is falling fastest, is the worst-timed purchase on the board. And by the time deflation slows enough for ownership to look rational, renting is cheap — the layer never passes through a window where building it pays.
  • Per-token deflation is not per-task deflation. Reasoning models consume far more internal tokens than they emit, so a falling price per token can coexist with a rising bill per task — which is the subject of fewer tokens versus cheaper tokens. Model the task, not the token.
  • Epoch's own caveat is worth carrying: benchmark-normalised estimates may be inflated because distilled models over-perform on benchmarks, and the steepest declines are the most recent, so persistence is unproven. Plan around these rates; do not underwrite with them.

Step 5Price lock-in as the shape of the meter, not the name of the vendor.

Three lock-in surfaces still dominate — model, framework, data gravity — and they now show up as specific, checkable shapes rather than a general worry.

  • Meter shape decides how much of your cost model is portable. A system costed against roughly eight AgentCore meters cannot be re-costed against Cloudflare's two without rebuilding the model. The migration cost is in the forecast, not the code — which is the practical content of forecasting agent spend.
  • Non-rolling credit pools are a commitment, not a discount. GitHub's reset monthly and Copilot Studio's expire at term, so a pack you under-consume is a price rise you chose. Size pools to the p25 of your usage and let overage carry the tail — at $0.01 a credit it is the same unit price as the pack. And a one-at-a-time consumption model is an exit cost: moving between Agentforce's per-conversation and Flex Credit models replaces SKUs rather than settings.
  • Platform layers do disappear, and that is now evidenced rather than theoretical. OpenAI retiring Agent Builder and Evals on 30 November 2026 is the risk in practice: workflows authored in it do not port themselves, and the migration path is the SDK. See exiting a managed agent runtime and model deprecation and migration.

Reversibility should still outweigh price: a buy you can exit in a quarter is cheap insurance at a higher monthly rate, and a build that takes two years to undo is expensive at a lower one. The assets that make reversal cheap are the portable ones — your eval suite, your prompts as data, and a seam at the model boundary.

Step 6The forecasts say the project dies of governance, not of the branch you picked.

Nobody has a measured population-level failure rate for agent programmes, so be careful with the numbers in circulation — and then notice that they all point away from the build-versus-buy question.

  • Gartner, 25 June 2025: over 40% of agentic AI projects will be cancelled by the end of 2027, attributed to escalating costs, unclear business value or inadequate risk controls. The same release coined "agent washing" and estimated that only around 130 of the thousands of vendors claiming agentic AI offer genuine agentic capability.
  • Gartner, 29 September 2026: 70% of enterprises will abandon agentic AI built by vendor forward-deployed engineering by 2028 — the most directly on-point buy-versus-build statistic available, and still a forecast. Its hype-cycle work puts only 17% of organisations in deployment today against more than 60% expecting to be within two years, which is the gap both forecasts are about.
  • The MIT Project NANDA figure — 95% of enterprise GenAI projects yielding no measurable return — is the number everyone quotes and the one to handle most carefully: the report concedes its findings are "directionally accurate based on individual interviews rather than official company reporting", secondary accounts disagree on its sample size, and critics reconstructing its own funnel land nearer 75% of pilots missing a deliberately demanding threshold. Quote it with the caveat or not at all.

Every one of those attributions — unclear business value, inadequate risk controls, a pilot that cannot show a return — is a measurement failure, not a sourcing failure. Teams rarely lose because they rented a runtime they should have written; they lose because nothing could say whether the agent worked, so the cost was legible and the benefit was not. The failure patterns are catalogued in economics failure modes and measuring ROI.

The decision rule, in order. First build the eval set and the verifier, on any branch, because every branch bills for it and no branch survives without it. Then rent the model and the runtime, always, because the layer you would be buying is deflating by roughly a third to two-thirds a quarter. Then buy the product wherever the workflow is generic, and price it per successful task rather than per seat. Then build only the thin core that carries proprietary signal, and give it an exit: a model seam, prompts stored as data, and your traces in a format you can read without the vendor. Renting the rest is not technical debt; it is the only way to afford the one layer that compounds.