JOURNAL

IncidentFox’s Open-Source AI SRE Agent: What You’re Actually Getting

A YC-backed AI agent promises to investigate production incidents for you. Here's what the public repo, license files, and GitHub metadata actually show once you look past the landing page.

Diagram showing an alert reaching the IncidentFox agent, which pulls logs, metrics, codebase, and chat history via integrations run by a self-hosted deployment, then calls an LLM to produce a root cause and fix

Read with AI

Choose content to copy and paste into your AI assistant. Nothing is sent automatically. CMS content is converted to Markdown; original Markdown is used when available.

60-second summary

IncidentFox (github.com/incidentfox/incidentfox) is a Y Combinator Winter 2026 company, founded by ex-Roblox/Meta-FAIR engineer Jimmy Wei and ex-Roblox infrastructure engineer Long Yi, building an AI agent that investigates production incidents in Slack, Teams, or Google Chat instead of a human paging through dashboards at 3 a.m. It claims 85-95% alert-noise reduction and hours-to-minutes investigation times — vendor numbers, not independently measured. The core is Apache 2.0 and genuinely self-hostable with Docker or Helm, and the public README lists real integrations across logs, alerting, cloud, dev tools, and 24+ LLM providers. But a five-file “security layer” — sandboxing and the credential proxy — sits under a separate Business Source License that blocks production use without a paid commercial license, and the public GitHub mirror hasn’t had a commit since 2026-03-03, about seven months before this was written. If you’re evaluating this for your own on-call rotation, those two facts matter more than the landing page.

The problem it’s aimed at

Anyone who’s been on call knows the real cost isn’t the alert, it’s the investigation. PagerDuty, Opsgenie, and incident.io are good at routing a page to the right human and tracking the timeline, but none of them tell you why the error rate spiked — that’s still someone grepping logs, correlating a deploy timestamp, and guessing. A wave of AI incident tools has shown up to fill that gap, mostly as closed SaaS: you connect your observability stack and codebase to a third party, and it reasons over the correlation for you. For a team that’s fine sending production logs and source code to an external vendor, that’s a reasonable trade. For a team that isn’t — regulated infrastructure, a security-sensitive client base, or just a strong “our incident data doesn’t leave our VPC” policy — the closed-SaaS AI-SRE category isn’t an option, which is exactly the gap IncidentFox is positioning its open-core, self-hostable product to fill.

A concrete scenario

Picture a 30-person infrastructure team at a fintech company running Kubernetes on AWS, with Datadog for metrics, PagerDuty for alerting, and a strict policy against sending production logs or source code to third-party AI vendors. They’re not short on observability tools — they’re short on the person-hours to correlate a 2 a.m. alert against a recent deploy, a dependency’s incident, and three Slack threads before anyone can say what actually broke. A self-hosted AI SRE agent that only ever talks to infrastructure they control is the kind of thing this team would plausibly pilot before buying a closed SaaS alternative.

The demand-test before you commit engineering time

Before wiring this into a real on-call rotation, the cheaper test is a shadow-mode pilot: point a self-hosted instance at read-only copies of your last 15-20 resolved incidents, ask it to produce a root-cause writeup for each, and have the engineers who actually resolved those incidents score the agent’s output against their own postmortems for accuracy and usefulness — without ever letting the agent take an action in production. That’s the number that should decide whether this is worth a real deployment: does it get the root cause right often enough, on your systems, with your integrations, to be worth the operational overhead below. This test has not been run for this article; it’s a suggested first experiment, not a result.

