External MCP servers
MCP (Model Context Protocol) is an open protocol through which the agent is given additional tools: a code graph, searching through documentation, access to a tracker, database, whatever. Pulse connects MCP servers once in the settings, and then they are available to all selected agents in all tasks.
Settings → MCP.
Add server
| Field | What to write |
|---|---|
| Name | how the server will be signed in the agent prompt and in the call cards |
| Transport | stdio (the command is run locally) or http (server address) |
| Command/arguments/env | for stdio: what to run. {worktree} in arguments and variables is substituted using a working copy of the task |
| For which agents? | empty - for everyone; else a list (for example, only Claude Code) |
| Hint | the text that will be sent to the agent in the first turn: when and why to use this server |
Button "Check" starts the server, shakes hands and shows a list of tools - you can immediately see that the command is correct and the server is alive.
Transfer from Cursor, VS Code and Windsurf
Plugins → “Move from Cursor / VS Code” (or the link in the last step of the first run wizard). Pulse shows what it has found, with check marks, and does not transfer anything until you click “Move.” The result is “Moved N” and a list of what was not transferred, with the reason.
Where it looks - paths from the editors' documentation; they have not yet been tested on live machines of each system:
| Editor | File |
|---|---|
| Cursor | ~/.cursor/mcp.json; in the repository - .cursor/mcp.json |
| Windsurf | ~/.codeium/windsurf/mcp_config.json |
| VS Code | mcp.json and the key "mcp" in settings.json in the profile folder: ~/Library/Application Support/Code/User (macOS), %APPDATA%\Code\User (Windows), ~/.config/Code/User (Linux), the same for Insiders; in the repository - .vscode/mcp.json |
What and how is it transferred:
- Servers go down — like any new one: turn it on after “Check”.
- Keys (variables with names like
*_TOKEN,*_API_KEYand values similar to keys) are shown as a mask and, without the “move and keys” checkbox, remain in the editor - enter them yourself in “Edit”. A key written directly in a command or address cannot be separated: such a server is transferred only with it. In Pulse, MCP variables are stored in the settings as openly as in the editor config. - Not transferred: servers via SSE; HTTP server headers (if they contain authorization, the server will not accept the request);
envFile; substitutions${input:…}and${env:…}— enter the value yourself.${workspaceFolder}becomes{worktree}. - Project Rules —
.cursor/rules/*.mdc,.cursorrules,.windsurf/rules/*.md,.windsurfrules,.github/copilot-instructions.mdin connected repositories - collected inAGENTS.mdat the root of the repository: first the “always” rules, then by file, for each - when it is valid and where it was taken from. IfAGENTS.mdalready exists, it is not overwritten. The original files remain in place.
How does the agent see it?
- External ACP agents receive MCP servers in the parameters of the new session - they connect to them themselves, as if you had registered the server in their config.
- Built-in Pulse Agent connects stdio servers itself and gives their tools to the model as functions with names
mcp__<server>__<tool>. Calls are visible in the transcript and on the graph using regular cards; the output is trimmed to a reasonable size. - Server hints are collected in the “Connected MCP Servers” block and left as the first turn - so that the model knows what it has and does not invent its own.
If the server does not come up, an error will be sent to the transcript, and the session will continue to work without it.
Code memory
Ready preset - codebase-memory-mcp: tree-sitter code graph, symbol search, call tracing, impact assessment of edits.
- Install the server (instructions are in its repository; the binary is usually in
~/.local/bin). - In Pulse: Settings → MCP → preset “Code memory”. Argument
--repo {worktree}will insert a working copy of the task. - The default hint tells agents to “ask the code graph first, then read the files” - this significantly saves context on large repositories.
Indexing when creating a task
Until the graph is built, there is nothing to ask: the first agent of the task parsed the repository right inside his first turn, and the hint “ask the code graph first” did not result in a quick answer, but a pause for several minutes. Therefore, Pulse builds the graph itself.
As soon as the task has a working copy, the application raises the code memory server as a separate process, calling index_repository on this copy and extinguishes the process: there is no need to keep it until the first turn - the agents raise their copies themselves, and the graph remains in the server database. This does not delay the creation of a task; the work goes on in the background.
This can be seen in the task activity feed, with a line for each known state:
| Condition | What is written |
|---|---|
| analysis in progress | “Code memory: working copy, project “…” indexed” |
| the server replied that it was ready | “the index has been built, the project “…” - agents can ask for the graph” |
| no binary | “the server is not installed, there will be no indexing” with the reason from startup |
| there is a server, no tool | "the server does not have a tool index_repository"and a list of what he gave |
| analysis failed | “indexing error” and the first line of the server response |
The index is called ready only after the server responds - “running” and “ready” are not the same thing. Project name Pulse collects as pulse-<repository>-<task id> (each task has its own branch and its own working copy, the common graph for all would be a graph of someone else’s code), but if the server named the project in its own way, his name appears in the feed, not our wish.
Working copies of swarm members - not yet indexed
In a swarm, each developer works in his own copy on his own branch. In this case, only the working copy of the task is indexed, and exactly those who write the code do not have a graph: search_graph from the participant’s copy answers about someone else’s directory or does not answer at all.
This is a state of affairs, not a description of a possibility. The rule for who should be analyzed is written and verified in the code (indexTargets in src/main/mcp/indexWorktree.ts): each copy has its own project name pulse-<repository>-<task id>-<role>, because one name for all copies would mean a graph of someone else’s branch under its own name, and matching paths are collapsed so that one directory is not parsed twice. But it calls for indexing indexCodeMemory when creating a task - and calls it for one copy of the task; launching a swarm does not index copies of participants. As long as this fork is not connected, the written rule does not affect anything, and there is nothing to promise about it.
The connection price is known in advance and fair: there are several copies, the repository is the same, and it is read anew for each one. The queue starts up no more than two at a time, so a swarm of four developers will build their graphs longer than one task - just in the background.
The preset is not connected, turned off or without a launch command - Pulse is silent: they didn’t promise anything, there’s nothing to index with. A draft task without a repository also has nothing to index. Parsing a large repository takes minutes, so it has its own patience limit - 20 minutes instead of the usual one-minute MCP timeout.
What Indexing Doesn't Do
- Does not re-index based on changes. The graph is removed once, when a task is created. While the agent is editing the code, the graph becomes outdated, and Pulse does not know about it: it does not have a “repository has changed” signal. On a long task, the agent may ask for yesterday's picture.
- Does not index copies of swarm members. Only the working copy of the task is parsed; The swarm developer with his own copy of the graph does not have his own branch. The rule for who to disassemble is written, but is not called from the swarm launch - see above.
- It will not build copies of the swarm of a common graph and when it will be connected. Each copy will have to be parsed separately: the server has no way to remove the graph once and reuse it between branches.
- Does not index the copy created after the task. Copies are distributed when the swarm is launched along with the task; a session for which a separate copy was made later (isolation of the second author in a regular task) does not fall into this analysis.
- Does not index the task that arrived as a package. It starts in a different way, by creating a task in the window.
- Doesn't clean up after himself. Deleting a task demolishes the working copy, but does not delete the project from the code memory database: the database belongs to the server, not Pulse. You need to clean it using the server itself.
Tips
- Keep only those servers enabled that are really needed: each one adds tools to the model context.
- For small models, extra tools are harmful - they start to get confused. Check the behavior using the “Check” button on the local model.
- Pass secrets to servers through environment variables in the server settings, and not in arguments: the arguments are visible in call cards.