MCP server

Otis runs a remote MCP server. MCP (Model Context Protocol) is the standard way coding agents connect to outside tools. Any coding agent that supports it can connect to Otis, read live project state, ask Otis about your product's usage, and use Otis's workflows and reference material directly.

The server has one address, which is the same for every team and project:

https://app.runotis.com/mcp

This page covers how to connect an agent to the server directly, and what the server provides.

If your agent supports Agent Skills, start with Coding agents instead. The Otis skills are built on this server and add step-by-step workflows, and the Claude Code and Codex plugins connect the server for you. Connect the server by hand when your agent doesn't support skills, or when you installed the skills with the skills CLI, which doesn't connect it.

Connect your agent

If you installed the Otis plugin for Claude Code or Codex, the server is already connected. Don't add it again, or your agent gets two copies of it.

Run this from the root of your repository:

claude mcp add --transport http otis https://app.runotis.com/mcp

The command adds the server for you alone, in this repository. Add --scope project to write it to .mcp.json, which you can commit so that your team shares it. Add --scope user to use the server in every repository on your machine.

Then start Claude Code and run /mcp to sign in.

Add the server with the Codex CLI:

codex mcp add otis --url https://app.runotis.com/mcp

Codex opens a browser window for you to sign in. The command adds the server to your Codex configuration for every project on your machine.

Open this link on the machine where Cursor is installed: Add Otis to Cursor. Cursor opens and asks you to confirm the new server.

To add the server by hand, put this in .cursor/mcp.json in your repository. Use ~/.cursor/mcp.json instead to add it for every repository on your machine.

{
  "mcpServers": {
    "otis": {
      "url": "https://app.runotis.com/mcp"
    }
  }
}

Cursor asks you to sign in the first time it connects.

GitHub Copilot in VS Code uses the MCP servers that VS Code knows about. Add the server with the VS Code command line:

code --add-mcp '{"name":"otis","type":"http","url":"https://app.runotis.com/mcp"}'

The command adds the server to your VS Code user profile. To share the server with your team instead, put this in .vscode/mcp.json in your repository:

{
  "servers": {
    "otis": {
      "type": "http",
      "url": "https://app.runotis.com/mcp"
    }
  }
}

VS Code asks you to sign in the first time it starts the server.

Run this from the root of your repository:

gemini mcp add --transport http otis https://app.runotis.com/mcp

The command adds the server to .gemini/settings.json in the current directory. Add --scope user to use the server in every project on your machine.

Then start Gemini CLI and run /mcp auth otis to sign in.

Any client that supports remote MCP servers and OAuth sign-in can connect. Add the address to your client's MCP configuration. Most clients accept this shape:

{
  "mcpServers": {
    "otis": {
      "url": "https://app.runotis.com/mcp"
    }
  }
}

Check your client's documentation for the file location and field names.

The first time your agent connects, it opens a browser window for you to sign in. Use the account you use for the Otis app. There are no API keys to create, and no secrets are written to your repository.

If you belong to more than one Otis team, the sign-in page asks you to choose a team. The connection then works with that team's projects. To work with another team, sign in again and choose it.

Choose a project

A connection can work with every project in your team that you have access to. How your agent chooses one depends on how many projects the team has:

Your team has one project. Your agent uses that project. There is nothing to choose.
Your team has several projects. Each tool that works on a project takes an optional project argument, which is the project's slug. Your agent finds the slug with the listProjects tool. That tool returns each project with the GitHub repositories linked to it, so your agent can pick the project whose repository matches the one it is working in.

You can also name the project in your request, for example "ask Otis about the checkout project". The slug is the last part of the project's address in the Otis app: https://app.runotis.com/<team-slug>/<project-slug>.

If a tool needs a project and your agent does not give one, the tool replies with the projects to choose from. Your agent can then call the tool again with the right one.

A few clients do not ask you to choose a team when you sign in. If you belong to several teams and use one of these clients, name the project with its team, as <team-slug>/<project-slug>.

Pin a connection to one project

To tie a connection to a single project, add the team slug and the project slug to the address:

https://app.runotis.com/mcp/<team-slug>/<project-slug>

A pinned connection always uses that project, whichever team you choose when you sign in. It refuses a project argument that names a different project. Pinning is useful when a repository belongs to one Otis project and you commit the MCP configuration for your team to share.

What the MCP server exposes

Three kinds of MCP surface, available to any connected agent:

