AURA and Open-Source Agents for Production Operations

The podcast discusses the application of AI agents in production environments, particularly within Site Reliability Engineering (SRE) and platform operations. While AI has made significant strides in software development, operational tasks like incident management and system reliability remain largely manual. The conversation centers on Aura, an open-source, declarative agent framework developed by Mesmo, which takes a Kubernetes-inspired approach by allowing teams to define desired outcomes rather than scripting detailed workflows. This declarative model simplifies agent management, improves reliability, and reduces context bloat through features like scratchpads for handling tool outputs efficiently.

Key challenges in deploying AI agents for SRE workflows include context limitations, multi-agent orchestration, and the need for structured memory systems. Aura addresses these with a unified framework that supports declarative configuration, reliable tool integration, and traceable execution via OpenTelemetry. The system enables variable autonomy levels - ranging from human-assisted to fully autonomous - through configurable human-in-the-loop controls, especially for high-stakes actions. The discussion also emphasizes agent-legible observability, where systems provide raw data and insights rather than dashboard-centric views, and highlights Aura's design for transparency, auditability, and ease of deployment. The long-term vision is to shift SREs from reactive firefighting to proactive system design by automating routine tasks and codifying institutional knowledge through AI agents.

• What if you automated incident triage using a declarative agent framework?

  • Move: Deploy Aura locally with a simple TOML config that defines an orchestrator agent to analyze incoming alerts from your monitoring stack (e.g., Prometheus, Datadog) and delegate log/metrics checks to worker agents.
  • Why Now?: Alert fatigue is increasing, and manual triage slows down MTTR; declarative frameworks now allow reliable, auditable automation without custom scripting.
  • Expected Upside: Reduce time spent on initial incident diagnosis by 50 - 70%, free up mental bandwidth for deeper system improvements, and create reusable, version-controlled triage logic.

• What if you used AI agents to auto-update your runbooks based on real incident data?

  • Move: Configure an Aura agent with read-only access to incident records and runbooks (e.g., in GitHub), and set up a memory-augmented workflow to detect recurring patterns and suggest runbook updates via PRs.
  • Why Now?: Agents can now correlate long-horizon data (logs, traces, postmortems) using structured memory, and open-source frameworks like Aura make this feasible without vendor lock-in.
  • Expected Upside: Turn tribal knowledge into living documentation, improve onboarding speed, and reduce repeat incidents through automated knowledge capture.

• What if you built a cost-optimized multi-agent swarm for production debugging?

  • Move: Define a multi-agent topology in Aura where a high-cost LLM handles root cause analysis planning, while low-cost models execute isolated tasks (e.g., querying logs, checking deployments) - all orchestrated via declarative TOML.
  • Why Now?: Token-efficient debugging is critical as LLM usage scales; Aura's support for model-tiering and OpenTelemetry-based observability makes this practical and auditable.
  • Expected Upside: Cut debugging-related inference costs by 40 - 60% while maintaining accuracy, and gain full traceability of agent reasoning for compliance and iteration.

• Adopt a declarative approach using frameworks like Aura to define operational outcomes in simple configuration files (e.g., TOML), reducing the need for manual scripting and improving reliability in agent workflows.
• Integrate OpenTelemetry into your agent systems from the start to enable deep observability, allowing traceability of reasoning steps, tool calls, and execution flows for debugging and trust-building.
• Implement a human-in-the-loop mechanism with config-driven controls, requiring manual approval for irreversible actions (e.g., production remediations) while allowing automation for low-risk, repeatable tasks.
• Optimize token costs and performance by orchestrating multi-agent workflows with different LLM tiers - using powerful models (e.g., Opus) for planning and lightweight models (e.g., Haiku) for execution tasks.
• Leverage structured memory architecture in agents to store historical incident data and runbook knowledge, enabling long-term learning, RCA improvements, and automatic runbook updates via PRs.