The scenario is familiar to anyone on call: a 3 a.m. alert arrives, and the site reliability engineer bounces between monitoring dashboards, deployment histories, and incident systems trying to figure out whether this is a real problem, whether they're the right person to handle it, or whether someone else needs waking. By the time they piece together what's happening, more customers may already be affected.

Azure SRE Agent changes that dynamic. Instead of an engineer joining an incident bridge to begin investigation, the agent has already analyzed monitoring data, identified the root cause, and prepared a fix awaiting approval and deployment. Sanchit Mehta, one of the head engineers for Azure SRE Agent, explains that the tool "starts analyzing telemetry and correlates things like blast radius, deployment changes, recent changes, any recent rollouts, to try to tell the engineers, 'OK, this is what is causing it.'" Increasingly, it even generates the pull request for the fix.

The value extends beyond emergency response. At InEight, correlating telemetry across tens of thousands of Azure resources once consumed days or weeks. When a support ticket reported slow performance without specifying which product was affected, engineers had to check 14 different products across multiple observability tools. During its first incident with Azure SRE Agent, the tool quickly pinpointed the affected product, traced the performance issue to its source, and recommended scaling Redis—a solution the DevOps team had been considering only as a temporary workaround.

Scale and autonomy in production

More than 3,000 service teams inside Microsoft now rely on Azure SRE Agent to investigate issues, perform root cause analysis, respond to incidents, fix code, enable automatic mitigation, support proactive detection, analyze data, and report at scale. The agent has already handled more than 1.8 million incidents within Microsoft, with many resolved in minutes.

Microsoft's own engineering teams use Azure SRE Agent to develop and improve the service itself, deploying custom agents for code review, deployment, evaluation, and monitoring. This "agent-powered engineering" approach, as Mehta describes it, lets teams capitalize on advances in AI models. The agent proactively spots problems—such as quota issues blocking deployments—and automatically raises support tickets. Recently, it identified the root cause of a change that broke synthetic tests as soon as the change reached the first region, telling engineers: "It said, 'OK, this was an upstream PyPI package that broke your dependency; you need to add tests for it; you should roll back immediately; here's how you should go fix this.'"

Mehta notes that this kind of proactive monitoring is difficult to achieve with deterministic queries. "You need a level of intelligence to see when a large production payload is being deployed and if it has the potential to cause degradations."

For some internal teams, more than half of incidents are autonomously managed by the SRE agent without human intervention, according to Shamir Abdul Aziz, lead program manager for Azure SRE Agent. These are what he calls "safe" operations and mitigations: a service restart, scale-out, rollback, or change order request escalated by customers. "The humans did the governance, set up the guidelines, gave some coaching to the agent, and then it went into auto mode to complete the entire workflow," Abdul Aziz says.

Agents ready to handle what humans built

Site reliability engineers already struggle under repetitive toil, and the rise of coding agents adds to that burden. However, agentic operations have matured enough to help, according to Vyom Nagrani, one of the head product managers for Azure SRE Agent. "As code gets written more and more by agents, it's going to take another agent to operate it," Nagrani tells The New Stack. "But why wait? If the agent can manage code which other agents write, why can't it manage code written by humans?"

As code gets written more and more by agents, it's going to take another agent to operate it.

Vyom Nagrani, head product manager for Azure SRE Agent

Nagrani adds that "the reasoning loop has become mature enough that now agents can automatically start figuring out a lot of these complex problems, especially when it comes to correlating across multiple data sources, which has always been the hardest thing for humans to do."

Powerful models alone are insufficient. Homegrown automation lacks the production-grade governance, verification, evaluation, telemetry, and control that a platform provides. The field has evolved from prompt engineering to context engineering—grounding AI in your infrastructure, code, and institutional knowledge—and now to harness engineering. "That is what allows you to run agents at scale, control them, and govern them," says Abdul Aziz.

"When you combine all these things with being able to verify, audit, evaluate, and get real telemetry and metrics out of the system, where the agent claims it has done something, you can validate that agent's claim," Abdul Aziz explains. Instead of a non-deterministic black box, you can trace and learn from the agent's reasoning to correct mistakes once rather than repeatedly. "That's why companies are willing to adopt it now," Abdul Aziz says. "Because when you try the same thing ten times, you're going to get the same output."

You don't just turn on the agent, give it full access, and ask it to solve everything.

Shamir Abdul Aziz, lead program manager for Azure SRE Agent

After two years of building enterprise-grade systems that can be trusted, audited, and validated, the next step for cloud-native SRE is agentic operations with autonomous capabilities—but adoption requires careful planning, Abdul Aziz cautions.

Building operational context

Azure SRE Agent is built for Azure but not confined to it. The agent provides native access to Azure services including Azure Monitor, Application Insights, Log Analytics, and Azure Resource Graph. Connecting the agent to your subscriptions, telemetry data, and source code supplies the operational context and institutional knowledge it needs to understand your environment.