Tools — consult Otis, read/write project state, manage ingestion, and read workflows and reference docs:

Tool	What it does
`askOtis`	Ask Otis — your project's product-intelligence agent — about usage, user behavior, metrics, or surfaced insights, and get back a distilled answer plus a link to the Otis app. This is what the `otis` skill calls; see Ask Otis about your product below.
`getOtisAnswer`	Collect the answer to an `askOtis` question that Otis was still working on when the call returned
`getProjectMemories`	Read codebase profile, per-measurement state, declared span mappings
`searchProjectMemories`	Semantic search across your Otis project
`saveProjectMemory`	Write profile, measurement state, or span mappings back
`removeProjectMemory`	Delete an entry
`getIngestionHealth`	Check whether spans are arriving from prod or dev in the last 24 hours
`createIngestApiKey`	Create an ingest API key for the Otis SDK (returned once — store it immediately). Admin only; `development` keys ingest without analytics, `production` keys enable full analytics
`getOtisWorkflow`	Get the step-by-step instructions for an Otis workflow: `analyze`, `instrument`, `verify`, `status`, or `consult` (when and how to ask Otis). See Workflows without the skills.
`searchOtisDocs`	Search the reference docs: the SDK reference, the Insights pages, the integration guide, and the page for each measurement
`readOtisDoc`	Read one reference doc, or one section of it, as markdown
`listProjects`	List the Otis projects you can use, with the GitHub repositories linked to each

askOtis, getIngestionHealth, createIngestApiKey, and the four project memory tools take the optional project argument described in Choose a project.

Prompts — dynamic project context:

Prompt	Contents
`lens-catalog`	The list of measurements available to your project, with active ones marked. It takes the same optional `project` argument.

Resources — reference material:

Resource	Contents
`otis://integration-guide`	SDK installation and configuration
`otis://sdk/{slug}`	SDK reference pages (tracing, nextjs, feedback, identity, serverless, etc.)
`otis://insights/{slug}`	Insights pages, which explain how Otis works (tasks, sessions, signals, segments, funnels, etc.)
`otis://memory-taxonomy`	Conventions for writing back to your Otis project
`otis://lens-parameter-schema/{lensId}`	Parameter schema for a lens

The same material is available through the searchOtisDocs and readOtisDoc tools.

Ask Otis about your product

Beyond reading project state, the MCP server lets your agent consult Otis directly through the askOtis tool. Otis is the product-intelligence agent for your project — it holds the telemetry-derived insights, analytics, knowledge base, and project memory your coding agent doesn't, and runs its own (read-only) tools server-side to answer.

Ask it anything about how your product is actually used:

"What are users struggling with this week?"
"Why are people dropping off in onboarding?"
"What do we know about our power users?"

Otis replies with a distilled, terminal-friendly answer plus a deep link to the full view in the Otis app (charts and evidence).

With the Otis skills installed, this is the otis skill. You don't have to name it: your agent recognizes a product-usage question and uses the skill on its own. Agents without the skill call the askOtis tool directly; the skill is a convenience wrapper around it.

A few things worth knowing:

Be specific — include the timeframe, segment, or metric ("…in the last 14 days", "…for self-serve signups") for a sharper answer.
Discuss a specific insight by passing its insightId (the id in the insight's link in the Otis app, …/insights/<id>).
Continue a thread by passing the conversationId Otis returns on the previous call; omit it to start a fresh topic. MCP conversations also appear in the Otis app.
Read-only — over this path Otis analyzes and recalls; it won't save memories or change project state.

Workflows without the skills

The Otis skills give your agent step-by-step workflows: analyze the codebase, add instrumentation, verify it, and check status. The MCP server serves the same workflows through the getOtisWorkflow tool, so any connected agent can follow them, whether or not it supports Agent Skills.

If your agent doesn't support skills, ask it to fetch a workflow and follow it. For example: "Get the Otis instrument workflow with getOtisWorkflow and follow it." Each workflow tells your agent which tools and reference docs to use at each step.

Auth for clients that don't support MCP OAuth

API key auth for MCP isn't offered today. If your agent requires a different auth scheme and OAuth isn't an option, contact us.

The MCP server and the skills

The skills and a directly connected agent use the same server and the same project state. You can instrument your app with the skills in one agent and check its status from another agent that is connected to the server alone.

Coding agents covers the skills: how to install them, what each one does, and how they stay current. Agent skills in the SDK section covers the instrumentation steps in detail.

MCP server

On this page