Mezmo Agentic SRE

The alert fires.Your SRE agent investigates.

When an alert fires, Mezmo's SRE agent starts the root cause analysis. Open the investigation to find the evidence, a confidence score, a suggested fix, and a timeline. Your team decides which tools it uses and which calls need approval.

An AI SRE agent built on open source. Mezmo's SRE agent runs on AURA, our open-source agent (Apache 2.0). Each alert it works produces an AI Investigation: one record of what it checked and found.

Example AI Investigation record. A pipeline alert on notification-worker queue depth triggered it at 01:58:12 and it completed at 02:00:47. Root cause: a queue backlog on notification-worker after deploy 3.9.0 lowered worker concurrency from 32 to 4, with confidence 0.84. Evidence: a log pattern "Job waited in queue before start" rose to 2,310 events from 140, deploy 3.9.0 reached notification-worker at 01:52, and email-sender delivery p95 rose to 2.4 seconds from 180 milliseconds. Suggested resolution: restore worker concurrency to 32 and roll out notification-worker, a write that waits for human approval.

AI Investigationinv_4c19e2Completed
Trigger Pipeline alert · notification-worker queue depth above threshold
Root cause

Queue backlog on notification-worker after deploy 3.9.0 lowered worker_concurrency from 32 to 4.

Confidence0.84
Evidence
Log pattern
Job <*> waited <N> s in queue before start
2,310140 before
Change
Deploy 3.9.0 reached notification-worker
01:526 min before
Trace
email-sender delivery p95
2.4 s180 ms before
Suggested resolution
Restore worker_concurrency to 32 and roll out notification-worker.Write needs approval
Open in Mezmo, or read it from any agent with get_ai_investigation.

Where on-call starts today. The page arrives with a symptom. The first stretch of the incident goes to questions the alert doesn't answer.

Which service? The alert names a symptom, not a cause.

Since when? Someone builds a time window by hand.

What changed? Deploys, configs, and logs get checked one tool at a time.

AI Investigations

The investigation is underwaybefore you open it

Point an in-stream pipeline alert at Mezmo AURA Investigation. When it fires, AURA starts collecting evidence, so whoever opens the investigation sees what has already been checked.

A finished record holds the linked alert, the evidence, a confidence score, the root cause, a suggested fix with remediation steps, and a timeline. Any MCP client reads it with get_ai_investigation.

AI Investigations is enabled per account. Talk to us to turn it on.

Example AI Investigations list with one active investigation. ingest-gateway p95 latency is investigating, started 2 minutes ago. notification-worker queue backlog completed with confidence 0.84 and a suggested fix to restore worker concurrency to 32. image-resizer restarts completed with confidence 0.64 and a suggested fix to raise its memory limit or roll back to 2.4.0.

app.mezmo.com/acme/ai-investigations
AI Investigations1 active
Investigatingingest-gateway p95 latency
Trigger: pipeline alertStarted 2 min ago6 tool calls so far
Completednotification-worker queue backlogConfidence 0.84

Suggested: restore worker_concurrency to 32 and roll out notification-worker.

Trigger: pipeline alert01:58 to 02:003 evidence items
Completedimage-resizer restartsConfidence 0.64

Suggested: raise the image-resizer memory limit, or roll back to 2.4.0.

Trigger: pipeline alertYesterday, 23:52Linked: 1 investigation
  1. 1

    An alert fires

    An in-stream alert on a pipeline source or processor notifies Mezmo AURA Investigation.

    Mezmo platform
  2. 2

    The agent gathers evidence

    Workers query your systems with the tools you assigned. Mezmo MCP returns clustered log patterns instead of raw lines.

    AURA + Mezmo MCP
  3. 3

    A root cause, with the evidence behind it

    The record fills in with evidence, a confidence score, a suggested fix, and a timeline.

    AI Investigation
  4. 4

    Changes wait for a person

    Calls you gate hold until someone approves. A denial goes back to the agent with the reason.

    AURA

Example approval gate. The operations worker's reads ran straight through: get pods at 09:41:20 and the log histogram at 09:41:24 were allowed. At 09:41:37 it called k8s apply configmap on edge-cache, which matched the pattern k8s:apply_* and is held for a person. If approved, the call runs. If denied, the call does not run and the agent is told why. If nobody decides within 5 minutes, it fails closed.

operations workeredge-cache incidentWaiting on approval
Held for approval · 09:41:37 k8s:apply_configmap Restore cache_ttl to 300s on edge-cache. Matched k8s:apply_*.
DenyApproveNo decision in 5 min fails closed

Human in the loop

Reads run.Writes wait.

Give each worker the access it needs. AURA gives every worker its own tool list, and approval gates hold the calls you name until someone decides.

A denial goes back to the agent with the reason, so it explains instead of retrying. If a request times out or the approval channel fails, the gated call doesn't run. For policy across agents, Slack approvals, and decision records, add Mezmo Governance. It works with agents beyond AURA.

