← Writing

AI · MBA

Pilot purgatory: where AI projects go to die

Somewhere between the demo that impressed the room and the system that never shipped, most AI initiatives quietly die. The average organisation now scraps close to half of its proofs-of-concept before they reach production, and the survivors take the better part of a year to cross. The comfortable reading is that the technology was not ready, or the team was not good enough. The uncomfortable one, which is this essay's thesis, is that the pilot was designed — rationally, by competent people — so that it could not cross.

That is a claim about optimisation, not talent. A demo is optimised to impress; a product is optimised to survive contact with reality. Those are different objectives, and the gap between them is engineered in at the start, then paid for at the end.

A metaphor on loan from the factory floor

The phrase "pilot purgatory" did not come from AI. The World Economic Forum and McKinsey coined it in their Global Lighthouse Network work, for manufacturers stuck between a promising Industry 4.0 pilot and a factory that actually ran on it. In that literature only about 30% of digital-manufacturing pilots reached scale across the organisation, and the rest leaked their value away.

One caution before the metaphor does any load-bearing work. Those 30%/70% figures are about smart-factory pilots, not AI proofs-of-concept, and it would be sloppy to launder them into the AI debate. I use "pilot purgatory" as a label for a shape — activity that never reaches the bottom line — not as a source of numbers. Borrow the word; leave the arithmetic on the factory floor.

The AI numbers come from elsewhere. S&P Global Market Intelligence ran a survey it calls Voice of the Enterprise: AI & Machine Learning, Use Cases 2025. It polled 1,006 senior IT and line-of-business professionals across North America and Europe. The headline: the average organisation scrapped 46% of its PoCs before they reached production. In the same study, the share of firms abandoning the majority of their AI initiatives jumped from 17% to 42% year over year. The top obstacles were cost, then privacy and data-security risk.

Two honesty notes, because the numbers travel loosely. First, 46% and 42% are not the same statistic and must never be merged. 46% is the average share of PoCs scrapped per organisation. 42% is the share of firms walking away from most of their AI work. Different numerators, different denominators, different sentences. Second, S&P's own page blocks automated access, so the wording here is the one CIO Dive quoted verbatim. I flag that because exact phrasing matters and I have not read it on the primary page.

Secondary readings of the same survey add a cycle time: roughly 48% of AI projects reach production, and getting there takes about eight months. I have only seen that pair in aggregation, not on S&P's own report, so treat the eight months as directional rather than settled — the 46% and 42% are the firmer figures. Even directionally, the shape is clear. Getting to production is slow, and most attempts do not.

Then the forecast. In July 2024, Gartner's Rita Sallam predicted that at least 30% of generative-AI projects would be abandoned after proof of concept by the end of 2025. The named causes: poor data quality, inadequate risk controls, rising costs, or unclear business value. The same release put the cost of a GenAI business-model transformation at 5 to 20 million dollars. Read that as a prediction made in mid-2024, not a measurement taken afterward — Gartner's newsroom is also behind a 403, so the content here is the version carried by trade press. I dismantled the methodology behind figures like these in a companion essay; the short version is that every one of them counts something slightly different. Here I use them as data, not as objects of a teardown, and the teardown lives at /blog/gartner-28-percent.

The last frame is the oldest. Steve Blank, in the Harvard Business Review in October 2019, named the pattern innovation theater. Faced with a threat, organisations produce more process instead of a new answer: hackathons, workshops, innovation pods. Meanwhile procurement, security, and legal quietly make deployment impossible. Blank wrote it before the current wave, and it describes the PoC-as-performance precisely. The demo is the show. The theater is the point.

Why a demo and a product are different animals

The cleanest statement of the gap is one practitioners keep rediscovering: a PoC prioritises velocity, and production prioritises reliability. Those two goals pull in opposite directions, and the pull is structural rather than a matter of care. Optimise hard for one and you build in a debt against the other.

Work it out from first principles, because the authority version explains nothing. A demo runs on a sample of inputs drawn from the easy part of the distribution: clean data, curated cases, fixed prompts, a cooperative operator, no cost ceiling, no clock. That is not cheating — it is what a demo is for. It shows that the thing can work when everything around it is arranged to let it. The trouble is that the arrangement is the result you are measuring, not the model.

Production is the whole distribution, heavy tail and all. It brings data drift, adversarial and confused users, latency and cost budgets, upstream systems that change without warning, and the long list of edge cases that a curated sample was built to exclude. A metric that reads 92% on the demo set can fall far lower on the live one, and that drop is a different problem wearing the same interface, not a bug you patch. The demo answered "can this ever work?" Production asks "does this keep working, cheaply, unattended, when I stop arranging the inputs?"