Beyond Azure, the agent integrates with engineering and operational tools through managed connectors for Azure DevOps and GitHub, plus MCP connectors enabling access to external knowledge sources such as Google Drive, Confluence, Cursor, Claude Code, and other third-party systems.

Store knowledge in Markdown files within a repository, along with the skills and tools agents need to act on your systems—including third-party and on-premises services. This creates artifacts that agents can version, review, test, reuse, and update.

Custom agents let you dictate incident handling: what to check and in what order, what to post, and how to format reports. Build them using existing runbooks or by working through an incident with an agent and saving that skill. Using agents to improve agents accelerates the process of making Azure SRE Agent more useful over time. Essentially, preserving what agents learn during incidents improves their future responses.

Governance, guardrails, and metrics

Governance encompasses identity, role-based access control (RBAC), and tool-access policies. These controls determine which actions are allowed, blocked, or subject to step-by-step approval, and whether an agent operates autonomously or with human review.

Hooks—based on prompts or deterministic commands—fire at different workflow stages and catch edge cases, such as permitting an agent to drop a corrupt index in a SQL database but never drop a table. Metrics reveal whether governance is working. New live reports display time to mitigation, tool reliability, how often agents act autonomously, and cost per outcome. InEight's results are typical: an 80% reduction in both incident investigation time and build failure triage time, a 67% reduction in the effort to investigate bugs, and an 84% reduction in cost.

Achieving these results requires triggers that automatically launch agents instead of waiting for a human to open a chat window. Bind skills and custom agents to specific alert classes so they respond to incidents first. Start agents through pipelines, webhooks, or work items to automate delivery workflows. Schedule regular checks, reviews, and audits, and have agents automatically update their artifacts.

A maturity model for agent adoption

By reducing repetitive tasks and technical toil, Azure SRE Agent frees engineers to focus on more interesting and innovative projects. Just as site reliability engineering adoption follows a familiar maturity model, you don't jump straight to having agents rather than humans handle operations. When you provide agents with context about your infrastructure, you can begin using them for investigations.

If you give agents read access to your source code, your telemetry, your resources, the time to get to the root cause is reduced to minutes rather than hours or days. Every customer starts there.

Shamir Abdul Aziz

Once you're satisfied with the answers you're receiving, you can grant the agent more permissions while still approving individual steps. "The fixing is easy once you understand the problem. It's usually changing your configuration, writing a piece of code, or restarting a service," Abdul Aziz says.

As you expand into other operational tasks, refine the agents' artifacts, metrics, and governance before granting more autonomy. Examples include rolling back a release when a regression is detected, restarting a service, dropping a corrupt index on a SQL table, or scaling out a service.

For more complex issues, agents can deliver the entire fix ready for approval. The Azure SRE Agent that manages the Azure SRE Agent product itself examines exceptions, errors, incidents, Teams conversations, emails, and GitHub issues each night and generates pull requests.

Avoid code review bottlenecks by having agents deploy, test, measure, and include outcomes in the pull requests. Use continuous evaluation to build a self-learning system that accurately follows your existing workflows. "The agent can self-improve because the agent learns constantly," Abdul Aziz says. "You can configure scheduled tasks to identify which evaluation scores were low and automatically improve the custom agent, custom skills, and even your knowledge documents – because knowledge management is also a toil. The agent can automate all of that."

Getting started: Common pitfalls to avoid

Azure SRE Agent now offers a 30-day trial with no always-on charges. To make the most of it, avoid these common mistakes:

  • It's not magic. Turning on the agent doesn't eliminate the need for DevOps work. Don't treat it as a chatbot or connect it only to your observability system. The agent needs context, the tools to act, and intentional triggers that tell it when to act. Otherwise, it may spend effort on low-value work or generate outputs disconnected from your environment.
  • Don't limit yourself to out-of-the-box capabilities. Customize agent skills, tools, connections, and logic to match how your organization works, and build custom agents for specific tasks.
  • Don't use agents for jobs a single line of code can do. Using them to explore deterministic, structured data for anomalies wastes tokens and floods the context window when the agent could write that code itself. "Orchestrate, don't calculate," as Nagrani puts it. If you're drowning in alerts, use automation to filter noise and send only alerts needing intelligent analysis to agents.
  • Don't stick with what you've always done or copy your org chart. The most effective agents have a complete picture of the system, so they need all the context, even if it crosses two teams. That might mean crossing boundaries, coordinating expertise and access, or rethinking how the organization works.

"If agents have the right context, they minimize the toil and truly make operations less costly," says Deepthi Chelupati, lead product manager. That way you can move faster, be proactive, and give engineers more time to innovate and less maintenance work to dread.