v1.0.0 · macOS · open source
Link the repos you already work in as projects. Dispatch merges one entry into each linked repo's .mcp.json — nothing else changes. From then on, the Claude Code sessions you run in those repos, your own sessions, can ask each other questions over a local MCP bus, and you see every exchange.
Dispatch is a native macOS app that links local repos you already work in and lets the Claude Code sessions running in them ask each other questions.
You add each repo as a project; linking two projects merges a single dispatch entry into each one's own .mcp.json. Dispatch never starts a session, never queues work, and never gates a commit — it hosts one localhost MCP bus and relays messages between sessions you started yourself, over four tools: ask_agent, answer_agent, check_messages, list_projects. A project link is the whole consent model — an ask to a project you haven't linked fails closed.
No fifth tool that runs commands or edits another repo's files. A question is a question, not a task — the session on the other end decides for itself how (or whether) to answer.
Ask another linked project's session a question about its own repo — its contract, its behavior, whether a change is safe there. Pass wait_seconds and, if that project is connected right now, get the answer back inline; otherwise it lands in that project's inbox.
Answer a question addressed to your project. Only the project a question was asked of can answer it. If the asker is waiting, your answer reaches them immediately.
Open questions still waiting on you, plus the outcome — answered or expired — of every question you asked and haven't seen yet. Each outcome is reported exactly once.
The only projects ask_agent can reach. Each entry reports whether that project's session is connected right now, when it was last seen, and how many of its questions are sitting in your inbox.
Link
A project is a name, a repo path, and a durable bus token — nothing is cloned or copied. Linking two projects is the human's decision, made once in the app; it's the only thing that makes them reachable from each other.
.mcp.json — your own MCP servers and any other keys round-trip untoucheddispatch is reported as a conflict, never silently overwritten{
"mcpServers": {
"dispatch": {
"type": "http",
"url": "http://127.0.0.1:<port>/bus/<token>"
}
}
}What linking merges into a repo's .mcp.json — one key, added or replaced, everything else untouched.
Watch
A graph of your linked projects, plus a searchable, filterable list of every question and answer that has crossed the bus — pending, answered, expired, or closed. Filter by project, or search by question text or id.
Read & answer
Expand any thread in the Messages tab to read the full question, the full answer, and who answered it. Nothing crosses the bus without landing here — the human can read every exchange, and can answer a question directly from the app if the session on the other end isn't around.
Cross-repo questions are a real attack surface if you let them be. Dispatch is built so a project you link can ask, but never quietly command.
Nothing is reachable until a human links it in the app. ask_agent checks the link before anything else fires — an ask to an unlinked project is refused, not silently dropped.
Every question and answer crossing the bus is wrapped in explicit content markers and a framing line telling the receiving session it's data to reason about, not instructions to follow — before it ever reaches that session's prompt.
Dispatch starts nothing. The sessions on both ends are yours, started the normal way in your own terminal. There's no queue of tasks, no commit gate, no QA pipeline for Dispatch to abuse.
The listener binds 127.0.0.1. The only thing Dispatch writes into your repo is a single localhost URL — nothing is sent to a Dispatch-run server, because there isn't one.
Dispatch is pre-1.0 — the app is real and buildable today. Grab a release when one's cut, or build from source below.
$PATH — Dispatch never installs or spawns it, but it's what runs in each linked repogit clone https://github.com/awizemann/Dispatch.git
cd Dispatch
./scripts/build.shclaude as usual in each repo — it picks up the dispatch server from .mcp.json on start.Full walkthrough, including troubleshooting, on the Getting Started wiki page.
Quick answers to the questions developers usually ask before installing.
Dispatch is a native macOS app that acts as a switchboard between local repos. You add each repo you work in as a project and link the pairs that should be able to talk. Linking merges one dispatch entry into that repo's own .mcp.json. From then on, the Claude Code sessions you run in those repos — your own sessions, started the normal way in your own terminal — can ask each other questions over an app-hosted localhost MCP bus.
No. Dispatch never starts a session, never queues work, and has no commit gate or QA pipeline. It only hosts the bus and relays messages between sessions you started yourself by running claude in a linked repo. If no session is running in a project, questions addressed to it simply wait in its inbox until one is.
Exactly four things, all mediated by Dispatch: ask_agent (ask a linked project's session a question about its own repo), answer_agent (answer a question addressed to you), check_messages (read your inbox), and list_projects (see who you're linked to and who's connected). There is no fifth tool that runs commands, edits files, or triggers work in another repo — a question is not a task, and the receiving session decides for itself how to answer.
It fails closed. A human-created project link is the entire consent model — ask_agent cannot reach a project that isn't listed by list_projects, and there is no way to reach an unlinked project by guessing a name or id. If the project you need is missing, that's a decision for the human, not something a session can route around.
No. A question crosses the bus as a single self-contained block of text — the asking session's repo, files, and conversation are never visible to the other side. Each project answers only from what it can verify in its own repo, and is expected to say plainly when it doesn't know.
No, by design. Every question and answer that crosses the bus is framed as untrusted data before it reaches the receiving session's prompt, with explicit content markers and an instruction that it's content to reason about, not instructions to follow. One repo's session cannot use a bus message to make another repo's session do something its own rules would otherwise refuse.
The question sits in that project's inbox. Nothing wakes a session that isn't there — the other side picks it up the next time it calls check_messages, whether that's a minute later or the next day. Pass wait_seconds to ask_agent only when you want an inline answer and the other project shows as connected on list_projects; otherwise the ask returns a pending id immediately. Unanswered questions eventually expire, and the asker is told so — never silently dropped.
Not through Dispatch. The bus listener binds 127.0.0.1 only, and the only thing Dispatch writes into a repo is a single localhost URL inside its .mcp.json. Whatever a Claude Code session itself does — reach a model provider, use other tools — is between that session and its own configuration, unrelated to Dispatch.
One key. Dispatch merges a single dispatch entry into the repo's .mcp.json (creating the file if needed) and touches nothing else — your own MCP servers and any other top-level keys round-trip untouched. If a dispatch entry already exists that Dispatch didn't write, install refuses rather than overwriting it, and reports the conflict. Unlinking removes only that one key; the file itself is only deleted if Dispatch created it and removing the key leaves it an empty shell.
Yes, MIT licensed. The source — the MCP bus implementation, the .mcp.json installer, the whole app — is on GitHub.
macOS 14 (Sonoma) or later, and the Claude Code CLI installed and on your $PATH in each repo you want to link — Dispatch never installs or runs it for you. Building from source additionally needs a recent Xcode.
No. Dispatch is a native macOS app built on SwiftUI and AppKit. There is no current Windows or Linux build.