Most of what closes that gap is not the model. It is the layer around it: data pipelines and the contracts that keep them stable, drift and latency monitoring, versioning and rollback, access control, lineage, human-in-the-loop design, capacity planning, and cost control. Add security, privacy, audit, and a service-level agreement that someone is on the hook for. The operational thesis, in the practitioners' phrase, is that most of the risk in an AI system lives outside the model — in the data flows, the operational decisions, and the feedback loops. A PoC touches none of it. That is why a PoC is cheap, and also why it is not a product.

Name the five things production adds that a PoC never has to carry, because they are the exact five a demo is allowed to assume away. Edge data: the inputs outside the curated sample, where accuracy quietly collapses. Integration: the live upstream and downstream systems the model must read from and write to without breaking them. Maintenance: retraining, drift correction, and the on-call rotation for the day it degrades. An SLA: a signed promise about latency, uptime, and accuracy that someone is measured against. Governance: access control, audit, lineage, and the approval a regulated function will demand before the model touches a real decision. A PoC can skip all five and still demo. A product can skip none of them and still exist.

Make it concrete. A team builds a contract-review assistant that extracts the key clauses from a stack of agreements. On demo day it is flawless. The demo stack was thirty clean, machine-readable PDFs someone selected the night before. Production hands it the real intake: scanned faxes, a merged three-contract file, a language the pilot never saw, a clause phrased in a way no example covered. Accuracy that read 94% on the curated set now reads a number the team is afraid to measure. Nothing about the model changed. The input distribution did, and that distribution was the thing the demo was quietly holding constant. Fixing it is not a tuning pass. It is data contracts, an exception path, a human-in-the-loop review queue, and monitoring to catch the next unseen clause — the whole non-model apparatus the pilot was scoped to skip. The team did not fail. They proved the concept. They just proved it in the one environment where proving it was easy.

This is where the costs get omitted, and not out of laziness: the non-model work is invisible from inside a demo. You cannot see the missing rollback path when nothing has yet gone wrong. You cannot price the data contract when you hand-fed the data yourself. The pilot budget covers the model and the show. The industrialisation budget, often several times larger, is a line item nobody wrote — because nobody owned the day the thing was supposed to ship.

There is a tell that this is a design problem, not a technology problem. MIT's NANDA initiative, in The GenAI Divide (2025), found that roughly 95% of enterprise GenAI pilots produced no measurable impact on profit and loss. The number is contested and easy to over-read — it counts pilots without measurable P&L, not "95% of firms," and I treat it directionally. But the direction is the point: that failure rate held, or rose, across a period when the underlying models improved every quarter. If the models got better and the pilots did not, the defect is in how pilots are structured, not in what the models can do.

The adoption data says the same thing from the other end. McKinsey's State of AI 2025, as cited secondarily, reports that 88% of organisations use AI in at least one function while only 39% report enterprise-level EBIT impact. Starting is easy and nearly universal. Crossing to value is where the population thins out. The bottleneck is the bridge, not the near bank.

The pilot that cannot fail is not an experiment

If the technology is not the cause, the incentives are the obvious suspect, and they do not disappoint. Three structural forces keep pilots alive past the point of usefulness, and all three are rational for the people inside them.

The first is that organisations reward activity, not outcomes. A launched pilot, a fine-tuned model, a slide showing "AI in production" — these are legible and celebrated. Revenue moved and cost removed are slower and harder to attribute to any one person. So the incentive gradient points at starting things, and the career reward lands on the champion who kicked off an expensive initiative, not on the invisible operator who would have had to keep it running. Worse, naming the theater is often career-negative. The sponsor of a costly pilot that delivered nothing gets promoted for "strategic thinking." The person who says it should be killed looks like the one who lacks vision.

The second is that most pilots have no production owner at all. There is a champion who launches it and a vendor who runs it. But no one owns the day it ships, the SLA it must hold, or the metric it must move. The first symptom of purgatory is exactly this: pilots multiplying without a single owner who can state the production criteria out loud. When no one owns the crossing, the crossing does not happen, and no one is accountable for its not happening.

