DevOps is Dead, Long Live AgentOps
DevOps was supposed to bridge the gap between development and operations. And for a while, it worked. Infrastructure as code, CI/CD pipelines, automated deployments; we got really good at encoding our workflows into deterministic systems.
But determinism has a ceiling. Pipelines execute, they don’t reason. Every novel scenario requires either a human in the loop or more YAML. The job quietly became YAML maintenance, not operations.
The rise of AI agents broke through that ceiling. And the paradigm needs to follow.
The Wall
This isn’t a failure of DevOps. It’s the natural limit of deterministic systems in an increasingly agent-driven world.
A CI/CD pipeline can run tests, deploy artifacts, and enforce linting rules. But it cannot look at a pull request and make a judgment call about architectural consistency. It cannot infer intent from context. It cannot adapt its behavior based on the specific team, project, or technology involved.
Every novel case needs a human to write more pipeline code. And general the pipelines themselves never get smarter, they just get longer.
Meanwhile, agents arrived that can do these things. Code review agents that assess code quality, architecture, and security. Coding agents that generate, refactor, and document. And the gap between what our pipelines can do and what our agents can do became impossible to ignore.
The Frustration That Changed Everything
I started seeing a pattern: poor quality pull requests flooding in. Not because the developers were careless, but because everyone was using different AI agent workflows. Different tools… Codex, Cursor, OpenCode, Claude. Different prompting styles. Different skills, or none at all. No planning discipline. No consistency.
The result was a mess. Agents generating code that didn’t follow project conventions. Reviews flagging style nits while missing real architectural problems. One developer’s Claude would write a perfect implementation, while another’s Cursor would produce something functionally correct but structurally inconsistent with the rest of the codebase. Every PR was a gamble.
I realized I couldn’t control which agents people chose to use. But I could control what those agents read.
It started small, an AGENTS.md file at the root of the repo documenting the project structure, conventions, and expectations. Then .agents/skills directories with composable, shareable behavior units, reusable instructions for planning, testing, and reviewing that any agent could consume regardless of the tool that launched it. Then symlinks claude.md pointing to agents.md, so Claude Code, OpenCode, Cursor, and Codex all routed to the same source of truth without each tool needing its own bespoke configuration. llms.txt and llms-full.txt followed, acting as the new robots.txt for the agent era; a documented contract for what agents should know about the project.
To make matters worse, human reviews were dropping off. Not out of laziness, but out of scale. Agents were pushing more code faster than ever, and the same developers who used to write thorough reviews no longer had the time, energy, or context to catch everything. The volume alone made it impossible to stay caught up, and even when they did review, the effort and passion for deep, line-by-line critique had faded. Code review became a checkbox, not a craft.
That’s what drove me to double down on CodeRabbit and Greptile. I started writing stronger, more specific configs, review criteria that mirrored what a diligent human reviewer would catch. Architectural consistency. Security patterns. Error handling discipline. Things the pipelines never could have checked and humans no longer had the bandwidth for. On the CI side, those same configs enforced the rules encoded in the agent files. Now both sides of the lifecycle, development and review were aligned through the same agent-readable documentation. The agents writing the code and the agents reviewing it were reading from the same playbook.
And that’s when I realized: this isn’t DevOps.
What AgentOps Actually Means
DevOps is about orchestrating infrastructure and pipelines. It answers the question: “How do we get code from a developer’s machine to production?”
AgentOps is about governing agent behavior, judgment, and coordination. It answers a different question: “How do we ensure every agent interacting with our codebase operates with shared context, consistent rules, and aligned objectives?”
In practice, this looks like:
AGENTS.mdat every level — root for global context, subdirectories for domain-specific guidance. Agents read the closest one first..agents/skillsas composable behavior — reusable units that encode planning workflows, testing patterns, and review criteria. Any agent can load them regardless of the tool that spawned it.- Symlinks as a routing layer —
claude.md → agents.mdensures every tool resolves to the same truth without duplicating configs. llms.txtandllms-full.txt— curated documentation indexes so agents don’t waste context on irrelevant files.- CI-side enforcement — CodeRabbit, Greptile, and similar tools apply the same rules on review that agents followed during development.
The CI/CD pipeline becomes a coordinator, not the brain. The brain lives in the agent layer; the rules, skills, and documentation that shape how every agent behaves. AGENTS.md files are the new infrastructure as code. .agents/skills are the new deployment units. The symlink from claude.md to agents.md is the new service mesh routing every tool to the same source of truth.
The “Ops” in AgentOps isn’t about operating agents. It’s about operating with agents. It’s the discipline of managing agent behavior across the entire software lifecycle.
The Future
This is already happening. Every repo I maintain now has agent context at root and subdirectory level. Skills are composable and shared across teams. Code review agents and coding agents read from the same documentation. The result is consistent, high-quality PRs without micromanaging which tool or prompt someone uses.
The “Ops” role is shifting from pipeline engineer to agent behavior engineer. The skills that matter aren’t YAML syntax or Terraform modules, they’re prompt design, context engineering, rule governance, and agent coordination.
DevOps isn’t dead because it failed. It’s dead because it succeeded at what it was built for, and the landscape evolved past it. AgentOps is the natural evolution not a replacement tool, but a replacement paradigm.