Getting it running

  • Documented quick-start: clone the repo, copy .env.example to .env, then run make dev (github.com/incidentfox/incidentfox).
  • Production deployment is documented via Helm on your own Kubernetes cluster, with stated support for air-gapped environments (github.com/incidentfox/incidentfox).
  • The README lists real, named integrations rather than a vague “300+” marketing figure: logs/metrics (Coralogix, Grafana, Elasticsearch, OpenSearch, Datadog, Prometheus, CloudWatch, Splunk, New Relic, Honeycomb, Jaeger, Sentry, Loki, Amplitude), incidents/alerts (PagerDuty, incident.io, Opsgenie, ServiceNow), cloud/infra (Kubernetes, AWS, GCP, Azure), dev tools (GitHub, GitLab, Confluence, Jira, ClickUp, Linear, Notion), and 24+ LLM providers including Claude, OpenAI, Gemini, DeepSeek, Mistral, Groq, and Ollama (github.com/incidentfox/incidentfox).
  • Beyond pure self-host, IncidentFox also sells a hosted SaaS tier (“complete setup in 30 minutes”) and an on-prem/VPC managed tier, alongside the free Apache-2.0 open-core option (incidentfox.ai) — that three-tier structure is also IncidentFox’s apparent revenue model: free self-host for adoption and community trust, paid for teams that want the integration and support work done for them.

How it actually fits together

Diagram showing an alert reaching the IncidentFox agent, which pulls logs, metrics, codebase, and chat history via integrations run by a self-hosted deployment, then calls an LLM to produce a root cause and fix
An alert reaches the IncidentFox agent, which pulls logs, metrics, codebase, and chat history through integrations run by your own self-hosted deployment, then calls an LLM to reason over that context before replying with a root cause and proposed fix.

The agent sits between your alerting tool and your team’s chat app. When an alert fires, it pulls context — logs, metrics, recent deploys, related code, and past incident threads — through the integrations your self-hosted deployment runs, then hands that context to an LLM to reason over (your choice of Claude, OpenAI, Gemini, or a fully local model via Ollama, among 24+ supported providers). The output is posted back as a proposed root cause and, per the marketing site, a fix script — though nothing about the fix-script step is independently verified here, and a human is clearly meant to review it before anything runs. Keeping the reasoning model itself swappable, including fully local, is the one part of this architecture that genuinely delivers on a “keep it in your infrastructure” promise, independent of whether the performance claims hold up.

What this costs and where it breaks

Read the license map before the README. The repository root is Apache 2.0, which covers almost everything — but five specific files making up a “security layer” (sre-agent/sandbox_manager.py, sre-agent/sandbox_server.py, sre-agent/credential-proxy/, sre-agent/sandbox-router/, and sre-agent/Dockerfile) are licensed under the Business Source License 1.1 instead. BSL lets you read, modify, and test that code, but production use requires a separate paid commercial license from IncidentFox, Inc., and the terms only convert to Apache 2.0 on February 18, 2030, or four years after each version’s release, whichever comes first (github.com/incidentfox/incidentfox, LICENSING.md). That’s not a trivial carve-out: sandboxing and the credential proxy are exactly the components you’d want for safely letting an AI agent read your production logs and codebase, which means a genuinely free production self-host, with the security layer included, isn’t accurate — you either run without it, replace it yourself, or pay.

The second thing worth checking before you invest real time: the public GitHub mirror’s own metadata shows 655 stars, 86 forks, 21 open issues, created 2026-01-20, and last pushed 2026-03-03 (api.github.com) — no commit to the public repo in roughly seven months as of this writing, despite an actively-marketed product. That could mean active development continues in a private repo with an infrequently-synced public mirror, or it could mean the open-source track has quietly stalled while the company focuses on its SaaS tier; this article can’t tell you which, and treats it as an open question rather than resolving it either way. On compliance: the company’s own site states its SOC 2 Type 2 audit is “currently undergoing,” not completed (incidentfox.ai) — worth knowing if a vendor summary elsewhere rounds that up to “SOC 2 compliant.” And the headline 85-95% alert-noise-reduction and 50%-to-0.3% error-rate figures are the company’s own marketing examples, with no independent benchmark found to confirm them on real-world incident data (incidentfox.ai) — exactly what the shadow-mode test above is meant to check before anyone relies on them.

Sources

Where to go next

If your team is weighing a self-hosted AI SRE agent against a closed SaaS one, the license map and the repo’s commit history are worth five minutes before the landing page’s benchmark numbers get five hours. If you want help running a shadow-mode evaluation like the one above against your own incident history before committing to a tool, Thuận Lương’s consulting practice helps infrastructure teams scope exactly that kind of pilot; reach out through luonghongthuan.com/en/contact.

Discussion

Comments are reviewed before publication. Your email is kept private.

← Back to allĐọc tiếng Việt