What is it?
As usual. let's take a moment to look at the "bare essential constituant parts" of what Agentic DevOps is, and let's see how we align them to the SecDevOps mindset.
Microsoft’s "Agentic DevOps", Key Concepts:
- "Agentic DevOps" positions AI agents (like GitHub Copilot) as active collaborators in the development and operations lifecycle, not just assistants, but participants.
- These "agents" are embedded in developer workflows
- suggesting code
- generating unit tests
- assisting with CI/CD YAML configs
- even watching platforms, helping triage incidents.
- Azure/Devops and GitHub integration aims to create a seamless loop where AI connects dev, test, deployment, and observability pipelines.
- The model encourages intent-driven automation, you describe what you want to achieve, and the agent helps scaffold or implement the solution.
Agentic DevOps: Is AI Ready to Be a Team Player?
We’ve all seen it by now: the demos where GitHub Copilot seems to finish your code before you even finish typing your thought. And now, with Microsoft’s Agentic DevOps vision, it’s not just about writing code faster, it’s about changing how we develop, test, deploy, and run software altogether.
I use it personally, all the time. It's quite stunning how it can "trim the fat" off writing code that would otherwise be obvious if not tedious. That is to say, some of the routines we write are simply "frequently used" and "well known" algorithms. Just different parameters or variables.
You can ask LLMs to write whole applications too. And it sometimes does a reasonable job. That "sometimes" though...who knows when it will, or won't do things properly? The more code it is required to produce the more likely it's going to contain a major bug.
To be fair, the same can be said about the code we write ourselves. But what is predictable is our fallibility. We include this in our processes as a matter of fact. We might be tempted to trim this out of our processes if we involve an AI to do it.
So, the more reliable it is, the more we will rely on it. Now, is that an asset or a new risk?
Is it the revolution we need, or just another layer of complexity dressed up as automation?
As someone who’s worked at the intersection of security, operations, and DevOps culture for a while now, I’ve been watching this trend with both excitement and caution.
Let’s unpack it.
The Good: Why This Matters
-
Acceleration of Repetitive Tasks
Writing boilerplate YAML? Structuring that Bicep deployment script? Copilot is already shaving hours off those tasks. That’s not trivial, it frees teams to focus on actual design, risk, and user value.
-
Incident Intelligence
The integration of observability, logs, and incident data into Copilot's scope could mean AI agents can help identify root causes faster, maybe even qualify the issues for triggering automated remediations.
-
Bridging Silos
A shared platform where code, deployment, and monitoring are all AI-augmented could reduce friction between devs and ops, if adopted correctly. It could bring a consistent need for peer reviewing as a process, instead of having the process viewed as systematic criticism.
-
Platform Engineering Synergy
This vision aligns well with Internal Developer Platforms (IDPs), the AIs could help developers self-serve builds, infra, and pipelines more easily, if guardrails are properly enforced.
The Caveats (a few): From a SecDevOps Perspective
-
Automation Without Understanding Is Dangerous
If you don’t understand the YAML Copilot just wrote, you can’t secure it. Blind trust in agentic systems creates blind spots, especially in config, secrets handling, and permissions. Don't even get me started on Vibe coding. Understanding code is critical to maintain a Zero Trust ecosystem.
-
Security by Suggestion != Secure by Design
AI agents might suggest best practices, but it’s still up to humans to validate, enforce policies, and think critically. Shift-left becomes shallow if we just shift it onto Copilot’s shoulders. It may not cover all you bases either. So people must do better than fill in the gaps that AI might create, but instead, make the full list of requirements upfront.
-
Agent Drift and Policy Compliance
Who’s auditing what the agent changed? Is it versioned? Logged? Reviewed by humans? In a compliance-driven world, traceability and "explainability" are non-negotiable. Zero trust must and will still apply, and Copilot will be the first to be verified at every turn.
-
Burnout via Pseudo-Acceleration
There’s a real risk of perceived acceleration masking actual cognitive load. Teams might feel pressured to "keep up with the agent" without having time to understand, refactor, or breathe. The sheer volume of what the AI tools can output could be overwhelming, so lets keep using the sense of "best value" that DevOps always proposes.
-
People are still the Platform
Sustainability isn't just ecological, it's about building teams that last. If we offload too much thinking to tools, we risk alienating people from their craft. And vice-versa: if the tools are available and we simply forbid it's use, it can also cause alienation towards our progressive thinkers or enthusiasts.
Governance with pattern recognition
It may be tempting to have the AI look out for patterns that break our governance rules. But relying on it to do so, is at our own peril. As much as false positives could desensitize out teams as to real potential incidents, "needles in a haystack" outcomes, where AI does finally detect something pertinent, might require more effort to parse that it is worth. This approach must be carefully evaluated as far as the final value of "AI in governance".
Agents are foreign entities
So far, from the perspective of Microsoft's proposition, we can infer that we must entrust our code and agents and their specific instructions to their care. That's their business model so I don't blame them for it. Not only does the volume of use cases, reinforce their product and service offering, but it may also expose intellectual property and even security flaws. So you might want to consider "self hosting" part of or all of the components of your ALM, when integrating Agentic SecDevOps. After all, hosting AI models like phi4-reasoning is completely feasible at enterprise level. Theoretically, Microsoft doesn't have to figure in the loop, at all. Let's keep that in mind.
Where It Does Align with Our Values
The cultural DevOps model we’ve talked about, shared ownership, cross-functional empathy, sustainability, can work beautifully with Agentic DevOps if we:
-
Use AI to augment, not replace, team practices.
- Insist on "explainability", traceability, and validation at every step.
- Teach teams how to challenge Copilot’s output, not just accept it.
- Preserve the social contract: automation serves the people, not the other way around.
So… Is This the Future?
Maybe. I for one, am looking forward to it. But only if we embed human-first principles into how we adopt it. AI and LLMs are great tools to generate ideas and test some of our own but critical thinking is still the realm of real people.
Yes, AI will shape how we build and run software. But whether it empowers or overshadows people, that’s still up to us. One thing is for certain, if is not working for us, we will be working for it. I don't mean this in the totally dystopian fashion of a bad sci-fi movie, but in the sense it may be more trouble adapting what we do, to it, if we don't design its caveats in our methods, from the get-go.
In my view, Agentic SecDevOps is using these tools like we have some very enthusiastic juniors that have a (quite a few) variety of opinions to share. But those opinions need critical scrutiny. And by the sheer volume of the propositions they can afford, they cannot be ignored: we must consider them.
