How DevOps practice changes when agents join the team
On-call, code review, runbooks, postmortems — every ritual of DevOps is being renegotiated as AI agents take their place in the loop. What survives, what inverts, and what becomes more important than ever.
DevOps was never really about tools. It was a set of rituals — code review, on-call, runbooks, postmortems, change management — that let groups of humans operate systems too large for any one head. Each ritual encodes a hard-won answer to the same question: how do we move fast without lying to ourselves?
Agents do not make that question obsolete. They make it urgent again, because for the first time the “group” operating the system is no longer entirely human. Here is how we see each ritual changing — not in some speculative future, but in the engagements we run today.
Runbooks stop being documents
The runbook was always an admission: this procedure is too rare to automate, so we wrote it down for a stressed human at 3 a.m. Agents dissolve that trade-off. A runbook an agent can read is a runbook an agent can execute — and so runbooks become code with prose in it: preconditions, scoped commands, verification steps, rollback paths. The wiki page that says “check if the queue is backed up” becomes a procedure the agent performs, reports on, and asks permission to remediate.
The discipline this demands is old and familiar: if the procedure is wrong, it is now wrong quickly and repeatedly. Runbooks need review, versioning and tests — exactly like the code they have become.
On-call gets a first responder that never sleeps
The first fifteen minutes of every incident are the same: gather traces, correlate the deploy timeline, check saturation, form a hypothesis. This is precisely the work agents are good at — tireless, broad, fast — and precisely the work that burns humans out.
The shape that works is a loop with a gate in it:
Fig. 1 — The loop we deploy with clients. The agent owns observation, diagnosis and paperwork; the human owns judgement.
The human is no longer the first responder. The human is the incident commander, arriving to a briefing instead of a wall of dashboards. That is not a smaller role. It is a more senior one — for everyone on the rotation.
Code review inverts
Within a few years, most diffs in most repositories will be written by agents. Review stops being the thing you do to your colleague’s code and becomes the primary craft of the human engineer: reading intent, catching architectural drift, refusing cleverness.
This inverts the economics of quality tooling. Policy-as-code, linters, security scanners and conformance tests were once guardrails for tired humans; they are now the operating constraints of non-human colleagues that will happily generate ten thousand compliant-looking lines before lunch. Every rule you can express mechanically is a rule you no longer have to argue about with something that does not get tired of arguing.
Fig. 2 — The rituals survive; the role of the human inside them moves up a level.
New disciplines arrive
Some practices have no pre-agent ancestor, and teams will need to grow them deliberately:
- Identity for agents — short-lived, scoped credentials per agent per task. “The agent did it” must resolve to which agent, under whose authority, with what permissions.
- Evals as regression tests — when behaviour lives in prompts and models, you test behaviour. An eval suite in CI is the only honest answer to “did this change make the agent worse?”
- Budgets for autonomy — error budgets taught us to spend reliability deliberately. Agent budgets do the same for independent action: how many unsupervised changes per week, of what blast radius, reversible how fast.
- Postmortems with non-human actors — the trace of agent reasoning joins the timeline. “Why did the agent believe this?” becomes a standard, blameless question.
Fig. 3 — Four practices with no pre-agent ancestor — and the doctrine underneath them, unchanged.
What does not change
Observe before you act. Make actions reversible. Earn trust through repetition. Write everything down. These were the doctrine before agents, and agents reward them brutally: a team with clean telemetry, scoped access and reversible deploys can hand an agent real work safely. A team without them is handing a chainsaw to something that reads very fast.
DevOps was the practice of humans operating machines. The next decade is humans and machines operating machines, together. The rituals survive — they were never about who was performing them. They were about telling the truth at speed.