The third force is the sharpest, and it comes from a vendor whitepaper — QueryNow's, which I flag because the diagnosis is a setup for their offer. Their framing, useful even so: a typical pilot has no executable success criteria. It runs in a sandbox against vague goals like "demonstrate value" or "validate feasibility," which means nothing can objectively fail. And a pilot that cannot fail is not an experiment. It is a subscription. The incentives around it conspire to keep it that way. The vendor extends the engagement. The systems integrator bills monthly regardless of outcome. And the sponsor avoids the embarrassment of a verdict by calling the open-endedness "optionality."

Under all three sits an economic asymmetry. The pilot is cheap; industrialising it is not. Some of the cost is data debt — the plumbing needed before a model can even reach production data, which one practitioner estimate puts at three to five times the model budget itself. Treat that multiple as an order-of-magnitude illustration from a blog, not a measured figure, but the direction is right: the model is the cheap part. And at the top of the range sits Gartner's 5-to-20-million-dollar cost of a full GenAI business-model transformation. Cheap to start, expensive to finish, and the expensive part unowned at kickoff. That is a machine for producing pilots that never cross.

Designing a PoC that can cross

The fix is production criteria applied from day zero, before the demo is built, when they are still cheap to insist on — not more rigour applied later. A pilot designed to cross looks different from a pilot designed to impress, and the differences are specific enough to check against.

Name the production owner before the pilot starts. Not the champion who will present it — the person who will answer for the SLA, the cost line, and the metric it must move. If no one will take that role at kickoff, that is your answer about the pilot, and you have it for free before spending a cent.

Set an executable definition of success, numeric and agreed before the first run. Borrow the useful parts of the vendor framing and strip the sales pitch. Use a held-out dataset the buyer owns, so the vendor cannot tune to the test. Fix a numeric pass threshold before starting, so the goalposts cannot move. Run in the buyer's environment, not a curated sandbox. Log reproducible artifacts a skeptic can rerun. Success becomes "a metric that matters moved, in my environment, reproducibly." Not "the demo worked."

Concretely: say the contract assistant must clear 90% extraction accuracy on a two-hundred-document held-out set the buyer sealed before the vendor arrived, and it clears 71%. The pilot has a verdict, and a cheap one, reached before anyone budgeted the rollout. The threshold is there so the answer cannot be renegotiated after the fact by whoever has the most to lose from a "no." It is not there to be kind.

Write the kill criteria at the same time as the plan, not after the sunk cost accrues. CIOs who do this converge on a recognisable list. Kill the pilot when:

  • success is undefined or unmeasurable;
  • the same milestone slips repeatedly and the status report loops;
  • there is no production owner;
  • production accuracy sits materially below pilot accuracy, with no path to close the gap;
  • no sponsor will commit a deployment budget;
  • the business assumption was wrong, and a working model moves no metric that counts;
  • adoption stays poor despite enthusiasm;
  • the vendor folds the capability into the platform's core and commoditises your edge.

The framing matters as much as the list. Killing on these signals is rational reallocation, not failure.

DimensionPoC built to impressPoC built to cross
DataCurated, hand-fed, cleanHeld-out set the buyer owns; live distribution in scope
EnvironmentVendor sandboxThe buyer's production environment
Success"Demonstrate value" (unfalsifiable)Numeric threshold, fixed before the first run
OwnerA champion who presents itA named owner of the SLA and the metric
Cost modelModel cost onlyModel plus the non-model layer, budgeted at kickoff
ExitOpen-ended; renews by defaultKill criteria written with the plan

None of this is expensive. It is a page of decisions taken before the code, and its whole function is to force the questions that a demo is otherwise built to avoid. The cost of skipping it is not visible in the pilot. It arrives eight months later, as a system that impressed everyone and shipped to no one.

When killing the pilot is the right answer

Here the thesis has to defend its own flank, because the obvious misreading of everything above is that a dead PoC is a failure. Often it is the opposite — the intended result of a cheap test working exactly as designed.

A proof of concept is, properly used, a question with a budget. If it returns "no" — this does not clear the threshold, the data is not there, the value is not real — then the process succeeded. It bought a cheap answer to an expensive question before the expensive commitment. Healthy organisations treat a well-run shutdown as a learning win: they archive what was found, document the barrier that killed it, and move the capital. A cheap test that returned "no" is a positive outcome of a decision process, not a scar.

The right unit to optimise, in that light, is not the success rate but the cost of an experiment. Some buyers now ask it directly: how much does a reproducible, safe, useful answer cost — fast enough to still matter when it arrives? Framed that way, many pilots are abandoned not because the idea was bad but because the learning was too expensive relative to what it taught. That is a rational verdict, and it has nothing to do with the model's quality.

