Why AI Coding Pilots Stall Before Production

Why AI Coding Pilots Stall Before Production

Between mid-2025 and mid-2026, half a dozen surveys asked some version of the same question: how many enterprise AI-agent pilots, coding agents included, actually reach production? Most don't, and it isn't a model quality problem. The data is consistent: a Zapier-commissioned survey of more than 800 senior leaders found that 84% of companies have at least one AI pilot that never made it to production, and 38% say their longest-running pilot has sat in evaluation for over a year.

MIT Media Lab's Project NANDA report, published in July 2025, found that roughly 95% of organizations saw no measurable profit-and-loss return from their generative-AI pilots. Those two numbers get treated as the same statistic online. They're not: one counts pilots that never shipped, the other counts pilots that shipped and still didn't pay off. Different population, different metric, same conclusion — most agentic AI projects never reach a state anyone would call production.

It isn't a model problem

The comfortable explanation is that the models still aren't good enough. That's not what the people who ran these numbers concluded.

Gartner's June 2025 forecast, from senior director analyst Anushree Verma, predicts that more than 40% of agentic AI projects will be canceled by the end of 2027. The named causes: escalating costs, unclear business value, inadequate risk controls. Model capability isn't on that list.

MIT's report goes further. It rules out model quality, infrastructure, regulation, and talent as the barrier. What it points to instead is a "learning gap" — how organizations adapt their processes around the tool.

Two of the most-cited studies in this space looked directly at causes. Neither blamed the model. The code an agent writes in a pilot is usually fine already — what's missing is everything meant to sit around it before that code goes near a client repo.

The governance gap, in numbers

Picture a new contractor walking into your office with no badge, no signed contract, and a key to every room. That's the average production AI agent deployment today. Gravitee's State of AI Agent Security Report 2026, based on a survey of 750 senior technology leaders fielded in April 2026, found that only about 19.7% of organizations say all of their production AI agents are fully secured and governed before going live.

Roughly 48% of production agents run unsecured. Only 7.2% of organizations have a named individual with formal accountability for what an agent does. Those aren't hypothetical risks in a slide deck — that's the current state of the average production agent deployment, coding agents included.

Four out of five organizations can't say their agents are fully governed. Most pilots stall before production. Same gap, measured from two directions.

Why this hits SMEs harder

Company size doesn't move the bar here. It moves who has to build the machinery to clear it. A large enterprise already runs an identity team, a SIEM, and a compliance function that spent a decade adapting to service accounts and third-party contractors — extending that to cover an AI agent is mostly configuration.

An SME usually has none of that machinery to extend. But the client contract clauses on data handling stay the same, and the audit obligation kicks in the moment a client's codebase is in scope. Often the entire security function is one person, or whoever also handles DevOps on Fridays.

That gap between obligation and infrastructure is where a consulting engagement earns its fee. Not making the pilot's code better — building the layer around it that the pilot skipped. Running that engagement itself well matters too, and that's its own discipline worth locking down before the first agent gets near a repository.

What to put in place before an agent touches a repo

Six things need to exist first. Roughly ordered by how much damage the gap causes if it's missing:

1. Named-identity mapping. Every agent session traces to a human account through SSO — SAML or OIDC. "The agent did it" isn't an audit answer; "this agent, under this person's session, at this timestamp" is.
2. Secret-scanning gate on every agent pull request. Agents pull in API keys and credentials from wherever they're visible in a repo or its history, and will commit one if nothing stops them. Runs before merge, not after.
3. Sandboxed execution. The agent runs and tests code somewhere that isn't production, with network egress restricted to what the task needs.
4. RBAC and least privilege. The narrowest set of repos, branches, and tool permissions the task requires, never a standing credential with the reach of a senior engineer.
5. Audit logging wired to SIEM. Every tool call, file write, and command execution lands in a log security tooling already watches, not a separate dashboard nobody opens.
6. A data-residency decision, made once, in writing. Where does the model provider process the code, and does that satisfy the client contract or the regulator you answer to?

None of this is exotic. It's the same access-control discipline an SME already applies to a new contractor or SaaS vendor — applied to software that can act on its own.

Laid out as a path from pilot to production, the gates look like this:

A pilot that jumps straight from "the agent wrote working code" to "ship it" is skipping every gate in that diagram at once.

Where to pilot it

Pick the pilot's target like any controlled experiment: bounded, reversible, low blast radius. An internal tool, a documentation site, a test-suite backlog, a low-traffic microservice — somewhere a bad merge costs an afternoon, not a client relationship.

Don't pilot on the core production repo or near a client's codebase until the six gates above are already proven on something smaller. The pilot isn't there to prove the agent can write good code — every vendor demo already answers that. It's there to prove the governance scaffolding holds up under real use before the stakes go up.

How to measure a pilot honestly

This is where most pilots quietly lie to themselves. The instinct is to measure success by whether the agent produced working code, merged pull requests, or saved engineering hours. Those numbers are real, but they answer the wrong question.

The right test: would the pilot pass a compliance and access-control audit today? Can you show exactly which human is accountable for every agent action, exactly what the agent can and can't touch, and exactly where its output gets logged? Gravitee's numbers say most organizations running agents in production couldn't answer yes to that.

If your pilot can, you've built something more valuable than an agent that writes good code. You've built one that's actually allowed to ship.

Governance first is the only path to production

Governance-first looks like the slow path when a pilot is already producing decent code and just waiting on a green light. It isn't. It's the only path that ends in production instead of the same evaluation folder where most stalled pilots are still sitting, some for over a year.

The six gates above take a few weeks to stand up properly with someone who's done it before running the setup — a scoped agentic-AI readiness review, gate by gate. Not a retrofit after a client asks an audit question you can't answer.