
Traditional DevOps automation is deterministic. You encode a rule, the rule executes, identical inputs produce identical outputs. That model is excellent for deployment and useless for the judgement-heavy work surrounding deployment — which is where the majority of engineering hours actually go.
What changed recently is that a category of tasks previously classed as un-automatable, because they required judgement, became partially automatable. Not because models developed judgement, but because a model can produce a good-enough first draft that a human corrects faster than they could author.
That is a meaningfully different proposition from full automation, and the distinction is worth being precise about, because most disappointment in this area comes from conflating the two. You are not removing the human. You are moving them from author to reviewer.
Where this genuinely holds up
Four applications survive production use today.
Characterisation tests for legacy code. A model reads an untested module and proposes a test suite describing what the code currently does. Coverage is imperfect. It is also enormously better than the zero coverage that module has carried for six years, and it unlocks refactoring that was previously unsafe.
Alert triage. An agent correlates a page against recent deployments, related alerts, and historically similar incidents, then opens the incident with context assembled and a ranked hypothesis attached. It does not resolve anything. It removes the first fifteen minutes of frantic context-gathering, and in a severity-one those are the most expensive minutes of the event.
Infrastructure change review. A model reads a plan and flags the security-group widening that a tired reviewer approves at the end of a long day. Not a replacement for review — a second reader that never gets tired and never has forty other things to do.
Incident timeline reconstruction. Assembling a sequence from logs, deploys, and chat history is mechanical, tedious, and something models are unusually good at. This work otherwise gets done badly or not at all.
The common thread: each produces a reviewable artefact, and each has a cheap failure mode. When the model is wrong, a human notices during review and the cost is a few minutes.
Where it must not go
The boundary is not about capability. It is about reversibility.
No production credentials. An agent that can act on production directly has a blast radius bounded only by the correctness of its reasoning, which is not a bound anyone should accept.
No self-approval. An agent that authors a change and approves it has removed the verification step that made the pattern safe. This happens by accident more often than by design — someone grants an agent merge rights for convenience and the review gate silently disappears.
Nothing near a security boundary unsupervised. IAM policy, network rules, secret rotation. These are precisely where a confident wrong answer is most expensive and least visible.
Not pointed at production data stores. The reasons here should not require elaboration.
The pattern that survives contact with reality is simple to state: the agent proposes, the pipeline verifies mechanically, and a human approves anything irreversible. Treat the agent as a fast junior engineer who holds no production credentials — prolific, useful, and never trusted unsupervised.

The verification layer is the actual engineering
The interesting design problem is not the agent. It is what verifies the agent's output.
An agent proposing test cases is only useful if the tests then run and their results are trusted. An agent proposing an infrastructure change is only useful if a plan is generated, policy rules evaluate it, and the diff is presented to a human in reviewable form. An agent drafting a triage hypothesis is only useful if the engineer understands it is a starting point rather than a diagnosis.
Which means the prerequisite for useful agentic automation is a mature deterministic pipeline. If your tests are flaky, an agent generating more tests makes things worse. If you have no policy-as-code layer, an agent proposing infrastructure changes has nothing checking it but a human reading a diff. If your observability is thin, an agent's incident hypothesis is pattern-matching over noise.
This is the part that gets inverted in practice. Teams reach for agents to compensate for a weak delivery system, and agents amplify whatever system they sit on top of.
The hypothesis trap
One specific failure deserves naming because it recurs.
A model triaging an incident will produce a plausible, confident, well-written wrong answer at some rate. It is correlating, not diagnosing. An on-call engineer under pressure at 3am, handed a coherent explanation, will tend to pursue it — and the cost of pursuing a wrong hypothesis during an incident is much higher than the cost of having no hypothesis.
The mitigation is presentational as much as technical. Show the evidence prominently and the hypothesis as clearly secondary. Rank alternatives rather than presenting one. And make sure the team understands the distinction before rollout, not after the first incident where it mattered.
A sensible starting order
-
Get the deterministic pipeline trustworthy first — fast CI, quarantined flaky tests, working rollback.
-
Add characterisation test generation on your least-covered business-critical module. Low risk, immediately measurable.
-
Add agent-assisted alert enrichment, initially in a read-only channel alongside existing paging.
-
Add automated review commentary on infrastructure plans, as a second reader rather than a gate.
-
Only then consider anything that acts, and only behind explicit approval for irreversible operations.
The full picture — the seven delivery layers, CI design, drift detection, progressive delivery, costs, and a 90-day roadmap — is at techcirkle.com/blog/devops-automation. We build agentic workflow automation with these boundaries as the starting constraint rather than an afterthought.
Frequently Asked Questions
Can AI agents replace DevOps engineers?
No, and the framing obscures where value actually is. Agents produce reviewable first drafts for judgement-heavy tasks — test generation, alert triage, plan review, timeline reconstruction — which moves engineers from authoring to reviewing and typically improves throughput on those specific tasks by three to five times. They should not hold production credentials or approve their own changes.
Are model-generated tests trustworthy?
They are characterisation tests, not correctness tests. They describe what the code currently does, which makes them genuinely valuable for pinning behaviour before a refactor. They will also happily encode an existing bug as expected behaviour. Used with that understanding they are a legitimate route to coverage on long-untested modules; treated as proof of correctness they will mislead you.
What is the biggest risk with AI agents in a pipeline?
Granting write access because a proof of concept worked. The propose-verify-approve boundary is what makes the pattern defensible, and it is usually removed for convenience rather than by decision — someone gives an agent merge rights to reduce friction, and the verification step quietly disappears along with the safety property.
Do we need mature DevOps before adding AI agents?
Yes. Agents amplify the system they sit on. Flaky tests plus generated tests is worse, not better. Missing policy-as-code means agent-proposed infrastructure changes have nothing checking them but a tired reviewer. Thin observability makes an agent's incident hypothesis pattern-matching over noise. Fix the deterministic layer first.
How should AI-generated incident hypotheses be presented?
Evidence first, hypothesis clearly secondary, and multiple ranked alternatives rather than a single confident answer. A model correlating rather than diagnosing will sometimes produce a plausible wrong cause, and an engineer under pressure tends to pursue whatever coherent explanation they are handed. Presentation is as much of the mitigation here as model quality.