Introduction
The way we build, operate, and support software has changed dramatically over the last two decades.
In the early days of software development, developers were often responsible for much more than writing code. They understood the application, deployed it, monitored it, debugged it, and supported it when something went wrong.
Today, the situation is very different.
Modern applications are highly distributed, cloud-native, integrated with multiple platforms, and supported by specialized teams. A single production issue can potentially involve application code, databases, APIs, containers, storage, networking, cloud infrastructure, identity, integrations, or even the end-user experience.
This is where Site Reliability Engineering (SRE) becomes increasingly important.
And now, with the evolution of AI and agentic systems, I believe SRE is entering its next major phase.
From Developer-Led Troubleshooting to Specialized Support
If we look back to the early 2000s, software systems were relatively simpler.
A software engineer could understand most of the application they had developed. When a production issue occurred, the same engineer could inspect the code, reproduce the issue, check the server, look at logs, identify the failing function or database query, and work toward a solution.
Development and production support were often closely connected.
As software platforms became more sophisticated, logging became an important part of troubleshooting.
Applications started generating application logs, server logs, event logs, IIS logs, scheduler logs, database logs, and other operational information.
Engineers could connect to the server, inspect the logs, identify an error, go back to the application code, and correlate the failure with a particular component.
But as systems grew larger, development and support became increasingly separated.
We created specialized L1, L2, and L3 support teams.
Development teams focused on building new capabilities.
Support teams focused on keeping production systems running.
This specialization was necessary, but it also created a new challenge:
The people troubleshooting the problem were often not the people who originally built the system.
The Complexity of Modern Production Systems
Fast-forward to today's cloud environment.
A modern enterprise application may consist of:
Front-end applications
Back-end services
APIs
Databases
Storage
Containers and Kubernetes
Azure App Services
Azure Data Factory
Azure SQL
Application Insights
Networking components
Identity services
File systems
External integrations
Messaging systems
Monitoring and alerting platforms
And these components may exist across multiple regions and environments.
A single transaction could travel through several of these systems before reaching the end user.
That makes production troubleshooting fundamentally different from troubleshooting a traditional standalone application.
The question is no longer simply:
"Which line of code failed?"
The question becomes:
"Where in this entire chain did the customer's experience start to deteriorate?"
Observability Became the Foundation
This is where centralized logging and observability became extremely important.
In a modern Azure environment, for example, organizations can bring information from multiple sources into centralized platforms.
Application logs, IIS logs, App Service logs, Azure Monitor data, Application Insights telemetry, server events, scheduler information, and other operational data can be brought together.
This gives engineers something that was difficult to achieve in traditional environments:
A broader view of the production ecosystem.
This is the foundation of observability.
But observability alone does not solve the problem.
And this is an important distinction.
Having millions of logs available does not automatically mean that we understand what happened.
The Problem With Too Much Data
Imagine a production incident where thousands—or even hundreds of thousands—of log records are generated.
An experienced engineer may know the architecture extremely well.
But they still need to:
Understand the architecture.
Identify the affected transaction.
Search the relevant logs.
Correlate events across systems.
Identify dependencies.
Check whether the database is responding correctly.
Validate APIs and backend services.
Check infrastructure health.
Determine whether the problem is application-related or platform-related.
Engage the appropriate team.
This can take significant time.
And during a production incident, time matters.
Often, a war room is created with several engineers from different teams.
One engineer checks the application.
Another checks the database.
Another checks Kubernetes.
Another checks infrastructure.
Another checks networking.
Everyone is looking at a different part of the same problem.
The traditional approach is not wrong.
It has worked for years.
But it is not necessarily the most efficient approach for today's complexity.
This Is Where AI-Powered SRE Starts to Change the Game
The emergence of AI-powered SRE introduces a fundamentally different approach.
Instead of asking engineers to manually navigate through thousands of pieces of information, an AI-driven SRE system can analyze the available telemetry and help identify where the problem is most likely located.
Whether the underlying agentic framework is based on Microsoft technologies, LangGraph, or another AI platform, the fundamental concept is similar:
Use AI to understand, correlate, reason, and guide troubleshooting across a complex production environment.
The biggest benefit is not necessarily that AI immediately fixes the problem.
The biggest benefit is that AI can give engineers direction.
For example:
"Based on the available telemetry, the application layer appears healthy. The latency is concentrated between the API and the backend service. The next area to investigate is the backend service and its dependency on the database."
That information can dramatically change the troubleshooting process.
Instead of five engineers investigating five different areas, the team can focus on the most probable area first.
AI SRE Does Not Mean "AI Will Fix Everything"
This is something I believe is important to clarify.
AI-powered SRE should not be viewed as:
Incident happens → AI fixes everything.
That is not how I see the immediate value of AI in SRE.
I see it more as:
Incident happens → AI understands the available evidence → correlates information → identifies probable problem areas → recommends the next actions → engineers validate and resolve.
That distinction is important.
The AI provides direction and confidence.
The engineer still provides judgment.
From One Big Problem to Smaller, Actionable Problems
One of the most powerful concepts in AI-driven SRE is the use of skills and specialized agents.
Initially, the problem may appear very broad.
For example:
"Users are experiencing application failures."


Monika MundraPosted Aug 23, 2026, 5:26 PM
Great article