Advisory

Investigate before acting

Give the agent read access to gather evidence and recommend a fix.

Supervised

Approve selected changes

Add the required write tools, and gate the calls that need a human decision.

Trusted workflows

Expand deliberately

Review how a workflow performs before allowing specific routine calls to run under policy.

Example AURA session. Asked why search results are stale, the orchestrator routes work to a logs worker and a Kubernetes worker. The logs worker calls Mezmo's root cause analysis tool over the last 30 minutes, which reduces 52,118 log lines to 9 clusters. The Kubernetes worker lists pods; the 31,907-token result goes to the scratchpad instead of the prompt, and a grep pulls back 386 tokens. The finding: pods are healthy, and bulk-index rejections begin at 03:41, right after mapping change 7.2.

aura · sre-orchestrator

Engineered context

Telemetry that fitsin a context window

One log export can be larger than a model's context window. Mezmo MCP clusters logs before the agent reads them, and AURA keeps oversized tool output on disk until the agent needs a piece of it.

Clustered log patterns

Mezmo MCP deduplicates and clusters logs over a time window and returns the patterns, not every line.

Large results stay on disk

With the scratchpad on, AURA writes oversized tool results to disk. The agent reads back only the part it needs.

Start from what changed

Mezmo Insights flags changed log patterns, metric anomalies, and trace findings, and the agent queries them over MCP. Explore Insights

AURA, open source

AURA runs the work.You control the config.

The agent behind every investigation is open source. AURA is written in Rust, licensed Apache 2.0, and configured in TOML. Read the code, run it in your own infrastructure, and see exactly what it did.

Deploy on your termsRun AURA locally, in a container, or as a Kubernetes workload.

Choose your modelConfigure OpenAI, Anthropic, Gemini, Bedrock, OpenRouter, or a local Ollama instance.

Connect your toolsUse compatible MCP servers for systems such as Kubernetes, Prometheus, Grafana, GitHub, PagerDuty, and Mezmo.

Trace agent activityExport OpenTelemetry traces for model calls, tool calls, and orchestration activity.

config.toml: an orchestrator with a logs worker scoped to Mezmo tools, an operations worker scoped to Kubernetes tools, and an approval gate on apply, restart, and delete tools.
# An SRE orchestrator with two scoped workers
[agent]
name = "sre-orchestrator"

[agent.llm]
provider = "anthropic"

[mcp.servers.mezmo]
transport = "http_streamable"

[mcp.servers.k8s]
transport = "http_streamable"
url = "http://k8s-mcp:8080/mcp"

[orchestration]
enabled = true

[orchestration.worker.logs]
description = "Query and cluster logs"
mcp_filter = ["mezmo:*"]

[orchestration.worker.operations]
description = "Changes to running services"
mcp_filter = ["k8s:*"]

# Writes wait for a person
[hitl]
require_approval = ["k8s:apply_*", "restart_*", "delete_*"]
$ curl -fsSL https://raw.githubusercontent.com/mezmo/aura/main/scripts/install.sh | bash $ aura init

Get started

Two ways to start

Pick the path that matches where your telemetry lives today.

Mezmo platform

Already sending telemetry to Mezmo?

Turn on AI Investigations and point a pipeline alert at it. The next time that alert fires, the investigation starts on its own.

AI Investigations is enabled per account.

Open source

Starting fresh?

Install AURA with one command and connect the MCP servers you already run. Add the Mezmo platform when you want alert-triggered investigations.

$ curl -fsSL https://raw.githubusercontent.com/mezmo/aura/main/scripts/install.sh | bash

Questions

Common questions

What is an AI SRE agent?

An AI SRE agent uses connected tools and production telemetry to investigate operational problems and propose next steps. Mezmo built AURA as an open-source SRE agent for this work. The Mezmo platform adds alert-triggered investigations and clustered telemetry context.

Can AURA change production?

Only through tools you make available to it. You limit tool access by worker and choose which calls need human approval. Approval gates do not automatically cover every write tool, so review the tool list and gate configuration before granting production access.

Which models does AURA work with?

AURA supports OpenAI, Anthropic, Gemini, Bedrock, OpenRouter, and local Ollama instances. Model providers are configured in TOML.

Where does AURA run, and where does data go?

AURA runs on infrastructure you control. It sends prompts and tool data to the model providers, MCP servers, approval services, storage backends, and tracing destinations you configure. The interactive CLI also has documented, opt-out anonymous product telemetry. Review the AURA telemetry controls when planning a deployment.

Do I have to train a model on my environment?

No. AURA queries your connected tools during an investigation. Add runbook retrieval or skills that load task instructions when a task needs them.

How is AURA different from a closed SRE agent?

You can inspect AURA's source code, review its configuration, scope each worker's tools, and export traces of its activity.

Your infrastructure. Your rules.Your SRE agent.

Turn on AI Investigations for your Mezmo pipelines, or start with open-source AURA.