ztzoff.tech

Nov 5, 2026

Where your AI pilot is stuck, and the one thing that would move it

Six symptoms of a stalled agent pilot, each placed on the Discover, Design, Build, Scale map, with the single missing deliverable that would unstick it. Most pilots are stuck in the same two places.

Every stalled pilot I have looked at was stuck at a stage boundary, missing one deliverable that the next stage needed. The team usually blamed the model, the data, or the budget. It was almost never any of those. This is the closing essay of the Discover, Design, Build, Scale series, and it is the diagnostic I run in the first conversation: match the symptom, find the stage, name the missing thing.

Symptom: "We have a demo and nobody knows what to do with it"

Stuck between Discover and Design. The demo was built to show what the technology can do, not to do a specific job measured a specific way. There is no sentence of the form "a run succeeded when our own check says so", because nobody chose a workflow narrow enough to have a check.

The missing deliverable: a costed opportunity map with two or three real workflows and the check for each. The audit is the product. Until it exists, the demo is a technology, not a project.

Symptom: "It works on our examples but the business won't sign off"

Stuck between Design and Build. The examples were chosen by the people who built it. The business is right not to trust them. There is no evaluation written by the people who do the job, with cases they chose and a threshold they set.

The missing deliverable: the eval, written before the build, run against a baseline. Sometimes the honest result is that the eval kills the build, and that is a cheaper outcome than the alternative.

Symptom: "It's been in pilot for eight months"

Stuck inside Build. This is the most common one. The build never had an exit test, so it never ended. Each week brings a new edge case, a new prompt tweak, a new reason not to call it done. Usually no real user has been inside it since the sponsor's demo.

The missing deliverable: the "done" list: an eval on every change, a holdout result, a runbook, a cost per run, and a named owner. A build with that list finishes in six to fourteen weeks. A build without it never finishes.

Symptom: "We can't say whether it's helping"

Stuck between Build and Scale. The agent was switched on for everyone at once. The only baseline is memory. There are anecdotes and a run count, and the sceptics and the champions are both right because nobody can prove either wrong.

The missing deliverable: the holdout result. A random share of runs on the old path, both groups judged by the client's own check, a difference with an interval. I explain why every pilot should have one, and it is the cheapest item on this page: a few percent of runs and a verifier you already have.

Symptom: "The vendor left and nobody dares touch it"

Stuck at the start of Scale. The agent works, more or less, and everyone is afraid of it. There is no eval to tell them whether a change broke anything, no runbook for when it fails, and no one with the access and the mandate to own it.

The missing deliverable: an owner and an operating model. Who owns the agent at month six describes the role; the eval and runbook are what make it a job a person can do rather than an act of courage. If the system is already in production, this is a three-week system audit, not a rebuild.

Symptom: "The second one is going worse than the first"

Stuck inside Scale. The second agent shares tools, memory or traffic with the first, and things that were free with one agent, permissions, cost, drift, are now bugs. Usually the first agent's benefit was never measured, so the second was approved on enthusiasm.

The missing deliverable: the handful of shared systems from the second agent is harder than the first: one permission check outside every agent, a shared trace format with version stamps, a per-workflow cost line, and memory that is scoped, gated and measured or not shared at all.

A vertical map of the four stages with six symptoms placed where pilots stall and the missing deliverable for each. Between Discover and Design: we have a demo and nobody knows what to do with it, missing a costed opportunity map. Between Design and Build: it works on our examples but the business will not sign off, missing the eval run against a baseline. Inside Build, marked most common: it has been in pilot for eight months, missing the done list. Between Build and Scale, marked cheapest fix: we cannot say whether it is helping, missing the holdout result. At the start of Scale: the vendor left and nobody dares touch it, missing an owner and an operating model. Inside Scale: the second one is going worse than the first, missing one permission check, a shared trace format, a per-workflow cost line and gated memory.

The pattern

Six symptoms, but two places hold most of the pilots I see: inside Build, with no exit test, and at the Build-to-Scale boundary, with no measurement. Both have the same root. Nobody wrote down, before the work began, what "worked" means in a way the client's own code can check. Every deliverable above is a consequence of that one sentence.

Which is why, when a company asks me where to start, the answer is almost never "with a bigger model" and almost always "with the check". It takes an afternoon to write, and it decides everything downstream.

If this is you

Match the symptom. Find the stage. The missing deliverable is a few weeks of work, not a new programme, and in two of the six cases it is less than that. If you would like a second pair of eyes on which symptom you have, that is exactly the conversation in a free AI readiness assessment: one call, your pilot placed on the map, and the one thing that would move it. If it turns out the honest answer is "don't build", I will say that too.

Book a discovery call