Connect
Devin Desktop

Give Devin Desktop memory across sessions.

Add the Bilinc adapter to Devin's MCP configuration and the agent can recall what earlier sessions decided before it edits, then keep what each session settled, with where it came from and every earlier version.

Start free MCP clients guide MCP tools

Set it up.

Devin Desktop runs the Bilinc MCP adapter from the bilinc Python package, which reads the key bilinc login saved.

Install the package and sign in. One package gives you the Python SDK, the bilinc command and the MCP adapter. bilinc login opens your browser and saves the key on this machine.
Terminal
```
pip install -U bilinc
bilinc login
```
Add Bilinc to mcp_config.json. In Devin Desktop, open the Cascade panel’s … menu and choose Open MCP config file in the MCPs section. On macOS and Linux the file is ~/.config/devin/mcp_config.json. Add Bilinc under mcpServers and save. bilinc mcp install prints this block with the absolute path of the Python that has Bilinc, and the adapter reads the key saved by bilinc login, so the config carries no key. On a machine without a saved key, add BILINC_API_KEY to the server's environment.
mcp_config.json
```
{
  "mcpServers": {
    "bilinc": {
      "command": "python3",
      "args": ["-m", "bilinc.cloud_mcp"]
    }
  }
}
```
Give the agent the memory contract. Paste the contract below into the instructions the agent reads, so it recalls before editing and commits outcomes at the end.

Or add it from the Devin CLI

The Devin CLI adds a stdio server with devin mcp add; everything after the two dashes is the command it starts. By default it saves to the local scope (.devin/mcp_config.local.json, gitignored); -s project uses .devin/mcp_config.json, and -s user uses ~/.config/devin/mcp_config.json for every project. Use the Python path bilinc mcp install prints.

Devin CLI

devin mcp add -s user bilinc -- python3 -m bilinc.cloud_mcp

Where Devin Desktop keeps its MCP servers is described in Devin’s MCP guide for Devin Desktop, the Devin CLI’s MCP configuration and the Devin Local agent.

What it changes for Devin Desktop.

A Devin session works from the repository, the conversation and the rules you keep. Anything you have not written into rules or memories by hand, which approach was ruled out, what a refactor deliberately left alone, what is still open, does not carry over to the next session. With Bilinc, the agent recalls those decisions before it edits, and each result says where the memory came from and when it was last written or confirmed.

At the end of a task it commits a short outcome with how it was verified. commit_mem keeps provenance with every write, revise replaces a memory deliberately, and every earlier version stays in the history.

Before risky work it can take a snapshot. diff then lists what changed since that checkpoint, and rollback restores it after a preview. The same memory is available from every other client you connect to the workspace.

Things to ask.

Ask in your own words; the agent picks the Bilinc tool that fits.

“Recall Bilinc for decisions about this module before you change it.”
“Take a Bilinc snapshot before you start this migration.”
“Show what changed in Bilinc since the last snapshot.”
“Commit this task's outcome to Bilinc with how you verified it.”

The memory contract

Paste this into the instructions Devin Desktop reads, so it recalls before it acts and keeps only what is worth keeping.

Instructions for your agent

Before editing, recall Bilinc for relevant project decisions.
After completing the task, commit a short session outcome with verification and caveats.
Never store secrets in memory.

The tools it gets.

The tools of the local adapter, as the tool reference lists them.

The tools of the Bilinc MCP adapter
Tool	What it does
`commit_mem`	Writes durable memory with key, value, memory type, importance, and provenance metadata. Returns an entry version you can reuse for optimistic concurrency.
`recall`	Retrieves prior state with query, profile, and limit. Smart retrieval is the profile argument, not a separate tool.
`revise`	Deliberately replaces a memory you already have. Returns memory_not_found rather than creating, so a correction stays distinguishable from an accidental overwrite.
`forget`	Destructive. Removes a memory from active recall. A reason is required and is written to the audit trail; the deleted value is never returned.
`status`	Reports the authenticated workspace, plan, limits, supported capabilities, and recall profiles. Read-only and never billed.
`snapshot`	Creates or lists project checkpoints. Create is metered; list is free. Neither returns the checkpoint contents.
`diff`	Compares a checkpoint against another checkpoint or current state. Free, and values are redacted unless explicitly requested.
`history`	Read-only and free. Returns one memory’s recorded changes, newest first, with the value before and after each change. Values from before the memory was forgotten are never returned.
`list_memories`	Read-only and free. Returns a page of stored memories ordered by key, with prefix, type, and updated-time filters and a cursor for the next page.
`confirm`	Records that an existing memory is still accurate without resending its value. The value stays as stored, its last-updated time moves to now, and history shows a confirmation. One write operation.
`rollback`	Destructive in execute mode. Preview is free and returns a short-lived confirmation token; execute needs that token and permanently discards everything changed since the checkpoint.

The tool reference

Questions.

Which Devin agent and file does this cover?

New tabs in Devin Desktop start with the Devin Local agent unless you chose another; Cascade is the legacy agent. Devin's MCP guide for Devin Desktop puts the Cascade agent's servers in ~/.config/devin/mcp_config.json, the same file the Devin CLI uses at user scope. For the Devin Local agent, Devin's documentation describes its MCP config files on its own page; check it for the file your version reads.

Does the config need an API key?

No. The adapter reads the key that bilinc login saved on your machine. A machine without a saved key needs BILINC_API_KEY in the server's environment.

Can I add Bilinc from the terminal?

Yes, with the Devin CLI: devin mcp add -s user bilinc -- followed by the Python command that bilinc mcp install prints. Without -s, the server is saved to the local scope of the current project.

How do I undo a bad session?

Take a snapshot before risky work. diff compares it with the current state, and rollback restores it: a free preview first, then an explicit execute. Rollback works on checkpoints, not on single keys.

Is the memory shared with my other clients?

Yes. Every client connected to the same workspace shares its memory, whether it is Devin Desktop, Codex, Cursor or Claude.

Bilinc connects the same way everywhere.

One workspace, every client. The memory guides and comparisons answer the questions underneath.