Most organisations with a stalled AI prototype have a working model. The model does what it's supposed to do. The demo went well. The exec team is excited.
Then it doesn't ship.
Or it ships, and something breaks in production that never showed up in testing. Or it ships and works technically, but nobody uses it because the workflow integration was an afterthought. Or it doesn't ship because legal review surfaces requirements that nobody thought about when the prototype was being built.
This pattern is consistent across the industry. The common thread is that the prototype proved the model worked, but nobody was seriously thinking about delivery.
Why prototypes are misleading
A prototype answers one question: can the model do this thing? It doesn't answer the questions that actually determine whether a system ships.
Who owns model drift? How do you know when it's drifting? What's the feedback loop between production behaviour and retraining? How does a human override the model, and is that override auditable? What happens when the input distribution shifts in a way nobody anticipated? What does the rollback process look like?
These aren't hard questions. But they're invisible when you're building a prototype, because prototypes are designed to make things look easy.
What this looks like in practice
Consider a mid-size lending business with a document intelligence model built over eight months. It classifies documents, extracts key fields, and flags anomalies — and performs well on their internal test set. Their legal team is brought in late. The review surfaces requirements the system can't satisfy: full audit trail of every decision, a defined escalation path for low-confidence outputs, a testing framework demonstrating consistent performance across protected-characteristic inputs. Standard stuff for a financial services context. None of it was in scope for the prototype.
The engagement pattern that unblocks this: the model itself barely needs to change. What needs to change is everything around it — the governance layer, the human review workflow, the testing infrastructure, and the documentation that legal needs to sign off.
Get that right and a system that was blocked for months ships cleanly — with throughput improvements over the manual process it replaces, and a legal team who were previously obstacles becoming advocates.
The actual delivery challenge
The model is the easy part. The hard part is everything that makes it safe to run in production.
The hard part is:
Governance — who is accountable for what the model does, and how do you demonstrate that accountability to a regulator?
Integration — how does the AI system connect to the existing workflow, and what happens when it's wrong?
Testing — how do you build confidence in a system whose outputs are non-deterministic? (This is harder than it sounds and deserves its own article.)
Observability — how do you know the system is behaving in production the way it behaved in testing?
None of this is cutting-edge AI research. It's delivery discipline applied to a new class of system. The organisations that are shipping AI successfully are the ones that figured this out. The ones that aren't are still building prototypes.
If you're working through the prototype-to-production gap, we're happy to talk through where you are.