Model Context Protocol · stdio

DevMesh MCP

One protocol that gives every coding agent in your stack the same kanban, the same memory vault, and a way to coordinate without stomping on each other's files.

Get DevMesh

See the tools →

One protocol, every agent

Atomic file claims · shared mailbox · tiered memory

What it is

The connective tissue under your coding agents.

DevMesh MCP runs as a pair of stdio servers shipped inside the desktop app. Any MCP-compatible client you point at the same workspace joins the swarm — no extra account, no extra cloud.

One protocol, every client

Built on the open Model Context Protocol. Plug Claude Code, Cursor, Windsurf, Codex, OpenClaw — or any MCP client — into the same workspace.

Coordination, not chaos

Atomic file claims, a persistent message log, and a single source of truth for kanban tasks — so two agents on the same repo don't trample each other.

Per-workspace, stdio-native

Runs as a stdio subprocess scoped to one repo. No daemon, no port to manage, no cloud handoff — your context never leaves the machine.

Human-in-the-loop by default

Memory writes go through the proposal queue you already use. Agents can read freely; commits to shared knowledge still wait for your sign-off.

Bring your own agent

Works with every MCP-speaking client.

If it speaks MCP, it can join. DevMesh MCP doesn't care whose model is on the other end — the protocol is the contract.

Claude Code

Anthropic's terminal agent

Cursor

Cursor IDE MCP integration

Windsurf

Codeium's agent IDE

Codex

OpenAI's coding agent

OpenClaw

Open-source MCP clients

Any MCP client

Spec-compliant stdio clients

Coordination tools

Five primitives. Zero collisions.

Each tool is a single MCP call. Combined, they give a swarm everything it needs to divide work, claim files, and report back — without a human relaying messages.

devmesh_send_message

Drop a structured message (task assignment, status update, review verdict, handoff) into the per-workspace log for another agent to pick up on the next turn.

devmesh_peek_inbox

Non-destructive read of pending messages addressed to a given agent — no auto-ack, so a peek doesn't quietly burn the message.

devmesh_claim_files

All-or-nothing claim on a set of repo-relative paths, atomic via SQLite. If anything conflicts, no claim is recorded and the owner is reported back.

devmesh_list_tasks

Lists kanban tasks via the local `dm` CLI, with optional status and assignee filtering. The same board the desktop app uses, surfaced as a tool call.

devmesh_post_finding

Files an agent-discovered fact as a `finding`-typed note in the project memory tier. Tagged, slugged, and routed through the proposal queue.

Memory tools

The vault, exposed as MCP.

The same DevMemory tiers — org, project, user, local — exposed as MCP tools any client can call. Reads are free; writes route through the proposal queue.

memory_tree

Walk the tiered memory layout — org, project, user, local — and see what's loaded.

memory_read

Fetch a single memory file with its frontmatter and body.

memory_search

Full-text search across the merged memory layers, scoped to the current workspace.

memory_backlinks

Find every memory that links to a given entry by `[[name]]` reference.

memory_propose

Draft a new memory or update an existing one — routed to the proposal queue for human review.

memory_session_log

Append a session log entry — the lightweight write path for what an agent did, not what it learned.

memory_resolve

Resolve a `[[name]]` slug to the underlying file path, so agents can link without guessing.

Resources

Subscribe to the live state.

MCP resources let clients pull live snapshots without polling a tool every time. The coordination layer publishes two.

devmesh://claims/all

Live snapshot of every file currently owned by an agent — who claimed it, for which task, and when it expires.

devmesh://mailbox/<agent_id>

Per-agent inbox view of unacknowledged messages. Subscribable as a resource by any MCP client.

At a glance

Stdio MCP — no daemon, no port, no cloud handoff.
Atomic file claims via SQLite — all-or-nothing, never partial.
Persistent inter-agent mailbox — agents talk across processes.
Memory writes route through the same human-in-the-loop queue.

Your turn

One protocol. Every coding agent.

DevMesh MCP ships inside the desktop app. Point Claude Code, Cursor, Windsurf, or any MCP client at your workspace and they join the swarm — same kanban, same memory, no stomping.

Get DevMesh

See DevMemory →