By Keith Rull ·
An AI pilot stalls before production when nobody has named the real task, the cases that must pass, or the cost of human review. The demo can look finished while the workflow still fails on ordinary work. Repair it, narrow it, or stop it. Tuning a model against a job you have not defined will not get you there.
The model is often the last place the stall starts. Here is where I would look first.
Why does a pilot look finished and then stall?
Four gaps show up over and over. They are ordinary, and they are easy to miss because the demo hides them.
The demo set is not the work. A short list of clean examples can make a pilot look ready, while real work includes missing fields, angry users, old policy, and the case that happens twice a week and costs the most. A good result on curated inputs says little about whether the whole workflow can run.
The task is not written down. If nobody can say what the system receives, what a good result is, and who acts on it, then “better” has no meaning. People reach for the prompt because it is the part they can edit in an afternoon, and the prompt is not the task.
The failure often starts upstream of the model. A wrong answer can begin with a revoked permission, a stale document, or a handoff that drops the context a person needs, and changing the model does not fix a broken input.
The operating cost shows up late. Tokens are the visible bill, and retries plus human review are the rest of it. A pilot that saves a minute of drafting and adds five minutes of checking has not moved the work forward. I would compare that full cost with the current process before calling the pilot a win, which is the same comparison an AI strategy assessment starts with.
What should you check before you tune the model?
1. Name the production task
Write what the system receives, what success looks like, and who acts on the output, and put the manual workflow next to it, including the exceptions and the time people already spend on review. If you cannot do that on one page, you have a demo rather than a pilot.
2. Cluster the failures
Use representative cases you are allowed to inspect, and group them by input, retrieval, model behavior, integration, or handoff. A cluster tells you where to spend the next week, and a pile of one-off complaints does not.
3. Count the operating burden
Track the full cost of a completed task. Include retries and the minutes a person spends checking or fixing the result. Write down what triggers an escalation, and how long recovery takes when the system fails. If you cannot see that cost, you cannot tell a repair from a slower process.
4. Set a decision checkpoint
Agree the quality bar and the operating limit before the next round of changes. At the checkpoint, repair, narrow, or pause. Keep a fallback for the people who rely on the workflow while you test a repair.
This support-desk sketch is hypothetical. It is not a client engagement.
A team wants an assistant to draft replies on billing questions. The demo used twenty tidy tickets, and the drafts looked helpful. The live queue is different. Some customers are angry. Some tickets have no account number. Some ask for a refund the policy does not allow. A useful diagnosis groups those, instead of editing the prompt after each complaint.
| Cluster | What you see | Where to look first |
|---|---|---|
| Missing account number | The draft asks the customer to repeat data the agent already had | The ticket fields passed into the prompt |
| Policy exception | The draft offers a refund the rules forbid | The policy text, and whether it is current |
| Tone on an angry ticket | The facts are fine and the reply makes it worse | A separate check, or a human for that slice |
| Tool timeout | The draft says it updated the account, and it did not | The action log, not the wording |
The third row is a reason to narrow the pilot, not a reason to retrain anything. The fourth row is an integration failure. More prompt words will not write the update that never happened.
How do you decide to repair, narrow, or stop?
Use the clusters and the cost, not the vibe of the demo.
Repair when the failures sit in one cause you can test. A stale policy file is a repair. So is a missing field that you can pass in. Keep the same case list, change one thing, and see whether that cluster shrinks. That fixed list is an eval set: the real cases you run every change against.
Narrow when the assistant is good on a slice and bad outside it. Let it draft the plain billing replies. Keep a person on the angry tickets and the policy exceptions. A smaller pilot that people trust beats a wide one they quietly route around.
Stop when review time is already higher than doing the work, or when you cannot get representative cases. Also stop when each fix helps one case and breaks another, and you have no list that would show you that. AI project rescue is the longer version of this call: reproduce, group, then decide whether rollout should resume.
If the pilot is an agent that takes actions, add one more check before you widen it. Who owns it, and when does its access end? I cover that in every AI agent needs a name and an end date. An agent that can update accounts needs that rule before it needs a cleverer prompt.
When the stall is between teams rather than inside the model, a Forward Deployed CTO on an AI transformation sits with the people who have to ship it. Building the production path, with tests and a rollback, is AI development. The release itself should stay reversible: how to keep an architecture decision reversible is the record I want before a pilot touches a live workflow.
What would I do with a stalled pilot?
I build and operate AI systems, including agent workflows, and I still start by writing the task in a paragraph a reviewer could grade. I would not spend the first week on the prompt. I would spend it on a small set of real cases, grouped by where they break, with the current manual time written next to each group.
If I cannot get those cases, I would pause. A model change without that list is a guess. If the cases show one broken input, I would fix that and rerun the same list. If they show a slice that works and a slice that does not, I would narrow the pilot and say so in the decision record.
A team can run this without outside help when the workflow is small, the cases are available, and someone inside already owns the decision. Bring someone in when the pilot has been “almost ready” for months, the bill is climbing, and nobody can point at the cluster.
FAQ
Is the model usually the reason a pilot stalls?
Often it is not. Unrepresentative tests, missing or stale inputs, integrations that fail quietly, and review time that nobody counted are the common stalls, so look there before you swap models. If the same cases still fail after the inputs are fixed, then the model choice is in play.
How many test cases are enough?
Enough to include ordinary work and the exceptions that cost you, and the same set every time you change something. A number pulled from a blog will not match your queue. If you cannot name the exceptions, you are not ready to pick a count. Add cases when a new failure appears in production, and keep the old ones so a fix does not bring them back.
Should we pause the pilot while we diagnose it?
Keep the fallback running, and pause any expansion. People who depend on the workflow should not be the test harness. Freeze the scope, collect the clusters, and change one thing at a time against the same cases. Turning the pilot off completely is right when it is taking actions you cannot undo, or when review is already slower than the old process.
What is a clear stop condition?
Write it before the next build. One version: if a week of real cases needs more human minutes than the current process, stop and narrow or end the pilot. Another: if two changes in a row shrink one cluster and grow another, stop tuning until the eval set is the gate. A stop condition you invent after a bad week is an excuse. One you wrote earlier is a decision.
If your pilot fails on real work, talk to us.