There is a portfolio logic under this that a founder already knows. Cheap, reversible probes are options: small premium, capped downside, occasional large upside. The right response to an option that expires worthless is to have paid little for it, not to regret it. A discipline that treats every expired option as a loss to be avoided will stop buying options, which is the same as refusing to explore. So the metric to protect is not how many pilots reached production. It is how cheaply the ones that should have died were allowed to die, and how fast their "no" arrived.

Which is exactly why production-first can be a trap of its own. Impose the full production apparatus on every idea from day zero — SLA, governance, held-out set, named owner, kill criteria — and you raise the price of the cheap exploratory test. Past some point it is no longer cheap. You will kill the fast, disposable probe whose entire value was a quick "no" for a hundred dollars. Loss aversion already pushes the other way, producing zombie pilots that are neither scaled nor killed because ending one feels like admitting waste. The discipline cuts both directions: most experiments should fail, and the ability to end them cheaply is worth as much as the ability to scale them.

And sometimes the eight months is simply correct. When the pilot's real target is integration with a critical system, or a governance regime you are not allowed to shortcut, a long, careful cycle is not purgatory — it is the work. The thesis is narrower than "slow pilots are bad." It is about proofs of concept that were meant to reach production and were designed, by optimisation and incentive, so that they could not. That is a different animal from the exploratory test that was always allowed to die.

The honest test between the two is a single question asked at kickoff: was this pilot supposed to cross? If yes, and it has no owner, no executable success criterion, and no kill switch, it is not exploring. It is performing. If no, then leave it cheap, leave it fast, and let it fail without ceremony.

The number to be afraid of

The 46% is not the scandal. Scrapping PoCs is what a functioning experiment budget looks like, and a firm that killed none of them would be failing in a quieter, more expensive way. The scandal is hidden underneath the number. Ask how many of those PoCs were built by capable people who knew, on day one, that no one owned the day they were meant to ship — and who built the demo anyway.

Purgatory is not where projects go to die by accident. It is where they are sent, fully funded, by an organisation that rewards the sending. Design the crossing before you build the demo — or admit that the demo was the product all along.

Sources

  1. primaryS&P Global Market Intelligence, Voice of the Enterprise: AI & Machine Learning, Use Cases 2025 — 1,006 respondents; 46% of PoCs scrapped before production; firms abandoning most AI initiatives up from 17% to 42%. (Primary page returns 403; figures quoted verbatim by CIO Dive.)
  2. primaryGartner, "Gartner Predicts 30% of Generative AI Projects Will Be Abandoned After Proof of Concept By End of 2025," press release, 29 July 2024 (Rita Sallam) — the 30% forecast and the 5–20 million dollar transformation cost. (Newsroom 403; content via trade press.)
  3. primarySteve Blank, "Why Companies Do 'Innovation Theater' Instead of Actual Innovation," Harvard Business Review, October 2019.
  4. primaryMcKinsey & Company / World Economic Forum (Global Lighthouse Network), "How digital manufacturing can escape 'pilot purgatory'" — origin of the term; ~30% of manufacturing pilots reaching scale (not an AI figure).
  5. primaryMIT NANDA, The GenAI Divide: State of AI in Business 2025 — ~95% of GenAI pilots without measurable P&L impact (used directionally; unit-of-analysis teardown in the companion essay).
  6. primaryMcKinsey & Company, State of AI 2025 — 88% of organisations using AI in at least one function; 39% reporting enterprise-level EBIT impact (accessed here via secondary citation; verify against the primary before hard quotation).
  7. secondaryCIO Dive, "AI project failure rates are on the rise: report" — verbatim 46% / 42% / 17% from the S&P survey.
  8. secondaryODSC / Medium, "Why AI POCs Fail: The Real Gap Between Pilot and Production" — velocity vs reliability; the risk that lives outside the model.
  9. secondaryQueryNow, "The enterprise AI pilot paradox: Why pilots multiply while production stalls" — vendor whitepaper; the "pilot with no failure condition is a subscription" framing and the held-out-set proposal.
  10. secondaryInformationWeek, "The Red Flags That Signal an AI Project Isn't Worth Pursuing" — the CIO kill-criteria list.
  11. secondaryForbes (Jason Snyder), "MIT Finds 95% Of GenAI Pilots Fail Because Companies Avoid Friction" — reporting on the MIT NANDA figure.
  12. secondaryEntrepreneur, "The One Metric That Explains Why So Many AI Pilots Never Get Off the Ground" — the cost-of-experiment framing.