Scale production
past human understanding.

Mezmo provides an operating environment for agents to safely and efficiently work on production systems. It adds the context, memory, governance, and evidence required to trust production agents.

Works with and more

Example incident workflow

An AI agent investigates a checkout latency alert. Mezmo Insights finds the change: latency rose after deploy #8121. Memory recalls a prior incident where a rollback resolved it. Governance holds the rollback for on-call approval in Slack. If approved, the agent rolls back and verifies recovery. If denied, the agent stops. Ledger records the trail either way. The animation plays these paths in turn.

SEV-1 · Checkout latency over 4s in productionRecovered at 03:15 · within approved policyEscalated to on-call · nothing ran
open-source agent Claudeyour agent
incident-responder
  1. investigate checkout latency
  2. Insightsfind the change
    latency rose after deploy #8121
  3. Memoryrecall prior incidents
    INC-2107: rollback resolved it
  4. Governanceroll back to #8120
    While waiting: held for on-call approvalNeeds approval
    If approved: approved · rollback completeApproved
    If denied: denied · agent stoppedDenied
  5. Ledgerrecord the trail
    every step linked to its context
#inc-checkoutSlack
AURA03:12
Investigating checkout latency
MezmoAPP03:12
Approval needed
Agent: incident-responder · Policy: checkout operations v14
Roll back checkout to #8120?
Approved by @on-call
Denied by @on-call
AURA03:15
Recovered within policy
AURA03:13
Stopped. The denial and its reason are on the record.

Production agents

Coding agents change code.
Production agents change live systems.

A bad call can disrupt live services for customers and other teams.

Agents for coding

The artifact waits for you.

CodeReviewTestAuthorizeShip
  • Bounded context: a repo, finite and static.
  • Nothing is live while you author. The blast radius is zero until you ship.
  • Git holds every decision and its reasoning.

Agents for production work

The output is the action.

Resolve targetCheck current stateCheck approved scopeExecuteVerify
  • Check the live target and approved scope.
  • Keep human approval where policy requires it.
  • Verify the result and record what happened.

Same loop, different problem: the artifact waits for you. Production does not.

Coding is single-player.
Production is multiplayer.

Every engineer and every coding agent works on a copy of the code. Git merges the work, pull requests are the approval, and the commit history is the shared memory.

In production, every person and every agent works on main. There is no branch, no merge, and no general revert. Teams have counted on people's judgment and memory to hold it together, and that stops working when many agents, on many engineers' credentials, act on the same live system.

Git gives code these four things. Production has none of them.Mezmo puts them back
In GitA branch per change
Before: Every agent acts on the live system
One governed pathTo production, with AURA in your environment
In GitPull request review
Before: Each agent approves its own actions
GovernanceYour policy, named approvers, and an audit trail
In GitCI checks
Before: Someone eyeballs the result
LedgerEach action linked to its observed outcome
In GitCommit history
Before: Tribal knowledge, lost between sessions
MemoryShared lessons the team has reviewed

Insights

Focused context for investigation.

Insights finds the change across logs, metrics, and traces, and shapes it into context before your agent reasons. The agent spends less effort assembling it.

  • Detect meaningful changes
  • Correlate signals into one focused context
  • Trigger an investigation on an anomaly
Less time triagingLower token spendHigher accuracy
Talk to us about Insights
app.mezmo.com/checkout-platform/log-insights
app.mezmo.com/checkout-platform/governance

Governance

Control what agents can do.

Before an agent's tool call runs, Mezmo checks it against the policy you own. Routine work proceeds. People decide the exceptions.

  • Allowed calls run without interruption
  • Risky calls wait for an authorized approver in Slack
  • Calls outside approved scope never run
See how Governance works

Memory Preview

Experience for the next investigation.

Memory keeps prior conditions, actions, and verified outcomes from production incidents, and the agent reads them before it reasons. Agents reuse reviewed experience. Governance still checks each proposed action.

  • Recall relevant history with its conditions
  • Compare what matches and what has changed
  • Retain new lessons after review
