MCP integration

Grove embeds an MCP server that gives agents a real tool surface for the product: the comment review loop, walkthrough authoring, workspace lifecycle, agent-to-agent messaging, vault notes, live diffs and directives, and precise code navigation. Any MCP-aware agent — Claude Code, Codex, opencode, or your own — gets these tools automatically when Grove launches it.

How agents connect

Grove writes the right config for whichever agent you launch — Claude Code, Codex, and opencode each get their own format — at chat launch, so only the agents you actually use get config files.
Each workspace's endpoint is scoped to that workspace, so tools default to the right place without the agent having to say which workspace it means. Agents only pass a workspace id explicitly to reach across workspaces.
The server is local-only: bound to your machine, same trust model as your shell. Nothing is exposed to the network.

Chats at the repo root (the project chat) get the same tool surface with paths resolved against the project itself.

The tool surface

Comments — the review loop

Tool	Purpose
`comments_list_pending`	The agent's inbox — unresolved comments only
`comments_list_all`	Full history, including resolved
`comments_create`	Drop a comment on a file and line
`comments_reply`	Append a reply to a thread
`comments_resolve`	Mark resolved

See Comments for the protocol these implement.

Walkthroughs

Tool	Purpose
`walkthrough_create`	Multi-step guided explanation, each step pinned to a line
`walkthrough_list`	List walkthroughs and their steps

See Walkthroughs.

Workspaces and agents

Tool	Purpose
`workspace_get`	Workspace metadata: name, branch, base, status, paths
`workspace_list`	Every workspace in the project
`workspace_create`	New workspace and worktree off the base branch; an initial plan becomes its `plan.md`

Agents can spawn workspaces — an agent planning a refactor can split it into parallel workspaces, each with its own worktree.

Chats — agents talking to each other

Grove runs one agent per chat, each in its own workspace and worktree. These let an agent address the others, so an orchestrating agent can hand work out across the pane grid and check back on it. If you know tmux, they map onto list-panes, send-keys, and capture-pane.

Tool	Purpose
`chat_list`	Every chat in the vault: its id, workspace, agent, and whether it's running right now
`chat_send`	Deliver a message to another chat's agent, as if typed at its prompt — opening and starting that chat if it isn't running
`chat_read`	Read what's on a running chat's screen

Delegating this way is the durable, visible alternative to spawning a subagent inside your own session: the peer is a real chat the user can watch and take over, with its own worktree and history that survive a restart.

Two limits are deliberate and worth designing around:

chat_send returns when the message reaches the peer's prompt, not when the peer replies. There's no reply channel, so an agent that needs an answer should tell the peer — in the message — to write its result to a note or a comment, and read that back.
chat_read returns the visible screen, not history. Agent CLIs run full-screen, which keeps no scrollback, so the line count caps what comes back rather than reaching further back in time. What you get is the rendered interface — boxes, spinners, the input line — so treat it as a status probe, not a transcript.

See Chats and terminals for the feature, and grove chat for the shell equivalents.

Notes

Tool	Purpose
`note_list`	List the workspace's notes (subfolders included)
`note_read`	Read a note by name or path
`note_write`	Create or overwrite a note — it appears live in the sidebar
`note_delete`	Delete a note

Directives

Tool	Purpose
`directives_reference`	Returns the `:grove-*` directive catalog, so an agent can author live note panels correctly. See Directives.

IDE control

Tool	Purpose
`open_file_in_grove`	Open a file in the editor, optionally jumping to a line
`read_file_lines`	Read a file with line numbers attached — exact coordinates for comments and navigation

Code structure and knowledge

Tool	Purpose
`document_symbols`	Outline of named symbols in source order
`symbol_at`	The enclosing chain at a line — e.g. `class Foo → method bar`
`anchors_in_scope`	Vault knowledge anchored to a file: every note that references it, relocated to current line numbers. See Wikilinks.

Tool	Purpose
`find_references`	All usages of the symbol at a line — plus any vault notes anchored to the results
`goto_definition`	Definition site — across crates, node_modules, stdlib
`goto_implementation`	Concrete implementations of an interface or trait
`hover`	Type signature and docs

Languages: Rust, TS/JS, Python, Go. See Language intelligence.

What the MCP deliberately does not do

Agents already have shell access, file editing, and search. Grove doesn't duplicate those. The tools earn their keep where the shell can't:

Structured results — a durable comment inbox, validated paths, atomic writes.
Editor integration — an agent writes a note and your sidebar updates live.
Cross-workspace addressing — operating on another workspace's notes or comments without cd.

Plain file reads, search, git operations: agents use their own tools.

Known gaps

Agents can author walkthroughs but not retract them.
Agents can create workspaces but not archive or delete them.
An agent can create a workspace, but can't yet start a chat in one — chat_send reaches chats that already exist.
Nothing prevents a message loop: two agents told to message each other will keep going until one stops.