Rootly MCP server: 252 tools, and their cost

The largest tool list measured in this guide, what it costs before the agent asks anything, and how to cut it down.

Last verified 1 September 2026 · from Rootly's repository, PyPI, its documentation and the server's own tools/list response

This page is one of 90 in a directory of monitoring and developer tools. Each page checks what an AI coding agent can get out of the tool through its MCP server, the connector that lets the agent query the tool directly.

What is the Rootly MCP server?

It is Rootly's server for the Model Context Protocol. Rootly is an incident management platform, so a connected agent reaches incidents, alerts, escalation paths, on-call schedules and retrospectives.

Most of the 252 tools are generated from Rootly's REST API: list_, get_, create_, update_ and patch_ variants for each resource type. A handful are hand-written for agents, including find_related_incidents and suggest_solutions, which use similarity analysis over resolved incidents.

The generated shape explains both the count and the cost. Each tool inherits the full request schema of the endpoint behind it, which is why schemas run to 2,143 characters while descriptions stay near 80.

Rootly sits in production observability, reaches nothing in code review or CI, and exposes no agent telemetry or spend data.

For an agent, that means Rootly answers questions about incidents and the people who respond to them. It knows what broke, who was paged and what was decided afterwards. It does not know what the code does or what the service is emitting, so this connector pairs with a telemetry one.

What can an AI agent do with Rootly?

Start with list_endpoints. It returns the Rootly API endpoints the server can reach, which is how an agent narrows 252 tools to the few that matter for a question.

What connecting costs before the first question

A context window is the amount of text a model can hold at once, and connecting uses some of it before the agent asks anything. Every tool the server registers sends its name, description and input schema to the model when the session starts. The tool list is charged whether or not a single tool is called.

252 tools cost between 127,149 and 245,805 tokens. At the high end that is more than a 200,000-token window holds, so the tool list alone does not fit.

The schemas carry it. Descriptions average 80 characters, among the shortest measured here, while input schemas average 2,143 characters because each one mirrors a REST endpoint's full request body.

Encodings: GPT-5.6, GPT-5.5 o200k_base; GPT-4, GPT-3.5 cl100k_base; Claude Haiku 4.5 to Opus 5 count_tokens. Counted 24 August 2026 from tools/list on the released PyPI package 2.3.17, run locally with a placeholder token.

Registration is static, so no Rootly account was involved. Figures cover name, description and input schema. The two models in column one share the o200k_base encoding, so they get one count. The two GPT columns differ by about 81%, because clients serialize the same 252 definitions differently. Reasoning tokens are output, spent per request. The tool list is input, charged once at connection.

The Claude figures are measured rather than encoded. Anthropic publishes no local tokenizer, so the definitions were sent to the API's count_tokens endpoint and a no-tools baseline subtracted. The range covers two tokenizer generations rather than two serializations. Haiku 4.5 and Opus 4.6 sit at the low end, Opus 5 and Sonnet 5 at the high end. The gap between them is about a third.

Rootly MCP server limits: where answers come back incomplete

Every limit below follows from the size of the tool list rather than from anything being broken.

How to configure Rootly MCP for agents

1. 1

   Decide whether the full list fits

   At 127,149 tokens on the low measurement, the definitions take most of a 200,000-token window before any work starts. A client that can filter the tool list is the difference between usable and not.

2. 2

   Start the server with writes switched off

   --no-enable-write-tools, or ROOTLY_MCP_ENABLE_WRITE_TOOLS=false, restricts the server to read-only tools. Scope the API token as well.

3. 3

   Prefer the hosted endpoint for shared use

   mcp.rootly.com/mcp authenticates with OAuth2, so each person carries their own identity rather than sharing one token.

4. 4

   Know that one tool leaves Rootly

   check_oncall_health_risk reads On-Call Health at oncallhealth.ai, which is a separate service from the Rootly API.

Paste this into your agent’s instructions

Many of the 252 generated names differ by one word. An agent can call the wrong one, get nothing back, and report that nothing exists. The block makes it name the tool and the filter.

When you answer using Rootly MCP tools, state:
- The tool you called and the filters you passed. Many tool
  names differ by one word and return different resources.
- Whether the answer came from find_related_incidents or
  suggest_solutions. Both are similarity analysis, not records.
- Whether you called a create_ or update_ tool, and on what.
Never state that data does not exist. State that none was
returned under the filters above.
Write your answer in ASD-STE100 Simplified Technical
English. Use short sentences with one idea in each.

Do you need the MCP server at all?

Often, yes. Rootly has a documented REST API, and the 252 tools are largely generated from it. For a known lookup, a direct call avoids the whole context charge.

The connector earns its place on the two tools that are not generated. find_related_incidents and suggest_solutions run similarity analysis that the REST API does not expose as a single call.