Talk to us about Memory
app.mezmo.com/checkout-platform/ai-memory

Checkout rollback #8120

One linked audit trail
InsightsContext validated
MemoryIncidents recalled
GovernanceRollback approved
AgentRollback complete
TimeAgent activityLinked toContext and authority
03:12:08Validate current contextInsightsResource, deployment, and signal freshness
03:12:09Recall prior incidentsMemoryINC-2107, 2158, and 2203 with conditions
03:12:40Request rollback #8120GovernanceTool-call scope and policy decision
03:12:40Receive authorizationApprovalNamed owner and approval for this action
03:13:55Execute the rollbackActionTool arguments and executor result
03:15:02Record service restorationTelemetrySource and time of the recovery signals

Ledger Preview

The record behind every action.

Ledger links Insights context, Memory recall, Governance decisions, and agent actions as one trail of activity. Every action stays linked to what the agent knew and who permitted it.

  • State, action, and outcome, written as it happened
  • Evidence attached to every step
  • Tonight's record informs the next investigation
Talk to us about Ledger

Platform

Production requires more than an agent.

Trust comes from the environment. Mezmo provides the context, memory, governance, and evidence. Your agents and your systems stay yours.

Your agent.

Start with the harness you use, move to AURA, or bring your own.

Your policy.

Permission comes from the policy you approve, with scope and approvals built in.

Your evidence.

Every action is linked to its observed outcome in a durable record.

Your agents

  • Claude Code
  • Codex
  • AURA

Or bring your own

Context Tool call
Signals Execute

Your systems

  • Services
  • Data stores
  • Queues
  • External
  • Kubernetes
LedgerPreviewLinked context, tool calls, approvals, and outcomes

AURA

AURA coordinates a bounded workflow.
Mezmo supports autonomy at scale.

One team and one workflow establish the pattern. Broader adoption needs a shared foundation. AURA is open source: run it, read it, extend it.

CapabilityOpen source, Apache-2.0AURA + MezmoCommercial
Runs unattended
SRE workflows
Logs, traces, and metricsDirect tool connections90% cheaper and faster
Policy across workflowsIn-session human approvalCentralized and governed
Memory across workflowsLocal files and retrievalShared, durable memory
Action and outcome historyPer-run execution tracesActions linked to outcomes
Try AURA on GitHub Learn about AURA Or bring Claude Code, Codex, OpenCode, Pi, or the agent you already run.

Put your SRE agent into production.

Bring your own agent or start with AURA. Risky actions wait for approval, investigations build memory, and every step is on the record. Expand when the results hold.

FAQ

Common questions about Mezmo and AURA

What is Mezmo?

Mezmo helps engineering teams investigate incidents and run AI agents in production. AURA, Mezmo's open-source SRE agent harness, connects AI models to your operational tools and coordinates investigation and execution. The commercial Mezmo platform provides telemetry context and agent governance, with shared Memory and Ledger capabilities in preview.

What's the best way to get started with Mezmo and AURA?

Start with open-source AURA and one investigation using tools you already run. Install AURA locally, use aura init to choose your model and create an initial agent configuration, then connect a tool through the guided MCP setup. Begin with read-only access and an incident your team understands so you can check the findings against known evidence.

You can evaluate standalone AURA without buying the Mezmo platform. When you need prepared telemetry context or centralized governance across agents, talk to Mezmo about the relevant platform services.

What's the difference between AURA and the Mezmo platform?

AURA is the open-source software that runs the agent: it coordinates models, specialist workers, tools, and approval gates in your environment. You can use it independently with compatible tools and your chosen model provider.

The Mezmo platform provides services around production agents. Insights prepares operational context; Governance controls connected tool calls through policies and approvals. Memory and Ledger, currently in preview, extend the platform with shared operational history and records linking activity to outcomes. Governance is currently in closed beta. Mezmo's platform can work with AURA or other agents.

