Is Aurora really free?

Yes. Aurora is licensed under Apache 2.0 and completely free to self-host. Your only costs are infrastructure (servers/cloud resources) and LLM API usage if you use cloud-hosted models. You can also run free local models via Ollama.

Can I use Aurora with local LLMs for air-gapped environments?

Yes. Aurora supports Ollama, which lets you run open source models like Llama and Mistral locally. This enables fully air-gapped deployments with no external API calls.

How does Aurora compare to Grafana OnCall?

They solve different problems. Grafana OnCall handles alert routing, on-call scheduling, and escalation. Aurora handles AI-powered incident investigation and root cause analysis. They work well together — Grafana OnCall routes the alert, Aurora investigates the cause.

What infrastructure do I need to run Aurora?

Aurora runs via Docker Compose or Helm chart. Minimum requirements are 4 CPU cores, 8GB RAM, and 20GB storage. For production use with Memgraph and Weaviate, 16GB RAM is recommended.

Open Source Incident Management: Why It Matters

The Shift to Open Source in DevOps

Key Takeaway: Open source incident management tools like Aurora give SRE teams full data sovereignty, no vendor lock-in, and zero licensing costs. With enterprise platforms charging $1,500-$5,000+/month, self-hosted open source alternatives are gaining traction — especially for teams that need to audit how AI investigates their production infrastructure.

Open source has transformed every layer of the DevOps stack. Kubernetes orchestrates containers. Terraform manages infrastructure. Prometheus monitors metrics. Grafana visualizes data. According to the 2024 Open Source Security and Risk Analysis Report, 96% of commercial codebases contain open source components. Yet incident management — the critical process of detecting, investigating, and resolving outages — has remained largely proprietary.

This is changing. SRE teams are increasingly demanding open source alternatives to expensive, opaque incident management platforms. The reasons are practical: data sovereignty, customization, cost efficiency, and avoiding vendor lock-in.

Why Open Source for Incident Management?

Data Sovereignty

Incident data is some of the most sensitive information in your organization. It contains infrastructure details, service architectures, failure modes, and sometimes customer impact data. With a proprietary SaaS platform, this data lives on someone else's servers.

Open source, self-hosted incident management keeps your data in your environment. You control storage, access, retention, and encryption.

No Vendor Lock-In

Proprietary platforms create deep dependencies. Your runbooks, postmortem history, incident workflows, and integrations are locked into one vendor's ecosystem. Switching costs are enormous.

Open source gives you freedom. If the project goes in a direction you don't like, you can fork it. If you outgrow it, your data is yours to migrate.

Cost Efficiency

Enterprise incident management platforms charge $1,500-$5,000+ per month. For a growing team, this adds up fast — especially when you factor in per-seat and per-incident pricing models.

Self-hosted open source tools eliminate these costs. Your expenses are infrastructure (servers, storage) and LLM API usage if the tool uses AI.

Customization

Every organization's incident process is unique. Open source lets you modify investigation workflows, add custom integrations, and build tools specific to your infrastructure. No waiting for a vendor to add a feature to their roadmap.

Transparency

When an AI tool is investigating your production infrastructure, you need to understand exactly what it's doing. Open source means full visibility into the codebase — you can audit every decision the AI makes.

"If an AI agent is running kubectl commands on your production cluster, you should be able to read every line of code that decides what it runs. That's why we made Aurora open source." — Noah Casarotto-Dinning, CEO at Arvo AI

Top Open Source Incident Management Tools

Aurora by Arvo AI

Aurora is an AI-powered agentic incident management and RCA platform. Unlike workflow-focused tools, Aurora uses LangGraph-orchestrated LLM agents to autonomously investigate incidents.

Key features:

Agentic AI investigation across AWS, Azure, GCP, OVH, Scaleway, and Kubernetes
22+ tool integrations (PagerDuty, Datadog, Grafana, Slack, GitHub, Confluence)
Infrastructure dependency graph (Memgraph)
Knowledge base with vector search (Weaviate)
Terraform/IaC analysis
Automatic postmortem generation
Any LLM provider (OpenAI, Anthropic, Google, Ollama)
Apache 2.0 license

Deploy:

git clone https://github.com/Arvo-AI/aurora.git
cd aurora
make init
make prod-prebuilt

Grafana OnCall

An open source on-call management tool from Grafana Labs. Focuses on alert routing, escalation, and scheduling rather than investigation.

Best for: Teams already using the Grafana stack who need on-call scheduling and alert routing.

Keep

An open source alert management platform that aggregates alerts from multiple sources and provides deduplication and correlation.

Best for: Teams drowning in alerts who need better aggregation and noise reduction.

PagerDuty Community Edition (Limited)

PagerDuty offers limited open source tooling around their ecosystem but the core platform is proprietary.

Aurora Deep Dive

What makes Aurora unique in the open source space is its agentic approach. Here's what that means in practice:

Self-Hosted Architecture

Aurora runs entirely in your environment via Docker Compose or Helm chart:

Backend: Python with LangGraph for agent orchestration
Frontend: Next.js dashboard for incident visualization
Graph Database: Memgraph for infrastructure dependency mapping
Vector Store: Weaviate for knowledge base search
Secrets Management: HashiCorp Vault for secure credential storage
Web Search: Self-hosted SearXNG for searching external documentation

LLM Provider Flexibility

Aurora doesn't lock you into a single AI provider:

OpenAI: GPT-4 and newer models
Anthropic: Claude models
Google: Gemini models
Ollama: Run any open source model locally (Llama, Mistral, etc.)

This means you can run Aurora completely air-gapped with local models if your security requirements demand it.

Sandboxed Execution

When Aurora's agents need to run infrastructure commands, they execute in sandboxed Kubernetes pods. This means the AI can run kubectl, aws, az, and gcloud commands safely without risking your production environment.

Getting Started with Aurora

# Clone the repository
git clone https://github.com/Arvo-AI/aurora.git
cd aurora

# Initialize configuration
make init

# Start with pre-built images
make prod-prebuilt

For Kubernetes deployment, Aurora provides Helm charts:

helm install aurora ./helm/aurora

Configure your cloud providers, connect your monitoring tools, and Aurora begins investigating incidents automatically.

Learn more at arvoai.ca or read the full documentation. To understand how Aurora's AI investigation works, read What is Agentic Incident Management?. For a comparison with commercial tools, see Aurora vs Traditional Incident Management Tools.