Rootly MCP server for AI agents

Live

BEARER TOKEN

INCIDENT MANAGEMENT

Monitoring

Rootly gives your agent incident management: create, triage, mitigate, and resolve incidents, acknowledge and escalate alerts, check on-call schedules, update retrospectives, and post status page updates.

  • Per-user credentials: each call uses the actual user's access token, never a shared bot.
  • Encrypted per-tenant vault: AES-256, resolved at request time, never in LLM context.
  • Scoped before every call: pre-call scope check, 90-day SIEM-exportable audit chain.
Rootly
agent · Acme Q3
Run
Who is on call for the API service right now?
S
rootly_list_oncalls
104ms
Incident agent
Dana Kim is on call for the API service until 9am tomorrow. Priya Shah is the secondary.
Sources: 2 on-call shifts
rootly
2 on-calls
18:29
Message Claude...

Tools your incident agent reaches for on Rootly, scoped per user.

CALL ANY TOOL
110 tools for incident management in Rootly: create and resolve incidents, handle alerts, read on-call schedules and shifts, update retrospectives, and post status page events.
rootly_acknowledge_alert
Acknowledge alert
Acknowledge an alert. Returns the alert record with id, type and attributes (short_id, noise, source, status, summary, description). Use it to apply this state change to an existing record by id.
Parameters
Name
Type
Required
Description
id
string
Required
The UUID or slug of the target record, as returned by the matching list tool. Example: a1b2c3d4-e5f6-4789-a012-3456789abcde.
actor
object
Optional
The user to record as performing this action. Only available when actor attribution is enabled for the organization; otherwise it is ignored. Only supported with Global and Team API keys; with a Team API key the user must belong to one of the key's teams. When omitted or null, the action is attributed to the API key. Otherwise provide either `email` or `user_id`, not both. Provide as a JSON object. Example: {"key": "value"}
rootly_add_incident_subscribers
Add incident subscribers
rootly_cancel_incident
Cancel incident
rootly_create_alert
Create alert
rootly_create_incident
Create incident
rootly_create_incident_status_page_event
Create incident status page event
rootly_create_service
Create service
rootly_delete_action_item
Delete action item
rootly_get_action_item
Get action item
rootly_get_alert_route
Get alert route
rootly_get_catalog_entity
Get catalog entity
rootly_get_environment
Get environment
rootly_get_incident_event
Get incident event
rootly_get_post_mortem
Get post mortem
rootly_get_schedule
Get schedule
rootly_get_status_page_event
Get status page event
rootly_list_action_items
List action items
rootly_list_alert_sources
List alert sources
rootly_list_catalog_entities
List catalog entities
rootly_list_escalation_policies
List escalation policies
rootly_list_incident_events
List incident events
rootly_list_incident_types
List incident types
rootly_list_playbooks
List playbooks
rootly_list_schedule_override_shifts
List schedule override shifts
rootly_list_shifts
List shifts
rootly_list_statuses
List statuses
rootly_move_incident_to_triage
Move incident to triage
rootly_update_action_item
Update action item
rootly_update_incident
Update incident
rootly_update_post_mortem
Update post mortem

For more tools, view docs.

Build your Agent
Same auth pattern across LangChain, OpenAI, Anthropic, and Google ADK.
Python · LlamaIndex
import { ScalekitClient } from "@scalekit-sdk/node";
import { createReactAgent } from "@langchain/langgraph/prebuilt";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

// Rootly tools scoped to this user
const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["rootly"], toolNames: [
    "rootly_list_oncalls",
    "rootly_create_incident",
    "rootly_create_incident_status_page_event"] },
  pageSize: 100,
});

const agent = createReactAgent({ llm, tools });
await agent.invoke({ messages: [{ role: "user", content: "Create a SEV1 incident for the payments outage and post it on the status page" }] });
import OpenAI from "openai";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const openai = new OpenAI();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["rootly"] }, pageSize: 100,
});

const res = await openai.chat.completions.create({
  model: "gpt-5",
  messages: [{ role: "user", content: "Create a SEV1 incident for the payments outage and post it on the status page" }],
  tools,
});

// Execute the tool call with the user's vaulted Rootly access token
await sk.tools.executeTool(res.choices[0].message.tool_calls[0], "user_123");
import Anthropic from "@anthropic-ai/sdk";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const anthropic = new Anthropic();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["rootly"] }, pageSize: 100,
});

const msg = await anthropic.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Create a SEV1 incident for the payments outage and post it on the status page" }],
  tools,
});

// Tool call runs with the user's vaulted Rootly access token
await sk.tools.executeTool(msg.content, "user_123");
import { Agent } from "@google/adk/agents";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["rootly"] }, pageSize: 100,
});

const agent = new Agent({
  name: "incident_agent",
  model: "gemini-2.5-pro",
  instruction: "Rootly tools scoped to this user",
  tools,
});