The hosted endpoint is the third option, and the better one for a team, because OAuth2 keeps each person's identity rather than sharing one token.

Call the API directly for known lookups. Connect the server when the agent needs to reason across incident history.

Rootly MCP server setup

The package runs from PyPI and needs one Rootly API token. The server checks the token's length at startup and refuses to register tools if it is too short, so a dummy value will not get you a tool list.

There is also a hosted endpoint at mcp.rootly.com/mcp, which uses OAuth2 rather than a token in a config file.

claude mcp add-json "rootly" '{"command":"uvx",
  "args":["rootly-mcp-server"],
  "env":{"ROOTLY_API_TOKEN":"<your-token>"}}'

{"mcpServers":{"rootly":{"command":"uvx",
  "args":["rootly-mcp-server"],
  "env":{"ROOTLY_API_TOKEN":"<your-token>"}}}}

[mcp_servers.rootly]
command = "uvx"
args = ["rootly-mcp-server"]
env = { ROOTLY_API_TOKEN = "<your-token>" }

Every other client

Each block below is the configuration for one client, with the file path and the key that client expects.

{"mcpServers":{"rootly":{"command":"uvx",
  "args":["rootly-mcp-server"],
  "env":{"ROOTLY_API_TOKEN":"<your-token>"}}}}

{"mcpServers":{"rootly":{"command":"uvx",
  "args":["rootly-mcp-server"],
  "env":{"ROOTLY_API_TOKEN":"<your-token>"}}}}

{"servers":{"rootly":{"command":"uvx",
  "args":["rootly-mcp-server"],
  "env":{"ROOTLY_API_TOKEN":"<your-token>"}}}}

{"mcpServers":{"rootly":{"command":"uvx",
  "args":["rootly-mcp-server"],
  "env":{"ROOTLY_API_TOKEN":"<your-token>"}}}}

{"mcpServers":{"rootly":{
  "url":"https://mcp.rootly.com/mcp"}}}

Read-only access, permissions and security

• Read-only mode exists and is off by default

  All 252 tools register together, and 112 are named create_, update_ or patch_. --no-enable-write-tools restricts them; the API token's scope is the second line.

• One tool calls a service outside Rootly

  check_oncall_health_risk integrates with On-Call Health at oncallhealth.ai to find responders carrying elevated workload.

• The tool list is itself a disclosure

  Registering 252 tools sends every resource name Rootly holds to the model. That includes catalogs, teams and status pages you may not have meant to describe.

• Startup audit logging is on

  The server writes a JSON audit event at start naming the tool count, whether write tools are enabled and the transport in use.

Troubleshooting

The server exits at startup

The token failed a length check. The server logs "API token appears to be invalid (too short)" and stops before registering tools, so a placeholder value never reaches a tool list.

The agent runs out of context immediately

The tool definitions cost between 127,149 and 245,805 tokens. On a 200,000-token window the high measurement does not fit at all. Filter the tool list in the client, or connect Rootly only for incident work.

The agent calls the wrong tool

Tool names differ by one word across 252 entries, so list_incident_events and list_incident_alerts sit next to each other. Have the agent call list_endpoints first to narrow the surface.

Something changed that should not have

112 tools are named for writing and all of them arrive on by default. Start the server with --no-enable-write-tools, or set ROOTLY_MCP_ENABLE_WRITE_TOOLS=false, to restrict it to read-only tools.

Rootly MCP server: Reference

What engineers report

Public discussion of this connector is thin, so the useful signals are the repository, the package and the measurement.

“The README states read-only mode can be enabled either with --no-enable-write-tools or by setting ROOTLY_MCP_ENABLE_WRITE_TOOLS=false.”

“On a fresh install, the server writes a 1.4 to 2.8 MB swagger.json into the host process's current working directory on startup. For an MCP server, cwd is inherited from the client, so a copy lands in every project directory a user launches their client from.”

Repository facts from the GitHub API and PyPI, retrieved 24 August 2026. The repository now resolves to rootlyhq/rootly-mcp-server; older links to the Rootly AI Labs organization redirect there. Tool counts and sizes come from the server's own tools/list response on the released package.

Should you connect an agent to Rootly?

Yes. Best for short, scoped sessions on a client that can filter the tool list, rather than a permanent connection.

Strongest fit

Rootly teams whose agent works on incident history and can afford most of its context window for tools.

Main advantage

The widest incident-management surface measured here, plus two similarity tools the REST API does not offer.

Main weakness

The definitions cost 127,149 tokens at the low measurement and do not fit a 200,000-token window at the high one.

Operational risk

112 writing tools arrive on by default, so read-only mode has to be switched on deliberately with --no-enable-write-tools.

Frequently asked questions