AURA

AURA is an open-source agentic harness for production AI, built and maintained by Mezmo. Licensed under Apache 2.0 and written in Rust, it lets SRE and platform engineering teams deploy multi-agent workflows that investigate incidents, perform root cause analysis, and execute remediation steps—all within operator-defined boundaries on their own infrastructure. The GitHub repository reached v0.2.17 as of September 2026 and the project reports powering thousands of agent sessions each month inside Mezmo's own hosted observability platform.

What It Is

AURA is a production runtime for AI agent workflows targeting site reliability engineering work. Rather than a chat-based assistant, it is a configurable harness that coordinates specialist agent teams—each with isolated context, scoped tool access, and per-agent prompts—defined entirely in reviewable TOML configuration files. The harness handles guardrails, API connections, state management, streaming, failure handling, and OpenTelemetry-based observability so engineering teams can focus on the workflows that matter rather than rebuilding runtime infrastructure from scratch. Mezmo describes AURA as eliminating "80% of that boilerplate" that teams otherwise rebuild for every agent project.

How the Agent Architecture Works

AURA uses an orchestrator-plus-specialist model. A coordinator agent decomposes an incoming task—such as investigating a payment failure—and delegates to specialist workers in parallel when there are no data dependencies between subtasks. Each worker has:

• A scoped system prompt and turn depth limit
• A filtered subset of MCP tool calls it is allowed to invoke
• Optional vector store access (Qdrant or AWS Bedrock Knowledge Bases) for RAG against runbooks or reference material
• Isolated context so one worker's tool results do not pollute another's reasoning

Results flow back to the orchestrator, which synthesizes findings and determines next steps. Sensitive actions—such as applying a Kubernetes fix or merging a pull request—can be placed behind human approval gates that fail closed on denial, timeout, or transport failure.

Deployment Model and Infrastructure Fit

AURA is designed to run entirely inside an operator's own security boundary, including air-gapped and highly regulated environments, as long as model providers and MCP servers are locally reachable. Supported deployment modes include:

• Local CLI – interactive terminal use via aura command
• Webserver daemon – aura webserver for monitoring-triggered workflows
• Docker container – published mezmo/aura image on Docker Hub
• Kubernetes workload – included Helm chart under deployment/helm/aura
• Embedded library – Rust core can be linked directly into other applications

The OpenAI-compatible /v1/chat/completions endpoint means existing chat clients such as LibreChat and OpenWebUI connect without adapter code.

Integrations and MCP Connectivity

AURA connects to tools through the Model Context Protocol (MCP) over Streamable HTTP, SSE, or STDIO transports. The README lists integrations covering the major SRE toolchain:

• Incident management: PagerDuty, Jira, Linear
• Metrics and tracing: Prometheus, Datadog, New Relic, Grafana, Dash0
• Log analysis: Mezmo, Elastic (via MCP)
• Infrastructure: Kubernetes, Docker, AWS, Azure, GCP, Windows Server
• CI/CD and source control: GitHub, GitLab, Argo CD
• Runbooks and knowledge: Notion, Confluence, Qdrant vector stores
• Communication: Slack
• Workflow orchestration: Temporal

LLM providers are swappable via a single configuration change: OpenAI, Anthropic, AWS Bedrock, Google Gemini, Ollama, and OpenRouter are all supported, allowing different models to be assigned to different specialist roles.

Update: v0.2.17 and Active Development

The latest release is v0.2.17, published September 11, 2026. The repository was created in March 2026 and has seen continuous pushes since, with 356 stars and 31 forks as of the data snapshot. The GitHub roadmap is publicly tracked via an issues view. Mezmo states that AURA originated as their internal harness for operating their own SaaS and that their engineering and SRE teams continue to use it in production today. The project carries an "AURA Pledge" framing—a commitment to keep the core harness free and open source—and maintains a Slack community for contributors and users.

Why It Matters for SRE Teams

The core value proposition is compounding operational intelligence: each incident investigation feeds findings back into prevention, hardening, and change validation for the next cycle. AURA's progressive autonomy model starts with human approval for every action, then allows teams to expand agent authority as trust is established through demonstrated accuracy. Full OpenTelemetry trace export covers every LLM turn, tool call, and orchestration decision, giving SRE teams the audit trail needed to trust agent actions in production without relying on a black box.