What can AURA do?

AURA connects models to operational tools so agents can investigate incidents and carry out configured workflows:

  • Incident investigation: inspect cluster state, logs, metrics, traces, and recent changes through connected tools.
  • Specialist agents: coordinate workers with their own instructions and tool access.
  • Runbook retrieval: consult operational guidance through connected tools and knowledge bases.
  • Operational actions: execute available tools within the permissions you provide.
  • Human approvals: pause selected MCP tool calls until an approval route permits them.
  • Execution tracing: export model and tool activity through OpenTelemetry.
  • Model choice: configure supported hosted providers or local models.

Do I have to build an SRE agent from scratch to use AURA?

No. AURA's setup wizard creates an initial SRE agent team with incident-response, metrics-analysis, and log-analysis workers. You connect your tools and can adapt the supplied configuration to your environment. You can change worker instructions, assign tools, and choose models without building the agent runtime yourself.

AURA can run locally, as a service, in Docker, or on Kubernetes. Your team owns its deployment, credentials, permissions, and ongoing operation.

Do I need to replace my observability or incident-management tools?

No. AURA can work with your existing tools through compatible Model Context Protocol (MCP) servers. Its guided setup includes Datadog, PagerDuty, Kubernetes, and Mezmo, and you can configure other compatible servers separately. You choose which tools each worker can use and supply the necessary credentials.

You do not need to move your telemetry into Mezmo to use standalone AURA. Start by connecting the systems needed for the investigation you want to run.

When should I choose AURA for AI SRE?

Choose AURA when you want an SRE agent you can inspect, adapt, and run in your own environment. It is a strong fit for teams that want to choose their models, connect existing tools, customize investigation workflows, and control which operational actions an agent can perform.

AURA supplies the runtime and a starting agent configuration; your team operates it. If you are comparing it with a managed AI SRE service, evaluate the deployment responsibilities alongside investigation results, customization, and control.

Can AURA make production changes, and how do approvals work?

Yes, when you give it tools and credentials that permit those changes. You can separate investigation and operations roles and configure human approval for selected MCP tool calls. A denied or timed-out gated call does not execute.

Standalone AURA supports webhook and supported conversational approval flows. Its Slack ingress does not support those approval gates. Mezmo Governance is a separate product that provides centralized policy checks and authorized approvals in Slack; it is currently in closed beta.

Which models can I use, and where does my data go?

AURA supports OpenAI, Anthropic, Gemini, Amazon Bedrock, OpenRouter, and local models through Ollama. You configure the model provider and can assign different models to specialist roles.

AURA runs on infrastructure you control. Prompts and tool data go to the providers, services, and storage or tracing destinations you configure. Keeping the entire workflow local requires local model and tool services as well as the appropriate network controls.

Can I use Mezmo Governance with an agent other than AURA?

Yes. Mezmo Governance supports agents beyond AURA. It checks connected tool calls against your policies, allows permitted actions, sends selected requests to authorized people for approval, and blocks denied actions. Each decision records the policy and approval context.

Governance is currently in closed beta. Contact Mezmo to confirm access and the connection requirements for your agent.

How does AURA's memory differ from Mezmo Memory?

Standalone AURA supports local files and retrieval for relevant context. Mezmo Memory is a separate platform capability, currently in preview, for shared, durable operational history across workflows. It preserves reviewed incident conditions, actions, and outcomes for later investigations.

Using a previous incident as context does not grant permission to repeat its actions. Governance checks the proposed action against the current policy.

How do pricing and getting started work?

AURA is open source under Apache 2.0 with no software license fee. You can start with the local quickstart and your own model access. Infrastructure, model inference, and the work of operating the agent remain your responsibility.

The commercial Mezmo platform is priced separately. The published pricing page describes data volume and retention as cost drivers and includes AI root-cause analysis without separate per-query charges. Contact Mezmo for a quote covering the services you need and to confirm access to beta or preview capabilities.