LanesLanes
Docs/Desktop/Integrations/Lanes Desktop MCP

Lanes Desktop MCP

Run Lanes Desktop MCP, a server on your machine, so Claude Code, Codex, and other agents can read your board and drive sessions.

Lanes ships Lanes Desktop MCP, a server built into the app, so agents like Claude Code and Codex can connect directly to your workspace. Once enabled, an agent can read your issues, create or update them, and start sessions on your behalf, all from a chat prompt. It is currently available as a research preview on desktop.

Enabling Lanes Desktop MCP

Open Lanes, go to Settings, then Local MCP, and toggle it on. The server starts on port 5353 and exposes an SSE endpoint at http://localhost:5353/sse.

Everything runs locally on your machine.

Connecting an Agent

From the same Settings panel, one-click buttons connect supported agents:

  • Claude Code: writes the lanes-desktop entry into ~/.claude.json.
  • Codex: writes the lanes-desktop entry into your Codex config.

After clicking the button, restart your agent. Lanes will show up as an MCP server named lanes-desktop alongside any others you already have configured. There is no JSON to edit by hand.

If you use a different agent that supports MCP, point it at http://localhost:5353/sse manually using whatever connection format your agent expects.

Prefer the terminal? With the server enabled, Claude Code can add the same entry in one command:

Bash
claude mcp add --transport sse lanes-desktop http://localhost:5353/sse

Upgrading From an Older Name

The local server used to register as lanes-local, and before that as plain lanes. If you connected an agent under either name, do nothing. Both keep working, and Lanes will not rename anything in your config unless you ask it to.

Renaming is opt-in because an MCP server's config name is also the prefix on its tool names. Changing it moves every tool from mcp__lanes-local__* to mcp__lanes-desktop__*, which would reset your approvals and break anything that refers to the server by its old name.

When you do want the new name, open Settings, then Local MCP. A notice appears for each agent still on an older name, with a button that renames the entry for you. For lanes-local that also rewrites your mcp__lanes-local__* permissions in ~/.claude.json and ~/.claude/settings.json, so tools you had already approved stay approved. Restart the agent afterwards to pick up the new name. Removing and re-adding the connection by hand works too, and gets the new name automatically.

Plain lanes is a special case, because the hosted Lanes MCP uses that name. Renaming it frees lanes for the remote, and connecting the remote server performs the same rename since it needs the name back. Permissions are not carried over in this case: an mcp__lanes__* grant is ambiguous between the two servers, so Lanes leaves it alone and you re-approve when prompted.

One thing Lanes cannot reach either way: permissions granted in a project's own .claude/settings.local.json. Those live in your repos rather than your home directory. Update any mcp__lanes-local__* entries there yourself, or just re-approve the tools when prompted.

What the Server Exposes

The server provides the full surface you would expect from a workspace agent.

Issues

List, search, create, update, move, and delete issues. You can filter by column, label, component, or free text. Helper tools let the agent resolve labels and components by name to the right UUIDs before tagging, so the agent does not need to hard-code IDs.

Sessions

Start a Claude Code, Codex, or shell session against any issue. Sessions can be launched in plan mode, started with a custom prompt, given extra CLI flags or environment variables, and optionally tied to a freshly-created git worktree so they run in isolation. Sessions can also be stopped, and the agent can check status across every running session at once.

History and progress

Pull the message history of a past or current session, fetch session statistics, and read the live terminal scrollback. This lets the agent answer "how is this issue going" without you describing the state by hand.

External issue trackers

Once you connect GitHub or Linear inside Lanes settings, the same MCP server exposes their issues to the agent too. Read, search, create, and comment on GitHub and Linear issues without leaving the chat — and pair those calls with lanes_create_issue to import a ticket, work on it locally, and post the result back upstream. Tokens stay on disk in integrations.json; the agent never sees them. See GitHub Integration and Linear Integration for the connect flow.

Server Details

For MCP registries, indexers, and clients connecting manually:

  • Server name: lanes-desktop (older installs registered as lanes-local or lanes; both still work, see Upgrading From an Older Name)
  • Transport: SSE (Server-Sent Events)
  • Endpoint: http://localhost:5353/sse
  • Protocol version: 2024-11-05
  • Server version: 1.0.0
  • Tool count: 30 (18 workspace + 6 GitHub + 6 Linear)
  • Install: Open Lanes → Settings → Local MCP → toggle on. Use Connect Claude Code or Connect Codex for one-click config injection, or point any MCP-capable client at the endpoint above.
  • Source: Built into the Lanes desktop app — no separate package to install.

Tool Reference

The complete list of lanes_* tools, their parameters, and live descriptions tracks the server's tools/list response. Rather than duplicate them here, the canonical sources are:

  • Source and full reference: github.com/lanes-sh/app documents every workspace, GitHub, and Linear tool, kept in sync with each release.
  • Live discovery: any MCP-capable client can call tools/list against http://localhost:5353/sse to enumerate the current surface with full JSON schemas.

Claude Code plugin

For Claude Code users, the bundled lanes-desktop plugin ships three skills that wrap these tools with workflow guidance, plus a setup command, so you rarely call them by hand:

  • lanes-sessions: end-to-end usage, UUID gotchas, the multi-session model, common workflows, anti-patterns.
  • github-lanes-bridge: import GitHub issues, run them locally, post results back.
  • linear-lanes-bridge: the same loop for Linear, including sprint imports and issue decomposition.
  • /lanes:setup-mcp: slash command for one-shot setup of the Lanes Desktop MCP connection.

Install the lanes-desktop plugin from the Claude Code marketplace, then just mention Lanes in chat and the right skill loads automatically.

Example Prompts

A few prompts that work today:

  • "What's on my plate in Lanes?" List and triage issues from chat.
  • "Create an issue in Lanes for the login bug, tag it with frontend." Capture work without leaving your agent.
  • "Start a Lanes session on issue 12 in plan mode." Launch an isolated worktree session with the right flags.
  • "How's issue 8 going?" Pull session history, terminal output, and progress without switching windows.
  • "Move every done issue from this week into archive." Bulk board hygiene in one line.
  • "Import GitHub issue lanes-sh/core#42 into Lanes and start a session on it in a fresh worktree." Cross-system pipe in one prompt.
  • "Find the Linear issue ENG-321, work on it locally, and post a comment back on it linking to the PR when you're done." Round-trip a Linear ticket without leaving chat.

The most interesting workflows are chains: an agent that reads your backlog, picks the next ticket based on labels, starts a session in a worktree, then reports back when it gets blocked. With GitHub and Linear connected, those chains can also start (and finish) on the team's source of truth, not just the local board.

Research Preview

Lanes Desktop MCP is shipping as a research preview. The tool surface is stable enough to build on, but expect it to evolve as we learn how people use it. If something feels missing or wrong, that is the kind of feedback we want right now. Share workflows or ideas in our Discord.