OpenSRE ships a moving main-channel binary behind an account-gated REPL
Build your own AI SRE agents. The open source toolkit for the AI era.
At a glance
- What is it?
- OpenSRE is Tracer Cloud's Apache-2.0 Python framework for AI SRE agents, pitched as an open-source agent for CI/CD reliability that reads a failed run, traces the cause and pushes a fix for review. The install takes whatever main holds at that moment, and the shell only opens for a signed-in account with a TTY.
- Who is it for?
- Adopt OpenSRE if you want an incident agent wired to your own Slack and observability stack and can accept alpha churn; the Python embedding path and the container route both assume you build from main yourself. Do not adopt it as the only interface to your on-call tooling while the README's own public alpha warning stands.
- Can I use it commercially?
- Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 1 day ago.
- What is it written in?
- Mainly Python, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- Tracer-Cloud/opensre12,833 ★ · +1,629
| Repository | 2026-09-22 | 2026-11-15 |
|---|---|---|
| Tracer-Cloud/opensre | 11.2k | 12.8k |
1,629 Stars in the last 54 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
The installer pulls the latest build from main, so there is no version to pin
Two lines cover every platform. On macOS or Linux a curl pipe feeds bash; on Windows PowerShell the README inlines a downloaded script block. Both end in the same `-gh` flag.
curl -fsSL https://install.opensre.com | bash -s -- -gh& ([scriptblock]::Create((irm https://install.opensre.com/install.ps1))) -ghThe consequence sits in the next sentence: the installer fetches the latest build from `main` and does not require sudo. Nothing pins that build. Releases carry dated tags such as `v0.1.2026.11.3`, but the install path never asks for one, so two engineers running the same line on different days can get different agents. The repository root does carry `install.sh` and `install.ps1` next to `opensre.spec`, the PyInstaller spec for the frozen bundle a dependency comment says release.yml assembles, so the same code can be rebuilt locally instead.
After install, `opensre` with no subcommand starts the shell. If the command is not found, the install notes say to follow the PATH instructions the installer prints or open a new terminal.
The REPL refuses to open without a signed-in account and a TTY
Running `opensre` with no subcommand validates your account and starts a REPL, and the shell only opens for an active account. A TTY is required. That is the first hard limit on the tool: the interactive surface is unavailable to an unauthenticated machine and to a CI runner with no terminal.
opensreThe first launch activates the hosted model, so the LLM path is chosen for you before you touch `LLM_PROVIDER`. Session control comes through slash commands including `/cost`, `/compact`, `/sessions` and `/new`. Integration state has its own pair, `/integrations list` and `/integrations verify`. Ctrl+C cancels the turn in flight without discarding session state, which matters when an investigation is halfway through and you need to interrupt it without losing the thread.
Webapp contributors authenticate differently, with `opensre setup --dev` routing through `http://localhost:3000`.
Headless turns and an embedded session that demands a source checkout
`opensre ask` runs a single turn from a terminal, a script or a CI job.
opensre ask "why is checkout-api slow?"The Python route drives the agent in-process, and it is marked as requiring a source checkout. The installed binary alone is not enough for this path.
from bootstrap.embedded import start_embedded_session
session = start_embedded_session()
result = session.chat("why is checkout-api slow?")
if result.answered:
print(result.primary_response_text)That import says more than the example does. The Makefile names the source roots as bootstrap, config, core, gateway, integrations, infrastructure, surfaces and tools, and contributors are pointed at `main.py` for the process entrypoint map. Embedding OpenSRE means building from main with `uv sync --frozen --extra dev`, not installing a wheel. Teams writing automation against it inherit that dependency on a clone, and `opensre uninstall`, which removes opensre and all local data, is a separate teardown story from a checkout of its own.
LLM_PROVIDER can point at a CLI you already pay for, and one of them ignores the model setting
The example environment sets `LLM_PROVIDER=anthropic` and lists sixteen common values, from openrouter and ollama through to codex, claude-code, gemini and antigravity-cli. The last four are local CLIs rather than API endpoints, and each carries its own login step and its own optional bin and model override.
npm i -g @anthropic-ai/claude-codeCodex needs `codex login`. The Claude Code CLI needs `claude login` or `ANTHROPIC_API_KEY`. Gemini needs its own auth setup. The Antigravity CLI, invoked as `agy`, authenticates through a browser on first run and caches the token in the OS keyring. Leaving a model variable empty falls back to whatever that CLI is already configured for, which is convenient on a workstation and makes runs differ between machines without any config difference on your side.
The one documented hole is worth knowing before you automate. The note on `ANTIGRAVITY_CLI_MODEL` calls it forward-compat only, because agy v1.0.2 does not expose `--model` in headless mode, and switching there happens interactively through `/models`. A headless job that needs a fixed model cannot get one from that provider, so provider choice becomes a reproducibility decision rather than a convenience.
The container installs main on boot, so the same image tag is not the same build
The Dockerfile header states the image is the toolchain plus a supervisor, and that it does not bake an OpenSRE checkout. On start the supervisor installs the current main-channel binary, and `opensre update` inside the container restarts the process onto a newer build. The image you push today and the one running next month can carry different agents, with no rebuild and no commit recording the change.
docker build -t opensre:latest .
docker run -p 8000:8000 --env-file .env opensre:latest
curl http://localhost:8000/health`MODE` picks the surface. Web is the FastAPI API for health, alerts and async investigations. Gateway is the two-way messaging gateway over Slack Socket Mode and Telegram. Scheduler is a cron loop service with neither. Gateway mode expects `SLACK_BOT_TOKEN` and `SLACK_APP_TOKEN`, or `TELEGRAM_BOT_TOKEN` with `TELEGRAM_ALLOWED_USERS`, on top of `LLM_PROVIDER` and its keys.
docker run -e MODE=gateway --env-file .env opensre-gateway:latestThe image is the toolchain around the agent: git, the GitHub CLI, Node, Codex and the shell tools agents reach for, which the CI repair loop shells out to. The OpenSRE binary the supervisor fetches is not, which is the part that decides your rollback story.
Three gateway routes, and the AMI path drops both Docker and Slack
Deployment splits three ways. The OpenSRE Cloud managed gateway is provisioned by an organization admin in the web app, so signed-in shell users can start and stop it without handling infrastructure credentials locally. The AMI route is `make build-gateway-image` then `make deploy-gateway`, installs the gateway into a server image that new servers boot from, and covers Telegram only with no Docker. The container route is the repository Dockerfile on Railway, ECS or Vercel, where you select `MODE` and set `LLM_PROVIDER` plus its key.
The Telegram-only limit on the AMI path settles architecture before anyone writes a line of code. A team that runs Slack cannot take that route as written, so the container gateway is the one that accepts `SLACK_BOT_TOKEN` and `SLACK_APP_TOKEN`, and that means owning the container rather than an AMI. `DATABASE_URL` carries the same narrowness: the deployment notes restrict it to cases where the gateway needs shared Postgres-backed state, such as Slack Events API replicas. On a single node it buys you nothing, and setting it everywhere only adds a connection string to fail.
OpenSRE positions itself against the SWE-bench gap for incident response
The argument runs from a specific hole. SWE-bench showed that agents improve fastest with realistic tasks and clear feedback, and pipeline failures are slower, noisier and harder to reproduce than local code tasks, so the project says it holds OpenSRE to the same standard.
What replaces the borrowed benchmark sits in the repository: real-world end-to-end tests across cloud-backed scenarios under `tests/e2e`, plus a naming discipline recorded in `tests/README.md` meant to keep e2e versus unit and local versus cloud boundaries obvious. The directory layout backs the same instinct, with separate `surfaces/`, `gateway/`, `integrations/` and `core/` roots rather than one flat package.
For a reader comparing tools, the real difference is where the agent starts. Coding-agent harnesses begin with a repository and a diff. OpenSRE begins with a failed CI run or an alert; pyproject.toml describes it analysing alerts from Slack, Grafana, Datadog and other tooling.
Public alpha, pinned dependency ceilings, and an uninstall that takes local data with it
The stability warning comes before the install instructions: core workflows are usable for early exploration but not yet fully stable, with APIs and integrations subject to change. The last push was on 2026-11-01, so the repository is not stale, yet the version in pyproject.toml is still 0.1 and the releases are dated build tags.
Two dependency ceilings deserve attention. `litellm` is held below 1.107.0, and `cryptography` is pinned to the 50.x line for a reason spelled out in a source comment: 50.0.0 is the first version patched for CVE-2026-69247, a PKCS#7 Bleichenbacher oracle. The same comment records that cryptography 49 and later ship no x86-64 macOS wheel, so the darwin-x64 release binary builds it from source against OpenSSL 3.2 or newer, and release.yml pins Homebrew openssl@3 and re-copies those dylibs into the onedir bundle. Anyone rebuilding that target on an Intel Mac needs that toolchain present first.
Python 3.12 is the floor. `opensre uninstall` removes opensre and all local data, and the preferred local integration store is `~/.opensre/integrations.json`. Plan for rollback yourself, since the installer always takes the newest main build.
Editorial conclusion
Adopt OpenSRE if you want an incident agent wired to your own Slack and observability stack and can accept alpha churn; the Python embedding path and the container route both assume you build from main yourself. Do not adopt it as the only interface to your on-call tooling while the README's own public alpha warning stands. Verify first what your provider lets you pin: the installer takes an unpinned main build, and the Antigravity CLI cannot take a model from the environment in headless mode.
Frequently asked questions
What is OpenSRE?
It is an Apache-2.0, Python-based open-source agent for CI/CD reliability: a CLI agent that reads a failed CI run, traces the cause and pushes a fix for you to review, self-hosted with your own models.
What are AI SRE agents used for?
For automated incident investigation and root cause analysis; pyproject.toml says OpenSRE analyses alerts from Slack, Grafana, Datadog and other tooling. The README focuses it on CI/CD: investigating a failed run, separating CI-caused from code-caused failures and pushing a fix for review.
Is the SRE Agent open source?
Yes. pyproject.toml declares Apache-2.0 and requires-python >=3.12. The repository is not archived and the last push was on 2026-11-01, though the version field still reads 0.1.
What are the alternatives to OpenSRE?
OpenSRE frames itself against simply re-running failed CI rather than against named products: it investigates the failure and pushes a fix for review. It cites SWE-bench for its testing standard and runs cloud-backed end-to-end tests under tests/e2e.
Official sources
Where developers are discussing it
Posts on Hacker News, dev.to and Lobsters that link to this repository, found by our scan of those communities. 1 in the last 30 days; newest first.
- Who owns the LLM? 28 AIOps products compareddev.to · Nov 4, 2026 · 2 points · 0 comments
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/tracer-cloud-opensre)Star history chart for your README
[](https://hysenlabs.com/projects/tracer-cloud-opensre)Was this useful?