AI SRE Agent, End to End: AURA Takes an Incident from Alert to Fix
Checkout starts failing because the cart service keeps dying. The real cause is a recent pull request that let memory grow with every add to cart.
Learn more about AURA → https://www.mezmo.com/aura
Get started today → https://github.com/mezmo/aura
Get deployment help → https://www.mezmo.com/contact
Jeff walks through a complete AURA run in one of the benchmark environments the team tests against: a simulated e-commerce stack on Kubernetes carrying production-shaped telemetry. A load spike pushes the cart service out of memory, it gets killed and enters a restart loop, and the checkout service starts throwing 502s because its upstream keeps disappearing. An alert fires, an incident opens, a Slack channel is created, and a webhook hands the incident to AURA.
The coordinator writes a plan and dispatches workers, each writing its response as a typed artifact on disk that the coordinator and dependent workers can reference. The cluster worker finds the checkout pods healthy and the cart crashing. The metrics worker reads Grafana and finds memory that grows on every add to cart and never comes back down. The GitHub worker, given a stronger model, finds a recent pull request against the cart service and diagnoses an unbounded per-session regression on the add to cart method. Symptoms came from logs, the cause from metrics, and the root cause from code.
AURA then locates the exact line and method and gives guidance on the fix. Filing a GitHub issue is guarded by human-in-the-loop approval, so the run pauses for a person. The issue carries the root cause, the proposed fix, the impact, and AURA's own remediation suggestion. AURA does not write the code: the issue is assigned to a developer or handed to Claude. After the change ships, PagerDuty auto-resolves the incident and AURA re-checks the cluster, metrics, and logs to confirm recovery.
The second half is the configuration. Four MCP servers are wired up: Kubernetes, Grafana, PagerDuty, and GitHub. Every access token is read-only except GitHub, which can create issues. Human-in-the-loop guards specific tool calls and accepts wildcards. Inference runs on Baseten, though any OpenAI-compatible API works. Scratchpad writes any tool response over the token threshold to disk and gives workers tools to explore it in small chunks. Five workers each get their own prompt and tool list: incident responder, cluster inspector, metrics analyst, log analyst, and GitHub analyst. Any worker can use tools from any MCP server, and workers can run on different models.
The pipeline is not the point, and yours would look different anyway. AURA holds a bounded role, deep reasoning and trusted actions under worker instructions your team owns and can read in a diff. Scoped workers, parallel dispatch, and large tool outputs kept out of the context window are what let non-frontier open-weight models resolve a multi-domain root cause.
Jeff's advice for starting: skip the pipeline. Run AURA standalone, connect a few MCP servers, and iterate from there. Kubernetes and automation come later. Governance of agent goals and durable memory are what the team is working on next, because approving every single action does not scale.
For more detail, visit
https://www.mezmo.com/videos/ai-sre-agent-end-to-end-alert-to-fix-in-one-aura-run
0:00 What AURA is and why it is open source
0:32 The benchmark environment and today's failure
1:16 How the incident reaches AURA
1:51 The root cause across logs, metrics, and code
3:04 From finding to a filed GitHub issue
4:00 Deploy, auto-resolve, and verify
4:39 Inside the AURA config
5:36 Workers, tools, and models
6:06 What the harness actually gives you
7:12 Where to start, and what is next
#AISRE #SRE #Kubernetes #IncidentResponse #OpenSource #AIAgents #DevOps