Incise app iconInciseMCP · agents

Let any coding agent drive your editor

Coding agents are good at editing files and bad at knowing what you’re looking at. They work in a terminal while your cursor, your open tabs, and your project sit in another window they can’t see — so you end up narrating: the file I have open, around line 40, the bit I just selected.

Incise is an MCP server. Switch it on and your agent can read your selection, see which tabs are open, open a file to the right line, and show you a diff you accept or reject in the editor — over the Model Context Protocol, the open standard those agents already speak. It runs entirely on your Mac, and it’s free.

Download for macOS — free

Version 1.12.19macOS 13.0+MCP needs 1.12.15+

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.

What your agent can do

openFileOpen a file, optionally selecting a line range. This is how an agent shows you what it's talking about.
getCurrentSelectionThe active editor's selection (or just the caret), with the file path.
getOpenEditorsEvery open tab, which is active, and which have unsaved changes.
getWorkspaceFoldersThe folder open in the file tree — an agent's idea of “the project”.
openDiffShow proposed changes as a side-by-side diff you accept or reject in the editor.
closeAllDiffTabs / close_tabClose the diff view again.
getDiagnosticsReserved 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.

There’s a fuller walkthrough, including what surprises people the first time, on the Claude Code page — the workflow is the same whichever agent you use.

Turning it on

  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

Claude Code

Run in your terminal

claude mcp add --transport http incise \
  http://127.0.0.1:3845/mcp \
  --header "Authorization: Bearer YOUR_TOKEN"

Antigravity (CLI & IDE)

~/.gemini/config/mcp_config.json

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

Codex CLI

~/.codex/config.toml

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

VS Code

.vscode/mcp.json

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

Cursor

~/.cursor/mcp.json

{
  "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.

Claude Code: two ways in

Claude Code can use the MCP endpoint like any other agent, but it also has a dedicated integration — Incise as your Claude Code editor (/ide) — and one thing only that path does: the diff-approval flow. Claude Code calls openDiff from inside its own permission step, so accepting or rejecting the change in the editor replaces the terminal prompt entirely.

Over plain MCP, openDiff is an ordinary tool: an agent may call it, and you still accept or reject in the editor, but it isn’t wired into that agent’s permission flow. Everything else behaves the same on both paths.

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.
  • 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

What is MCP?

The Model Context Protocol is an open standard for connecting AI agents to tools and data. It defines two transports: stdio for local subprocesses, and Streamable HTTP for everything else. Incise implements Streamable HTTP, which is what nearly every coding agent speaks, so one endpoint works for all of them.

Which agents can drive Incise?

Anything that supports MCP over HTTP: Claude Code, Antigravity (CLI and IDE), Codex CLI, Cursor, VS Code, Zed, Cline, and others. Incise's Settings ▸ Agents pane generates the exact config each one expects, with the token already filled in.

Is my code sent anywhere?

No. The endpoint listens on 127.0.0.1 only, so nothing outside your Mac can reach it, and Incise makes no outbound connections of its own. Your agent decides what to send to its own model — that is between you and that agent, exactly as it is when it reads files from disk.

Does this work in the Mac App Store version?

Yes. Both the Mac App Store and the Homebrew/direct-download builds serve the MCP endpoint. The only Incise feature the sandboxed App Store build cannot include is the built-in terminal.

Do I need Claude Code's /ide integration too?

Only if you use Claude Code and want its diff-approval flow, where accepting an edit in the editor replaces the terminal prompt. That is specific to how Claude Code's permission flow calls openDiff. Everything else — opening files, reading your selection, listing tabs — works the same over MCP.

Is it on by default?

No. It is off until you enable it in the View menu, and it requires a bearer token unique to your install on every request. You can regenerate that token at any time from Settings ▸ Agents.

Or install via Homebrew
brew tap incise-app/tap
brew trust incise-app/tap
brew install --cask incise
incise.dev · © 2026