Incident management meets AI-powered development.
Prevent, respond, and learn from incidents -- without leaving your terminal.
You're in the zone writing code. Then:
- You
git pushand realize there's a SEV-1 in progress - You get paged and scramble between Slack, Datadog, and your incident tool
- The retro after an incident takes hours to compile
This plugin brings Rootly's incident lifecycle into Claude Code -- so you can assess deployment risk, investigate incidents, check on-call, and generate retrospectives from the same terminal where you write code.
Analyzes your git diff against past incidents. Warns you if similar changes caused outages before. Checks if on-call coverage exists. |
Pulls full incident context, finds similar past incidents, suggests proven solutions, and shows who's on-call -- all in one brief. |
See who's on-call across all schedules, shift metrics, upcoming handoffs, and health risk indicators. |
Quick overview of all services with active incidents grouped by severity and age. |
Generate executive-friendly incident summaries with impact, timeline, and current status for stakeholder updates. |
Create structured handoff documents for incident commanders or on-call transitions with context and next steps. |
Natural language queries about your incident data, on-call schedules, and service reliability patterns. |
Generates structured retrospectives from incident data: timeline, contributing factors, action items, and systemic patterns. |
You can use this plugin in two ways:
- Marketplace install for a persistent Claude Code installation
- Local
--plugin-dirloading for development and evaluation from source
This repository includes .claude-plugin/marketplace.json, so Claude Code can use the repo itself as a marketplace source.
- Add the marketplace:
/plugin marketplace add Rootly-AI-Labs/rootly-claude-plugin
- Open the plugin manager:
/plugin
- In the Discover tab, select
rootlyand install it to your preferred scope:
- User: available across all your projects
- Project: shared through this repository's
.claude/settings.json - Local: only for you in this repository
- Reload plugins so the install takes effect immediately:
/reload-plugins
- When Claude Code prompts for the plugin's configuration, paste your Rootly API token, then run:
/rootly:setup
git clone https://github.com/Rootly-AI-Labs/rootly-claude-plugin.git
cd rootly-claude-pluginclaude --plugin-dir .Claude Code loads the plugin directly from this directory for the current session. This is the recommended flow for local development and evaluation. For a persistent install, use the marketplace flow above.
Get a token from your Rootly dashboard under Settings > API Keys.
The plugin will prompt for your ROOTLY_API_TOKEN when you install it. This single configuration works for all plugin features. The MCP server reads the token from ${user_config.ROOTLY_API_TOKEN}, so the prompt is the canonical path for both marketplace installs and --plugin-dir loading.
For non-interactive dev environments where you cannot complete the prompt, you can additionally export an env var:
export ROOTLY_API_TOKEN="your-token-here"The env var is honored by the hook scripts (incident-warning checks at commit/push time), but MCP-backed commands (/rootly:respond, /rootly:oncall, /rootly:setup, etc.) will only work once the userConfig prompt has been completed, since HTTP MCP headers do not read from arbitrary OS env vars. If the prompt didn't appear, run /plugin and re-enable the Rootly plugin to trigger it.
/rootly:setup
This repository is a Claude Code plugin. If you only want direct Rootly MCP access in Claude Desktop / Cowork, configure the MCP server separately:
{
"mcpServers": {
"rootly": {
"command": "npx",
"args": [
"-y", "mcp-remote",
"https://mcp.rootly.com/mcp",
"--header", "Authorization:Bearer YOUR_TOKEN_HERE"
]
}
}
}Replace YOUR_TOKEN_HERE with your Rootly API token, then restart the app.
After installation, run the setup command:
> /rootly:setup
First-time plugin setup with API token validation, service mapping, and quick-start guide.
If you need to update your Rootly API token:
# Uninstall and reinstall to get fresh configuration prompt
claude plugin uninstall rootly@rootly-plugins
claude plugin install rootly@rootly-plugins# Use the interactive plugin manager
claude pluginThen go to Installed tab, find Rootly, and look for configuration options.
# Session-scoped override for hook scripts only
export ROOTLY_API_TOKEN="new-token-here"Note: this only affects the hook scripts (active-incident warnings on commit/push). MCP-backed commands continue to read from the userConfig value, so update the plugin config (Option 1, 2, or 4) to refresh those.
Edit the settings file directly:
- User scope:
~/.claude/settings.json - Project scope:
.claude/settings.json
Look for pluginConfigs["rootly@rootly-plugins"].options.ROOTLY_API_TOKEN and update the value.
| Command | What It Does |
|---|---|
/rootly:setup |
First-run configuration and connection check |
/rootly:my |
Personal dashboard — your active incidents, action items, and upcoming on-call |
/rootly:status [service] |
Service health overview — active incidents at a glance |
/rootly:oncall [team] |
On-call dashboard with shift metrics |
/rootly:alert [short-id] |
Triage a Rootly alert — events, group context, linked incident |
/rootly:lookup [name] |
Look up a service, team, or catalog entity — owner, on-call, reliability |
/rootly:trend [scope] |
30-day reliability trend with prior-period comparison |
/rootly:brief [id] |
Stakeholder summary for executives or customers |
/rootly:handoff [id] |
Incident or on-call handoff documentation |
/rootly:ask [question] |
Natural-language Q&A over your Rootly data |
/rootly:action [list|add|done] |
Manage incident action items (write actions confirm before mutating) |
/rootly:swap [date] |
Request someone cover one of your shifts (write, confirms first) |
/rootly:cover [team] |
Offer to cover someone else's shift (write, confirms first) |
/rootly:announce [id] |
Draft and post a stakeholder update on an incident (write, confirms first) |
| Command | What It Does |
|---|---|
/rootly:respond [id] |
Deep incident investigation via the incident-investigator agent |
/rootly:retro [id] |
Post-incident retrospective via the retro-analyst agent |
/rootly:deploy-check |
Pre-deploy risk analysis via the deploy-guardian agent |
The experimental skills delegate to forked subagents. In some Claude Code contexts the subagent doesn't inherit the plugin's MCP server; when that happens it stops and reports rather than falling back to bash/curl (which would leak the API token). For reliable coverage of those workflows, prefer
/rootly:brief,/rootly:status, and the inline alternatives above.
/rootly:ask how many SEV-1 incidents did we have last month?
/rootly:ask which service has the most incidents this quarter?
/rootly:ask who's been on-call the most in the last 30 days?
When a slash command isn't enough, Claude automatically invokes specialized agents for deeper analysis:
| Agent | Triggered When | What It Does |
|---|---|---|
| Incident Investigator | You need root cause analysis beyond initial triage | Builds hypothesis trees, correlates alerts with code changes, traces causation chains |
| Deploy Guardian | Multi-service deployments with cross-team impact | Maps blast radius across dependent services, evaluates downstream risk, builds coordination checklists |
| Retro Analyst | You want to understand patterns across incidents | Clusters incidents by failure mode, calculates frequency trends, identifies systemic reliability issues |
Two lightweight hooks run in the background -- they never block your workflow:
| Hook | When | What It Does |
|---|---|---|
| Token check | Session start | Validates your API token and nudges you to configure one if missing |
| Incident warning | Before git commit / git push |
Warns if there's an active critical incident -- so you don't deploy into a fire |
Map your repository to Rootly services by creating .claude/rootly-config.json:
{
"services": ["auth-service", "auth-worker"],
"team": "platform-team"
}/rootly:setup walks you through creating this. Without it, the plugin falls back to matching your git repo name against Rootly service names.
Self-hosted Rootly
export ROOTLY_API_URL="https://rootly.internal.example.com"This overrides the REST API base URL used by hook scripts. Configure the MCP endpoint separately in .mcp.json.
Local MCP server
Replace the HTTP transport in .mcp.json:
{
"mcpServers": {
"rootly": {
"command": "uvx",
"args": ["--from", "rootly-mcp-server", "rootly-mcp-server"],
"env": {
"ROOTLY_API_TOKEN": "${user_config.ROOTLY_API_TOKEN}"
}
}
}
}CLI MCP setup
claude mcp add rootly --transport http https://mcp.rootly.com/mcp \
--header "Authorization: Bearer YOUR_TOKEN"Post-push deployment registration
An optional script (scripts/register-deploy.sh) can register deployments with Rootly after git push. It is not enabled by default -- see the script header for hook configuration.
| Problem | Fix |
|---|---|
| "No API token found" | Re-open the Rootly plugin config and provide a valid token via the prompt. Setting ROOTLY_API_TOKEN as a shell env var only feeds the hook scripts; MCP commands need the userConfig value. |
| "API token appears invalid" | Regenerate your key in Rootly: Settings > API Keys, then update the plugin config and rerun /rootly:setup. |
| MCP tools not responding | Confirm the token works against https://api.rootly.com/v1/users/me, then reload the plugin with /reload-plugins. |
| Skills not appearing | Run /reload-plugins, then check the Installed tab in /plugin. |
| Hook scripts not running | Run chmod +x scripts/*.sh and ensure jq or python3 is available. |
See ARCHITECTURE.md for the full technical design: MCP integration, hook system, agent orchestration, and data flow.
Apache 2.0 -- see LICENSE.
Built by Rootly AI Labs