Let any coding agent drive your editor

What is MCP?

The Model Context Protocol is an open standard for connecting AI agents to tools and data, so every agent doesn’t need a bespoke integration with every tool. It defines exactly two transports: stdio, for tools an agent launches as a subprocess, and Streamable HTTP, for tools that are already running, like an editor with your files open in it.

Incise serves Streamable HTTP, which is the transport essentially every coding agent supports. That’s the whole reason one endpoint covers all of them.

Incise follows the current MCP specification, revision 2026-07-28 (what changed), and still accepts the earlier 2025-11-25 and 2025-06-18 revisions that most agents speak today.

What your agent can do

openFile

Open a file, optionally selecting a line range, or with the rendered preview showing for Markdown and HTML (preview: true). This is how an agent shows you what it's talking about.

getCurrentSelection

The active editor's selection (or just the caret), with the file path.

getOpenEditors

Every open tab, which is active, and which have unsaved changes.

getWorkspaceFolders

The folder open in the file tree: an agent's idea of “the project”.

openDiff

Show proposed changes as a side-by-side diff you accept or reject in the editor.

closeAllDiffTabs / close_tab

Close a proposed-change diff again.

showDiff / closeDiff

Show a read-only diff of one or more files, with no Accept or Reject, and close it again. It waits behind a proposed change or your own Compare with Saved rather than replacing them. Homebrew build, 1.16.0 or later.

getDiagnostics

Reserved for errors and warnings. Incise has no linter wired to it yet, so it currently reports none.

What it looks like in practice

You never call these tools yourself. You keep talking to your agent the way you already do. The difference is what it can see, and where its output arrives.

• Select a function in Incise and ask your agent to “explain this”. You don’t paste the code or name the file: it reads the selection from the editor.
• Ask where something is defined and the file opens in an Incise tab with the right lines already selected, instead of a path printed in your terminal.
• When the agent wants to change a file, a diff pane opens inside the Incise window with Accept and Reject buttons, and it waits for you. Accept and it applies the change; reject and it adapts.

Using Claude Code? It connects through its own integration instead, which works a little differently; see the Claude Code page.

Turning it on

MCP needs Incise 1.12.15 or later.

1. In Incise, choose View ▸ Enable Agent Integration (MCP).
2. Open Settings ▸ Agents (⌘,). It shows the endpoint URL and a config snippet for each agent, with your token already in it.
3. Pick your agent, click Copy, and paste it where that agent keeps its MCP servers; the pane names the file.

Or let the agent do it. If that config file already exists and has other servers in it, merging by hand is the fiddly part. Click Copy Setup Prompt instead and paste the result into the agent itself: it edits its own config, merging the Incise entry in without disturbing what’s already there, and creating the file if it’s missing. Requires 1.12.16 or later.

Copying from Settings is easier than the samples below, because the token is filled in for you. The samples are here so you can see what you’re agreeing to before you install anything.

Setup by agent

Using Claude Code? Skip this and connect with /ide instead. Here’s why.

{
  "mcpServers": {
    "incise": {
      "serverUrl": "http://127.0.0.1:3845/mcp",
      "headers": { "Authorization": "Bearer YOUR_TOKEN" }
    }
  }
}

grok mcp add --transport http incise \
  http://127.0.0.1:3845/mcp \
  -H "Authorization: Bearer YOUR_TOKEN"

[mcp_servers.incise]
url = "http://127.0.0.1:3845/mcp"
http_headers = { "Authorization" = "Bearer YOUR_TOKEN" }

{
  "servers": {
    "incise": {
      "type": "http",
      "url": "http://127.0.0.1:3845/mcp",
      "headers": { "Authorization": "Bearer YOUR_TOKEN" }
    }
  }
}

{
  "mcpServers": {
    "incise": {
      "url": "http://127.0.0.1:3845/mcp",
      "headers": { "Authorization": "Bearer YOUR_TOKEN" }
    }
  }
}

Two things worth knowing, both learned the hard way. Antigravity requires serverUrl and rejects the url / httpUrl spellings other clients use, so a snippet copied from one of them fails silently. And its CLI (agy) reads the user-level ~/.gemini/config/mcp_config.json; a project-level .agents/mcp_config.json was not picked up in testing.

Grok Build’s grok mcp add is add-or-update, so it’s safe to re-run after regenerating the token, and grok mcp doctor then verifies the connection end to end, which a config file alone never proves. A session started before the server was added won’t see the tools; new sessions pick them up automatically.

Claude Code: use /ide instead

Claude Code has a dedicated integration, Incise as your Claude Code editor (/ide), and it’s the better way in. Over /ide, Claude Code attaches the file you’re editing and your selection to every prompt without being asked. When it wants to change a file, it opens the diff in Incise as part of its own permission step, so Accept or Reject there answers the prompt.

Over this endpoint, the same tools are ordinary tools: Claude calls them only if it decides to, and a diff it opens isn’t tied to its permission flow. Don’t connect Claude Code both ways. It sees two copies of every tool, and it can open diffs outside the permission step that /ide already manages.

The one thing /ide doesn’t give you is opening a file on request: Claude Code keeps Incise’s open-file action to itself. When you want a file on screen, ask Claude to run open -a Incise path/to/file.

With several agents connected, a diff proposed while another is on screen waits its turn: you review them one at a time, and each agent gets your own answer.

How it’s kept safe

• Off until you turn it on. No port is opened before that, and turning it off closes it immediately.
• Local only. The listener binds to 127.0.0.1, never to a public interface, so nothing off your Mac can reach it.
• Token on every request. A token unique to your install is required; anything without it is refused. Regenerate it whenever you like. That invalidates every client until you re-paste the config.
• A discovery file only you can read. In the Homebrew build (1.16.0 or later), while the endpoint is on, Incise writes its address and token to ~/Library/Application Support/Incise/mcp-endpoint.json, readable only by your account, so a local app can connect without you copying them. Turning the endpoint off, or quitting, removes it. It holds nothing your Incise preferences don’t already.
• Browsers can’t sneak in. Web pages can reach a local port, so requests carrying a foreign Origin are rejected outright.
• Nothing leaves your machine on Incise’s account. It makes no outbound connections. What your agent sends to its own model is that agent’s business, the same as when it reads files from disk.

Questions