Cursor + Steady

Cursor integration for Steady

Cursor is where a lot of engineering work actually happens — reading code, refactoring, shipping changes, talking to an agent about all of it. Connecting Steady’s MCP server pulls the human side of that work into the same surface: what the team is blocked on, which Goal Stories the diff in front of you maps to, what shipped yesterday, who’s out tomorrow.

The result is fewer trips out of the editor. Instead of switching to Steady to check on a goal, you ask Cursor’s chat. Instead of summarizing a stand-up by hand, you have Cursor pull the digest and frame it for you. Steady becomes one more piece of context Cursor reasons over, indistinguishable from your repo and your terminal.

Where it lands in your workflow

Editing with team context attached. While you’re inside a file, Cursor can pull the Goal Story it relates to, surface recent updates, and flag relevant check-ins from teammates touching the same area. Useful when you’re picking up someone else’s work, or revisiting a project after a break.

Reviewing and shipping. Before opening a PR, ask Cursor to compare the diff against what was promised in the relevant Goal Story update. Or generate a PR description that includes a short summary of the goal, the most recent updates, and the change itself.

Agentic and Background runs. Cursor’s longer-running agents can read Steady at the start of a task and write back at the end — fetch what the team committed to before kicking off, file a check-in or post a Goal Story update once the work is done. The MCP connection is available the same way it is in interactive chat.

Cross-tool reasoning. Cursor supports multiple MCP servers concurrently, so Steady plays nicely with whatever else you’ve registered — GitHub, Linear, Slack, Notion. Ask one question, get an answer that draws on the right pieces of all of them.

A note on Cursor mode coverage

Steady works the same way across Ask, Edit, Agent, Composer, and Background — there’s no separate setup per mode. Some prompts naturally fit one mode better than another (deep multi-step automations belong in Agent or Background; quick lookups are fine in Ask), but the connection itself is shared.

Installation

The Steady MCP server URL is https://app.steady.space/mcp.

The simplest path is to add Steady to your global config at ~/.cursor/mcp.json:

{
  "mcpServers": {
    "steady": {
      "url": "https://app.steady.space/mcp"
    }
  }
}

Or commit a workspace-level .cursor/mcp.json so the whole team picks it up when they open the repo. After the file is in place, restart Cursor (or reload the MCP servers from Settings → MCP) and complete the OAuth handshake the first time a tool is called. Step-by-step instructions live in the AI Assistants doc.

Security

The connection uses OAuth 2.1 and is scoped to your individual Steady account. Cursor stores the issued tokens locally; there’s no shared service account, no expanded permissions, and authentication is per-person on per-machine. A teammate adding Steady to their own Cursor doesn’t change anyone else’s access.

About Cursor

Cursor is the AI-first code editor that's become a daily driver for a lot of engineering teams. It treats the Model Context Protocol as a first-class extension point, which means Steady can sit alongside your repo, your terminal, and the rest of your tooling — available to Ask, Edit, Agent, and Background sessions without flipping out of the editor.

Frequently asked questions

How does Steady show up inside Cursor?

Once Steady is registered as an MCP server, its tools appear automatically to whatever Cursor mode you’re using — Ask, Edit, Agent, or Background. You can call it implicitly (“what did the team flag in this week’s check-ins?”) or explicitly via Cursor’s tool-mention UI. Either way, results land in the same chat surface you’re already using to read and write code.

Does this work with Agent and Background mode?

Yes. Long-running Cursor agents can read Steady context just like the foreground chat can, so a Background agent rewriting a service can first check what the team committed to in their Goal Stories, or a Composer pass can summarize the day’s blockers before suggesting next steps. Tool calls are scoped to the same OAuth session you authorized when you added the server.

Can my team share the Cursor config?

Yes. Drop the MCP entry into a workspace-level .cursor/mcp.json and check it into the repo, and every teammate who opens the project picks up Steady automatically. They each authenticate individually via OAuth on first use, so credentials are never shared — only the server registration is.

What's a useful first prompt to try?

Open a file you’re about to change and ask Cursor “what’s the latest on the goal this work belongs to?” Cursor pulls the matching Goal Story and recent updates from Steady, then reasons over the diff you’re about to ship in the same conversation. Or kick off a session with “give me today’s digest, then help me triage the issues mentioned in it.”

How is access controlled?

Cursor authenticates to Steady over OAuth 2.1 against your individual account, and the resulting tokens stay on your machine inside Cursor’s local config. There is no shared service account, and your teammates’ Cursor instances are completely independent — each person sees exactly what their Steady role allows.