DevOps has changed — Agentic DevOps is the future
I’ve spent a good chunk of my career watching DevOps evolve — from a cultural movement about breaking down silos, to a toolchain, to an entire engineering discipline. And I’m now convinced we’re standing at the start of the biggest shift yet. DevOps as we’ve practiced it for the last fifteen years is changing under our feet, and the thing replacing it is agentic.
Let me explain what I mean, why I think it’s inevitable, and what I’ve been building to prove it out.
A quick history of how we got here
It helps to remember how much has already changed.
- Manual ops (pre-2010). Ticket-driven. A developer wrote code, threw it over the wall, and an operations team hand-configured servers to run it. Slow, fragile, and adversarial.
- DevOps (2010s). We tore down the wall. Infrastructure as code, CI/CD, and “you build it, you run it” turned deployment from an event into a habit. The pipeline became the product.
- Platform engineering (early 2020s). As the toolchain exploded, we abstracted it. Internal developer platforms and golden paths gave teams paved roads so they didn’t have to assemble twelve tools by hand.
Each step automated more of the mechanics. But notice what stayed stubbornly manual the whole time: the judgment. A human still had to decide what the pipeline should do, why a build broke, which remediation to apply, and how to translate a vague requirement into working infrastructure. We automated the hands. We never automated the head.
That’s the part that’s about to change.
What “agentic DevOps” actually means
Agentic DevOps is the practice of handing the decisions — not just the execution — to autonomous AI agents that can plan, act, observe the result, and adapt.
The distinction matters. A CI/CD pipeline is deterministic automation: it does exactly what you scripted, every time, and falls over the moment reality deviates from the script. An agent is different. Give it a goal (“migrate this service’s pipeline to GitHub Actions,” or “this deploy is failing, fix it”) and it reasons about the current state, chooses the steps, uses tools to carry them out, and checks its own work.
Traditional automation executes the plan you gave it. An agent makes the plan, then executes it — and re-plans when the world pushes back.
Put a fleet of those agents together, each specialized, coordinating through shared state and events, and you no longer have a pipeline. You have a team of tireless engineers operating your delivery lifecycle.
What I built: the DevOps Agentic Framework
Rather than just theorize, I built it. My DevOps Agentic Framework is an autonomous, AI-powered platform that uses a set of collaborating agents to generate code, run pipelines, enforce policy, and manage cloud infrastructure — with the explicit goal of reducing developer toil and accelerating secure, consistent delivery.
The core idea is specialization plus coordination. Instead of one giant “do-everything” model, the framework runs six focused services, each an expert in its lane:
| Agent | Job |
|---|---|
| Planner | Orchestrates multi-step workflows and delegates to the others |
| CodeGen | Generates microservices, REST APIs, and infrastructure code |
| Remediation | Detects and auto-fixes failures |
| Chatbot | A natural-language interface — DevOps by conversation |
| Migration | Converts legacy Jenkins pipelines to GitHub Actions |
| MCP GitHub Server | Standardized GitHub operations via the Model Context Protocol |
Under the hood it’s deliberately production-shaped, not a notebook demo:
- Reasoning: the Anthropic Claude API drives each agent’s planning and generation.
- Coordination: the agents communicate through an event-driven backbone — EventBridge for messaging, DynamoDB for shared state, S3 for artifacts — so work happens asynchronously and no agent blocks another.
- Tool use via MCP: the Model Context Protocol gives agents a clean, standardized way to actually do things (like GitHub operations) instead of just talking about them. This is the piece that turns a chatbot into a worker.
- Infrastructure: everything runs on AWS as ECS Fargate services behind an ALB and API Gateway, provisioned by Terraform (90+ resources) so the whole platform is itself reproducible infrastructure-as-code.
The result is a system where you can say, in plain English, “scaffold me a new service with a CI pipeline,” and the Planner breaks that down, CodeGen writes it, the MCP server commits it, and if something fails downstream, Remediation takes a swing at fixing it — no ticket, no wall, no waiting.
Why this is the future, not a gimmick
Three forces make me think this direction is inevitable:
- The toolchain finally outgrew human bandwidth. Modern delivery spans dozens of tools and thousands of config knobs. We’ve hit the point where managing the automation is itself the toil. Agents are how you automate the automation.
- LLMs crossed the capability threshold for real tool use. With protocols like MCP, models don’t just suggest commands — they execute them against real systems, observe the outcome, and correct course. That feedback loop is the whole ballgame.
- The economics are lopsided. An agent that resolves a failed deploy at 3am, or migrates a hundred legacy pipelines over a weekend, changes the unit cost of operations in a way no dashboard ever did.
The part we can’t hand-wave: trust and control
I’d be doing the discipline a disservice if I pretended this is all upside. Handing decisions to autonomous agents raises exactly the questions a good DevOps engineer should ask: How do I bound what an agent is allowed to touch? Where’s the human approval gate for irreversible actions? How do I audit what an agent did and why?
My answer, and a design principle throughout the framework, is that agentic DevOps doesn’t remove those controls — it makes them first-class. Least privilege per agent, human-in-the-loop for anything destructive, and a durable, event-sourced record of every action. The agent proposes and executes the mechanics; policy and, where it matters, a human still govern the intent. As someone who came up thinking about security, that boundary is non-negotiable for me.
Where this goes next
DevOps didn’t disappear when CI/CD arrived; it absorbed it and moved up a level. The same thing is happening now. Agentic DevOps doesn’t retire the DevOps engineer — it promotes them. Your job stops being “wire up the pipeline” and becomes “direct, constrain, and verify a team of agents that wire up the pipelines for you.”
That’s a more interesting job, not a smaller one.
If you want to see the ideas in this post as running code, the framework is open on my GitHub: github.com/darrylbowler72/agenticframework. I’ll be writing more here about the specific pieces — how the Planner decomposes work, why MCP changed my architecture, and what I learned making autonomous agents safe enough to trust with production.
More soon.