await agent.run("Create a SEV1 incident for the payments outage and post it on the status page");
Try these prompts
Copy any prompt into your agent. Each maps directly to a Rootly tool. Click to copy, paste into your agent, done.
Incidents
Copy the prompt
Copied
Create a SEV1 incident for the payments outage.
Copy the prompt
Copied
Mitigate the checkout incident and add a timeline event.
Copy the prompt
Copied
Assign Priya as commander on the payments incident.
Alerts and on-call
Copy the prompt
Copied
Acknowledge the latest alert for the API service.
Copy the prompt
Copied
Who is on call this weekend?
Copy the prompt
Copied
Add an override shift for Dana tonight from 6pm to midnight.
Follow-through
Copy the prompt
Copied
List open action items from last week's incidents.
Copy the prompt
Copied
Update the payments retrospective with the root cause.
Copy the prompt
Copied
Post a status page update that the payments fix is deployed.
SEE HOW AUTH WORKS
Each user connects their own Rootly access token once, and Scalekit sends it with every call. Tokens stay vaulted, every call is scope checked, and every action is logged.
1
Authorize
Your user connects
Rootly
once. We tie it to their identity and the meetings they approved — no shared bot account, no org-wide access
Who:
user ‘A’
when:
Once per user
access:
Limited to user
2
Store
Their
Rootly
token lives in a vault scoped to them. User A's meetings are never reachable by an agent acting for user B, even on the same connection
vault:
encrypted
scope:
per-user
tokens:
auto-refreshed
3
Resolve
When your agent calls a
Rootly
tool, we fetch the right token server-side. It never touches your agent, never appears in the LLM context, never shows up in your logs
speed:
~40ms
check:
before every call
seen by:
nobody
4
Audit
Every
Rootly
tool call is logged — who triggered it, which meeting was fetched, what came back. 90 days of history, tied to the user who authorized it
history:
90 days
export:
SIEM-ready
logged:
every call
Test other agents
See the same per-user auth pattern across other monitoring and developer tools connectors.
Engineering Teams
DevOps assistant agent
Polls GitHub for failing checks and stale PRs, opens Linear issues for the ones that need work, and posts a daily digest to Slack. It acts as the engineer, not a shared service account.
Engineering Teams
Slack triage
Polls Slack for new messages, classifies bugs and support requests with a LangGraph router, files GitHub issues or Zendesk tickets, and confirms in the thread.
Test other agents
See the same per-user auth pattern across other monitoring and developer tools connectors.
ENGINEERING
DevOps assistant agent
Poll GitHub for failing checks and stale pull requests, open Linear issues for the ones that need work, and digest to Slack.
ENGINEERING
Slack triage agent
Classify new Slack messages as bugs or support requests, file the GitHub issue or Zendesk ticket, and reply in the thread.
Why Scalekit
Secure your agent's access. Connectors ship in minutes
01.
Shared tokens break per-user analytics
A shared Rootly access token looks fine in a demo. In production every incident update and alert acknowledgement looks like one service account, and you cannot tell which user triggered it. Scalekit resolves the credential of the actual user who triggered the agent, never a shared bot.
// shared token
audit → bot_service_account

// scalekit
audit → user_abc ✓
02.
Authentication is not authorization
03.
Multi-tenancy is architectural
04.
Rootly today. Ten connectors tomorrow.
“Our agents act across Salesforce, Gong, Google Drive, and more, on behalf of every customer. Scalekit behind the scenes meant we can keep adding tools without ever rebuilding how credentials or tool calling work.”
Venu Madhav Kattagoni
Head of Engineering / Von
FAQs
Frequently Asked Questions
Does the agent access Rootly as the user or through a shared token?
As the user. Each user connects their own Rootly access token once, and Scalekit sends it with every call. Audit logs attribute every incident change and alert action to that user, not a shared service account.
Where is the Rootly access token stored?
In Scalekit's managed AES-256 token vault, namespaced per tenant. To rotate it, the user reconnects with a new access token. Revocation is a single dashboard action. Credentials never appear in prompts, logs, or LLM context.
Can I limit what the agent does in Rootly?
Yes. Filter by tool name in listScopedTools to expose only what you want, for example the read tools without rootly_delete_incident or rootly_escalate_alert. Scalekit also enforces scope checks before every API call.
What happens when a user revokes Rootly access?
The connection is invalidated on the next tool call. Subsequent requests for that user fail closed with a clear error. Other users in the tenant remain unaffected. The event is logged for audit.
What can the agent do with Rootly alerts?
List and read alerts and alert groups, create alerts, and acknowledge, snooze, escalate, or resolve them with rootly_acknowledge_alert, rootly_snooze_alert, rootly_escalate_alert, and rootly_resolve_alert. Alert routes, sources, and urgencies are readable for context.
Start in your coding agent
Up and running in one command
Install the Scalekit skill in your editor of choice. Connector, auth, tools, prompt, all wired up
Claude Code REPL
/plugin marketplace add scalekit-inc/claude-code-authstack
/plugin install agentkit@scalekit-auth-stack
Cursor Code REPL
# ~/.cursor/mcp.json
{
""mcpServers"": {
""rootly"": {
""url"": ""https://mcp.scalekit.com/rootly"",
""headers"": { ""Authorization"": ""Bearer $SCALEKIT_TOKEN"" }
}
}
}
Codex Code REPL
# ~/.codex/config.toml
[mcp_servers.rootly]
url = ""https://mcp.scalekit.com/rootly""
auth_env = ""SCALEKIT_TOKEN""
Copilot Code REPL
# .vscode/mcp.json
{
""servers"": {
""rootly"": {
""url"": ""https://mcp.scalekit.com/rootly"",
""type"": ""http""
}
}
}