AI in your company
From AI prototype to production: what is missing between the demo and real use
Florian Rocktäschel · Last reviewed: November 2026 · 12 minute read
In short
A demo proves that a language model can, in principle, do a task. What production needs is almost always the system around the model: a measurable goal, a test set, access rights on the data, pinned model versions, monitoring, a cost model, settled security and legal questions, and a named owner. The path runs through three stages (demo, pilot, production), and each stage has criteria that must be met before the next one. A better model replaces none of these building blocks.
Why do so many AI prototypes stall after the demo?
You can build a prototype in a few days now. Some documents, a language model, a simple interface, and the first twenty questions get impressive answers. Those twenty questions are the problem. They usually come from the people who built the prototype, and they cover the cases that work.
Real users ask different questions: incomplete ones, ambiguous ones, questions about outdated documents and questions the data cannot answer at all. Add users who must not see everything, a bill that grows with usage, and the question of who is accountable when a wrong answer reaches a customer.
Market research points the same way. In 2024 Gartner predicted that at least 30 percent of generative AI projects would be abandoned after the proof of concept by the end of 2025, citing poor data quality, inadequate risk controls, escalating costs or unclear business value. That is a forecast, not a measurement. But the reasons match what German companies report themselves: in Bitkom’s survey from September 2026, companies already using AI name data protection requirements (66 percent), legal uncertainty (56 percent) and costs that are hard to predict (54 percent) as their main obstacles. A quarter complain about poor result quality or a lack of traceability.
None of these is a model problem. They are questions about the system, and the system only gets built after the demo. Back in 2015, engineers at Google described how the actual machine learning code is only a small part of a production system, surrounded by data pipelines, configuration, monitoring and infrastructure. The same holds for language models.
What is the difference between demo, pilot and production?
The most common mistake is to open the demo straight to everyone. A pilot with clear rules belongs in between. Each stage has its own goal and its own hurdle:
| Stage | Who uses it | Goal | Criterion for the next step |
|---|---|---|---|
| Demo | the project team | show that the task can be solved | goal and metric defined, a first test set exists |
| Pilot | a small group of real users, real data, real permissions | find out whether it holds up in daily work | test set passed, failure types known, cost per request measured, owner named |
| Production | all intended users | deliver value over time | continuous measurement, monitoring, planned model changes, budget for upkeep |
The last column is what matters. You define the criterion before the pilot starts, not afterwards. Otherwise every pilot gets declared a success, because nobody said in advance what success means. Define a stop criterion too. A pilot that misses its metric after eight weeks gets reworked or ended. That is a good outcome as well, because it saves money.
Which eight building blocks are missing between demo and production?
| Building block | Key question | How you know it is in place |
|---|---|---|
| Goal | Which decision or process should get better? | a metric with a baseline |
| Measurement | How do we know the answers are right? | a test set of real questions, result as a number |
| Data and permissions | Who may see what, and how current is the data? | permissions checked on every request, automatic updates |
| Versions | What happens when the model changes? | pinned model version, changes only after testing |
| Monitoring | How do we notice that something is going wrong? | logs, alerts, user feedback |
| Costs | What does a request cost, and what does operation cost? | cost per request measured, limits in place |
| Security and law | Which risks do we carry, and who accepted them? | threats reviewed, data protection and AI Act settled |
| Ownership | Who acts when the AI gets it wrong? | named owner, a process for errors, time for upkeep |
The sections below take them one at a time.
Which decision should get better?
When a company tells me “we want to automate this with AI”, my first question back is: which decision or process should improve, and how will we measure it? Without an answer you can neither judge a pilot nor justify the investment.
Good metrics are specific and have a baseline: handling time per customer enquiry, the share of requests resolved without going back to a specialist team, time to a first draft of a quote. “People should be more productive” is not a metric. Measure the baseline before the pilot, or you will have nothing to compare against.
How do you measure whether the answers are right?
The tool is a test set: a few dozen real questions from daily work for which subject experts know the correct answer and the correct source. It grows with every error found in production. Three things separate a test set that tells you something from one that merely reassures you:
- Test retrieval separately. For assistants that answer from company documents (RAG), first measure whether the right passage is among the search results at all. If it is not, no prompt will fix it.
- Include questions without an answer. Some test questions deliberately have no answer in the documents. You count how often the assistant makes something up anyway.
- Pass or fail. Check each criterion with yes or no (“Does the answer state the correct deadline?”) rather than with scores. An average of 3.8 out of 5 tells you nothing you can act on; “92 of 100 answers give the correct deadline” does.
The criteria do not come from a template. Start by reading around a hundred real conversations from the pilot, write one sentence per conversation on what went wrong, and group the notes into failure types. Automated checks, including ones where a language model grades against fixed criteria, are worth building only for the most frequent types. The reading should be done by someone from the business side. Finance knows better than the developers whether an answer about the travel expense policy is right.
Who may see which data?
In a demo the prototype often runs on a technical account that can read everything. In production that is the fastest route to a data protection incident: the assistant happily answers a clerk’s questions about salaries because the document is in the index.
The rule is simple and the implementation is not: the assistant may only use passages the person asking could open themselves. Permissions must be checked on every request, not once at indexing time. Two more questions almost never come up in demos: how quickly does a changed document reach the index, and how quickly does a deleted one disappear? I cover how to build permissions properly in such systems in The chatbot knows too much: permissions in RAG systems.
What happens when the model changes?
Language models change, and providers retire older versions on fixed schedules. If your code uses an alias such as “latest”, you receive new versions without being asked. That is harmless for a chat and dangerous for a process that parses the answers automatically.
In production this means:
- pin a specific model version and record it in every log entry,
- test a new version against your own test set, then switch deliberately,
- put the model behind your own interface, so that changing the model or the provider is a configuration change rather than a rebuild.
The third point is the real protection against lock-in. If you own your prompts, test set and logs, you can switch providers, including to European ones such as Mistral or to open models on your own or European infrastructure. How to do that is the subject of Changing models without starting over, and what running models yourself involves is covered in Running sovereign AI yourself.
How do you notice in production that something is going wrong?
Conventional software reports an error. A language model produces a fluent, plausible answer even when it is wrong. Production therefore needs more than an uptime check:
- Log every conversation: question, retrieved passages, model version, answer, latency, tokens. There is an open, vendor-neutral format for this, the OpenTelemetry conventions for generative AI, so the data ends up in the tools your operations team already uses.
- Let users flag a wrong answer with one click, and have someone read those flags every week.
- Alert on anomalies: suddenly longer answers, more “I don’t know”, rising cost per request, more errors from connected systems.
- Provide a fallback. If the model provider is down, users see a clear message and another way to get what they need, not an endless spinner.
Mind data protection in the logs. They often contain personal data and need a retention period and controlled access.
What does production really cost?
Pilot costs say little about production costs. Here is a worked example with deliberately assumed round prices (€0.50 per million input tokens, €2.00 per million output tokens; actual prices are on the providers’ pricing pages and change):
| Item | Pilot | Production |
|---|---|---|
| users × questions per day × working days | 10 × 5 × 20 | 300 × 8 × 20 |
| requests per month | 1,000 | 48,000 |
| tokens per request | 6,500 in, 400 out | 6,500 in, 400 out |
| cost per request | €0.00405 | €0.00405 |
| model cost per month | about €4 | about €194 |
| with four model calls per question | about €16 | about €778 |
The 6,500 input tokens are made up of fixed instructions (1,500), six retrieved passages of 700 each and the question with its history (800). Four calls per question are realistic as soon as the application rewrites the question, searches, answers and checks its answer.
The example shows two things. First, usage grows by a factor of 48 here, and the architecture multiplies that by another 4. Second, tokens are rarely the largest item. If a subject expert reads a hundred conversations a week at three minutes each, that is about 20 hours a month. At an assumed internal cost of €60 an hour, quality assurance costs €1,200, more than the model. Operations, index maintenance and further development come on top. A business case therefore has to count people’s time, not just token prices. I go through every item in What an AI application costs to run.
Set hard limits all the same: maximum answer length, maximum calls per question, a daily budget with an alert. Otherwise a bug in a loop can cost more overnight than the entire pilot month.
Which security and legal questions must be settled?
The most important security question arises as soon as the application reads external content: incoming emails, uploaded PDFs, web pages. Such content can contain hidden instructions, and a language model cannot reliably tell them apart from genuine ones (prompt injection). OWASP, an independent foundation for application security, ranks this as the top risk for LLM applications and states openly that it is unclear whether fool-proof prevention exists. It becomes dangerous when three capabilities come together: access to internal data, exposure to external content, and a way to send data out, such as sending email. Remove one of them and you remove the path for data to leave. This matters most for applications that are allowed to act, which is why they get their own article: AI agents with guardrails.
On the legal side, at least these points belong on the list, with your data protection adviser if in doubt:
- Data protection: a data processing agreement with the model provider (Art. 28 GDPR), where the data is stored, retention periods for logs, and a data protection impact assessment for high-risk processing (Art. 35 GDPR).
- EU AI Act, transparency: since 2 August 2026, providers of AI systems that interact directly with people must ensure those people know they are dealing with an AI, unless it is obvious (Art. 50). If you build an assistant and offer it to customers, you are usually the provider.
- EU AI Act, high risk: if AI is used for recruitment, for example, considerably stricter obligations apply from 2 December 2027 after the postponement in the Digital Omnibus. If you are building something like that now, design for those obligations from the start.
Who is accountable when the AI gets it wrong?
A prototype belongs to the team that built it. An application in production needs a person who answers for the result: they decide on model changes, read the error reports, prioritise improvements and have the authority to switch the application off. That person is best placed in the business unit, backed by the technical team.
A process for errors belongs with it. When an employee reports a wrong answer, who looks at it, by when, and how does the case get into the test set? AI is not a project with an end date. It stays with you and needs upkeep, and that belongs in the budget from day one.
Which failure patterns are typical, and where is the cause?
| Symptom | Common cause | Building block |
|---|---|---|
| “The AI is just a bit inaccurate sometimes” | search misses the right passage and nobody measures it | Measurement |
| Invented answers to questions that have no answer | no way out allowed, no test questions for it | Measurement |
| Staff see content they should not see | technical account with full rights | Data and permissions |
| Suddenly a different output format, the next step breaks | model alias instead of a pinned version | Versions |
| Bill twice as high as planned | longer answers, more calls per question, no limit | Costs |
| After three months hardly anyone uses it | no metric, no owner, errors never fixed | Goal, ownership |
From practice
A prototype has to prove two things: that the technology works and that the process works. The second one is easy to forget. Can the workflow be mapped at all, do people go along with it, is the result right? With AI this is decided early. You can always improve things later, but sometimes it becomes clear early on that an approach does not work or needs a different angle. Seeing that now is cheaper than seeing it after the rollout.
At Kivvo, the AI platform whose product development I lead for a client, there is no single prototype for that reason. The platform is the foundation, individual modules build on it, and each module has its own question a prototype must answer: low latency for voice, the quality of the documents, how fast documents are processed, how the platform scales.
And test with real data as early as you can. Otherwise it is easy to fool yourself. A common mistake is testing with data an AI generated. That data is usually already phrased in a way an AI handles well. Real documents and real questions are messier, and that is exactly where a prototype fails once it is in production.
Checklist: is your prototype ready for production?
Answer each question with yes or no. Every no is a task before the next step.
- Is there a metric with a baseline, and success and stop criteria defined in advance?
- Is there a test set of real questions, including some without an answer in the data?
- Is retrieval measured separately from the answers?
- Does each person see only content they could open themselves, checked on every request?
- Is it defined how quickly changed and deleted documents reach the index?
- Is a specific model version pinned, and is there a process for changing it?
- Can you change the model without rebuilding the application?
- Is every conversation logged, with a retention period and controlled access?
- Can users report wrong answers, and does someone read those reports?
- Is the cost per request measured, and are limits in place?
- Have you checked whether the application reads external content, sees internal data and can communicate externally?
- Are data processing, storage location and the transparency obligation settled?
- Is there a named owner with time and budget for upkeep?
What does management have to decide?
Four decisions cannot be delegated to the technical team: which goal applies and when the pilot will be stopped, which residual risk the company accepts, who gets ownership, and what ongoing budget the application receives after launch. Once those four are decided, the rest is craft. While they are open, even the best prototype remains a demo.
How I support companies along this path is described on the page AI in your company. Disclosure: I earn nothing from any of the providers or tools mentioned here. I lead product development for Kivvo, an AI platform operated in Germany, on behalf of a client.
Frequently asked questions
That depends less on the model than on the data and the permissions. An assistant working on a few well-maintained documents with simple access rules reaches production faster than one connected to several systems with their own permission models. Give the pilot a fixed period and a success criterion agreed in advance, and you will know at the end whether and how to continue.
Rarely. If search misses the right passage, permissions are missing or nobody measures anything, a better model changes nothing. Switching models is worth it only once the test set shows that the model itself is the bottleneck.
A few dozen real questions that subject experts can answer are enough to start, including some that have no answer in the data. More important than size is that the test set grows with every error from production and runs again after every change.
Not for the first use case. Once several applications exist, a shared foundation for permissions, logging, model access and cost control pays off. Otherwise every team rebuilds these pieces, each a little differently.
The transparency obligation in Art. 50 covers AI systems that interact directly with people and has applied since 2 August 2026. Stricter obligations apply to high-risk areas such as recruitment, from 2 December 2027 after the postponement. Whether and how your use case is affected should be checked legally if in doubt.
Sources
Last reviewed November 2026. Legal information without guarantee, not legal advice. Prices in the worked example are assumptions.
- Bitkom, AI use and obstacles in German companies, September 2026: bitkom.org
- Gartner, forecast on abandoned GenAI projects, July 2024: gartner.com
- Sculley et al., Hidden Technical Debt in Machine Learning Systems, NeurIPS 2015: papers.nips.cc
- Hamel Husain, Shreya Shankar, AI Evals FAQ: hamel.dev
- OWASP, Top 10 for LLM Applications 2025, LLM01 Prompt Injection: genai.owasp.org
- Simon Willison, The lethal trifecta for AI agents, June 2025: simonwillison.net
- OpenTelemetry, semantic conventions for generative AI: github.com/open-telemetry
- Mistral, Model lifecycle policy: docs.mistral.ai
- EU AI Act, Art. 50: artificialintelligenceact.eu; Digital Omnibus, Regulation (EU) 2026/1744: regulation-ai.eu
About the author
I am Florian Rocktäschel, an engineer from RWTH Aachen. I have worked with machine learning since 2013 and as a fractional CTO for mid-sized companies since 2018. Here I write down what I am asked again and again in this work.
Where does your technology stand?
The Technology Traffic Light asks 15 questions about AI, strategy, security, data, costs and team. Ten minutes, instant result, free of charge.

