Operating AI to a Standard

Classical software is stationary: shipped correct, it stays correct until someone changes the code. Agentic AI is not. Four forces move it after launch. Model drift — the provider updates the model beneath a stable API, and behavior shifts in either direction without a line of your code changing. Data drift — the world the agent retrieves from changes, and yesterday's grounding is today's error. Dependency drift — tools and APIs the agent calls evolve and break. Demand drift — new input distributions arrive that the launch evaluation never saw. A system certified at launch is not certified next month; certification is a rate, not an event.

Operating a non-stationary system is a control problem, and the discipline is a closed loop. Observe: full tracing of every step, tool call, and decision, with cost and latency attached. Evaluate: continuous scoring against ground truth and acceptance criteria, not a one-time test. Intervene: rollback, re-prompt, re-route to a different model, tighten a guardrail, or escalate to a human — then feed the result back into observation. Without the loop, you have telemetry no one acts on; with it, the system corrects faster than it drifts.

Observability & tracing — every action reconstructable. Continuous evaluation & regression — a standing eval set that gates every change and runs on live samples. Incident response — on-call, runbooks, and rollback for agents, because a misbehaving agent is a production incident. Change management — treating every model and dependency update as a controlled change. Cost & governance — per-workload spend and policy held to budget and rule [3]. These are the same disciplines that made cloud operations reliable, applied to a system whose behavior is probabilistic.

“Running well” must be a number, or it is an opinion. We operate agents to an explicit service-level objective set:

The most under-managed risk in production AI is the silent provider update. Treat every model change as a controlled deployment: shadow the new version against live traffic, gate on the regression suite, stage the rollout behind a canary, and keep a rollback path pinned. The same protocol applies to dependency changes. This is what separates the two curves below: the unmanaged system takes every update blind; the operated one absorbs them as changes.

This discipline is a 24/7 operation with on-call, tooling, and a standing evaluation practice — a function few teams are staffed to run for every system they deploy. The durable asset is not the model, which is rented; it is the operating discipline around it, and it is best owned by a party accountable to the customer's outcome rather than a platform's roadmap. Whether built in-house or run as a managed service, the test is the same: is there an SLO, an owner, and a change protocol?

The cost of not operating is invisible until it isn't: a silently regressed agent makes worse decisions for weeks before anyone notices, and the loss is the compounded bad output plus the trust that does not come back. Continuity is the product. For the executive, require of any production agent the same three things you would of any critical system — a defined service level, a named owner, and a change-management protocol — reported on a standing cadence. An agent without these is not in production; it is in a long, unmonitored beta.

Continuous evaluation is only as good as its coverage; rare and adversarial inputs evade standing suites. Observability at production volume carries real cost and must itself be budgeted. And automated intervention has limits — some regressions require human judgment to diagnose — so the loop is human-supervised, not autonomous, by design.

Agentic AI is bought as a capability and kept as an operation. The systems that hold are the ones run to a standard — observed, evaluated, and corrected on a loop, against service levels someone owns. AI strategy ends where the bill begins; managed operations is where the value is kept.