Enterprise AI adoption in the AI industry now turns on disciplined use-case selection, not model access. Foundation-model labs, infra providers, and AI-native startups all face the same question: build, buy, or fine-tune. Most organizations run 10 or more pilots but ship fewer than a quarter to production, and roughly 70 to 80 percent of pilots stall before real value lands. This playbook frames how to pick use cases with clear economic value, choose between frontier models and fine-tuning, deploy agents safely, and move from demo to durable production capability with measurable throughput.
Adoption stalls at the pilot line, not the model
Access to frontier models is no longer the constraint. A capable base model costs cents per thousand tokens through an API, and open-weight alternatives run on commodity GPUs. Yet the gap between experimentation and production remains wide. Across large enterprises, teams typically launch 10 to 20 generative AI pilots per year, and industry surveys consistently show that 70 to 80 percent never reach production. The bottleneck is use-case selection, integration, and governance, not raw capability. Frontier training runs now exceed $100M for a single model, but that spend belongs to the labs; the adopter economics are dominated by inference, integration engineering, and change management.
The AI industry itself is the sharpest test case. Foundation-model labs adopt AI internally for evals and code generation. Infra providers embed AI in scheduling and capacity planning. AI-native startups build products where the model is the core value. In every case, the winning pattern is the same: pick a narrow, high-frequency workflow with a measurable baseline, wire the model into that workflow end to end, and instrument the result. A coding assistant that lifts merged pull requests per engineer by 15 percent beats a broad AI transformation that ships nothing. Value concentrates where volume is high and the cost of a wrong answer is bounded and recoverable.
Build, buy, or fine-tune by use-case profile
Map each candidate use case against three axes: how differentiated the capability must be, how sensitive the data is, and how much volume it carries. The answer to build versus buy versus fine-tune falls out of that profile rather than from preference.
| Use-case profile | Recommended path | Why it fits |
|---|---|---|
| Commodity task, low differentiation (summaries, classification) | Buy: hosted frontier API | Fastest to value; no moat in owning the model; per-call cost is trivial at these volumes |
| Core product capability, high differentiation | Build or fine-tune on open weights | The model is the product; control over latency, cost, and behavior is strategic |
| Domain-specific style or format, moderate volume | Fine-tune a mid-size model | Captures house patterns cheaply; a 7B to 13B model often matches a frontier model on narrow tasks |
| Multi-step workflow with tool use | Agentic orchestration over a hosted model | Value comes from the scaffold and tools, not the base model; keep the model swappable |
| Regulated or highly sensitive data | Self-host open weights in your boundary | Data residency and audit control outweigh the convenience of an external API |
Move from pilot to production deliberately
- Rank candidate use cases by frequency times value-per-run, and fund only the top three; kill the rest before they consume engineering time.
- Define a numeric baseline for each shipped use case (cycle time, resolution rate, cost per task) before writing any prompt, so lift is measurable.
- Default to a hosted frontier model for the first version; reserve fine-tuning and self-hosting for cases where the profile above clearly demands it.
- Deploy agents behind a human checkpoint for any action that writes to a system of record, and log every tool call with inputs and outputs.
- Set a production readiness bar (eval pass rate, latency budget, rollback plan) that every pilot must clear before it touches real users.
Where AI adoption programs go wrong
- Chasing breadth over depth: running 20 shallow pilots instead of shipping three deep ones that change a real metric.
- Fine-tuning too early, before a hosted base model has proven the use case has value at all.
- Treating agents as autonomous from day one, with no human checkpoint and no logging, then discovering silent failures in production.
- Ignoring integration cost: the model is 10 percent of the work, and the data plumbing, evals, and monitoring are the other 90 percent.
Instrument adoption end to end
- Pilot-to-production conversion rate: share of pilots that reach real users, targeted above the 20 to 30 percent industry norm.
- Task-level lift: measured improvement in cycle time or resolution rate against the pre-AI baseline for each shipped use case.
- Active usage: weekly active users of each deployed capability divided by the eligible population.
- Cost per successful task: fully loaded inference plus overhead per completed unit of work, tracked over time.
Frequently asked questions
How do we decide between a frontier model and fine-tuning?
Start with a hosted frontier model to validate that the use case creates value. Only fine-tune once you have proof of value and a specific reason: a house style, a narrow domain, or unit economics where a smaller fine-tuned model is materially cheaper at your volume. Fine-tuning before validation wastes effort on use cases that were never going to ship.
Why do most AI pilots fail to reach production?
They fail on integration, evaluation, and governance rather than model quality. Teams demo a prompt that works on happy-path examples, then discover they have no eval set, no monitoring, no rollback, and no owner for the workflow. Building those foundations before scaling is what separates the pilots that ship from the 70 to 80 percent that stall.
When should we deploy agents versus a single-shot model call?
Use a single model call when the task is one step and the output is the answer. Use an agent when the task requires multiple steps, tool use, or retrieval, and the value comes from the orchestration. Keep the base model swappable, put a human checkpoint on any write action, and log every tool call so failures are debuggable.
Related reading
Go deeper on this sector and topic.