In short
- Most AI projects are planned as a build that ends at launch. The trouble starts after launch, when nobody is set up to watch the system.
- Cloud teams solved the same problem for software years ago. They stopped treating a service as something you finish and started treating it as something you operate.
- The same four habits carry over to AI: instrument, monitor, diagnose, improve. They are cheapest to adopt in the first version and expensive to add later.
The launch is not the finish
An AI project usually has a clear end in the plan: the system goes live, the project team moves on, and the budget closes. The plan treats launch as the moment the work is done.
For an AI system, launch is the moment the real conditions begin. People ask things the test set never covered. The documents and data it relies on keep changing. The model behind it gets updated by its provider. Usage grows and so does cost. None of this raises an error. The system keeps answering, and the answers slowly get worse or more expensive, and nobody is positioned to notice.
This is why capable prototypes stall before production, and why systems that do ship are often quietly abandoned. The build was planned. Operating it was not.
What cloud teams learned
Large cloud services went through this earlier. A service that many customers depend on is never finished. It changes every day, and it has to stay healthy while it changes.
The teams that run those services settled on a discipline. Everything reports what it is doing. Health is watched continuously, not checked when someone complains. When something goes wrong, the goal is to find the cause, not only to clear the symptom. Fixes ship as routine releases. At cloud scale this discipline is supported by machine learning and goes by the name AIOps.
The important shift was not a tool. It was deciding that operating the service is part of building it, and staffing and designing for that from the start.
Why AI needs this more than ordinary software
Ordinary software tends to fail loudly. A page does not load, a job crashes, an error is logged. AI systems fail quietly, for four reasons.
- The output is a judgment, not a calculation. A wrong answer looks exactly like a right one. There is no error to catch.
- The inputs move. The questions people ask and the data the system draws on both shift over time, away from what it was built and tested on.
- The parts underneath change. Models are updated or retired by their providers, and behavior changes with them.
- Cost follows usage. A system that is cheap in a pilot can become expensive in production without any change to the code.
A system with these properties cannot be declared done. It can only be watched and kept in good condition.
The four habits, applied to AI
Instrument
Every request records what was asked, what the system drew on, what it answered, how long it took, and what it cost. Where people can react to an answer, their reaction is recorded too. This is built into the first version. Added later, it means reworking the system, and the history you most want is already gone.
Monitor
Quality is measured against a baseline, not judged by impression. Drift, failures, and cost are tracked continuously. Alerts go to a named person, because an alert that belongs to everyone belongs to no one.
Diagnose
When an answer is wrong, the question is why. It could be the data, the way information was retrieved, the instructions given to the model, the model itself, or the connection to another system. With instrumentation in place you can trace a bad answer back through each step. Without it you are guessing.
Improve
Changes ship as routine releases. Each one is evaluated against the baseline before it goes out and watched after. Then the loop runs again. Improvement stops being a special project and becomes the normal state of the system.
What this looks like at each stage
The loop does not wait for production. It starts small and grows with the system.
- Prototype. Establish the baseline. Every result is measured, so later changes can be judged against it.
- Pilot. Log usage and quality from the first real user.
- Production. Monitoring and alerts go live with the system, with a named owner.
- Enterprise scale. One view of every deployment: quality, cost, and incidents.
These are the same four stages described in our methodology.
Five questions to ask of any AI system you run
- If its answers got worse next month, how would you find out?
- Can you see what it was asked, what it answered, and what it drew on?
- Is there a baseline that tells you whether a change made it better or worse?
- Who is named as responsible when something looks wrong?
- Do you know what it costs to run, and what drives that cost?
If most of these have no answer, the system is being built but not operated. That is the common case, and it is fixable.
Where to start
Start with the system you already have, or the one you are about to build. Record what it does. Set a baseline. Name an owner. Those three steps cost little and change what you can see. Everything else in this paper builds on them.
If you would like to talk through where your own system stands, book 30 minutes.