Multiplayer agents over a shared git workspace. My agent works for me. Your agent works for you. They share a drop board — a git repo with an opinionated layout and a journal protocol — where work product lands. No agent-to-agent chat. Async coordination through artifacts.
Multisphere ships as a single plugin for both Claude Code and Cowork. One install brings the a2a skill (the drop-board protocol) and the multisphere-mcp server.
Same plugin, same artifact, two different install surfaces depending on client.
node, npm, and npx must be on the PATH of the process that launches your client (Claude Code or Cowork). The plugin's .mcp.json spawns the MCP server via npx -y multisphere-mcp@latest; without Node on PATH you'll see ENOENT / "Failed to reconnect to plugin:multisphere:workspace" at startup.
Node 20+ is required. If you use nvm, asdf, or mise, make sure the shim is loaded by the shell/launchd context that starts the client, not just your interactive terminal — GUI-launched apps often inherit a minimal PATH and won't see version-manager shims unless they're wired into your login environment.
Quick check from the same shell that launches your client:
which node npm npx
node --version # should print v20.x or newer/plugin marketplace add unicitynetwork/multisphere
/plugin install multisphere@unicity-labs
Then run /reload-plugins to apply — no full restart needed (restarting Claude Code also works). The skill registers as /multisphere:a2a and the MCP tools wire up automatically.
Cowork installs plugins through its UI, not slash commands:
- Click Customize in the left sidebar.
- Click the Plugins tab, then the + button → Add marketplace.
- In the URL field, type:
unicitynetwork/multisphere(the GitHub repo path). - Click through to add the marketplace. Cowork registers it as
unicity-labs. - Find the multisphere plugin in the marketplace listing and click Install.
- Restart Cowork.
After install in either client, you usually just describe your work ("what's new in this workspace?", "drop research about X in research/") and the skill activates from its description. /multisphere:a2a invokes it explicitly.
There are three distinct names that look similar:
| Layer | Identifier | Where it shows up |
|---|---|---|
| GitHub repo | unicitynetwork/multisphere |
The URL/repo field in install commands |
| Marketplace | unicity-labs |
Registered name after the marketplace is added |
| Plugin | multisphere |
What you install: multisphere@unicity-labs |
| Skill | a2a |
Invoked at runtime: /multisphere:a2a |
The GitHub org is unicitynetwork, not unicity-labs — that's the marketplace name (from marketplace.json), not the org.
The MCP server needs to know who you are so it can sign journal entries and git commits. Identity is resolved per-client (so the same machine can host jamie-claude-code and jamie-cowork without collision).
Simplest setup, covers all clients on the machine — create ~/.multisphere/identity.json:
{
"user_slug": "jamie",
"agent_name": "Jamie",
"agent_email": "jamie@unicity-labs.com"
}The server appends the client suffix automatically: Claude Code becomes jamie-claude-code, Cowork becomes jamie-cowork. Full precedence order and per-client overrides: docs/getting-started.md.
Single-player agents are done. Everyone has MCP, everyone has tool calling. The next move is multiplayer — and team-chat-for-robots architectures are a token nightmare and a hallucination nightmare. Multisphere bets on the simpler thing: agents read each other's outputs through a shared repo, and humans stay in the loop on what triggers what.
A run looks like this. You tell your agent to drop research in research/. The agent does the work, writes a journal entry, commits, pushes. Tomorrow Mike opens his agent — "what's new?" His agent pulls, reads the journal tail, summarizes. He says "build a slide from Jamie's research." Mike's agent does it, journals, pushes. No agent ever talks to another agent.
See docs/concept.md for the longer story. docs/product-plan.md is the product brief. docs/implementation-plan.md is the build spec.
.
├── .claude-plugin/
│ ├── plugin.json # plugin manifest (name: multisphere)
│ └── marketplace.json # marketplace manifest (name: unicity-labs)
├── .mcp.json # bundled MCP server config
├── skills/
│ └── a2a/SKILL.md # the drop-board protocol (/multisphere:a2a)
├── mcp-server/ # multisphere-mcp (TypeScript, Node 20+)
├── workspace-template/ # cloneable seed for a new workspace
├── docs/
│ ├── concept.md
│ ├── product-plan.md
│ ├── implementation-plan.md
│ ├── getting-started.md # setup walkthrough
│ └── protocol.md # wire spec for journal/inbox/pointers
├── manifest.json # (fallback) MCPB manifest for non-plugin hosts
├── scripts/build-mcpb.sh # (fallback) builds the .mcpb
├── Makefile # (developer tool, not for end users)
└── CLAUDE.md
If you're running an MCP host that doesn't support the /plugin system (something other than Claude Code or Cowork), there's an .mcpb bundle as a fallback. It carries only the MCP server — you'd add the skill manually to that host's equivalent of ~/.claude/skills/. We publish a .mcpb per release; build it locally with ./scripts/build-mcpb.sh until the first GitHub release.
- One-command plugin install for Claude Code and Cowork.
multisphere-mcpexposes 20 tools: workspace × 4, git × 8, fs × 4, protocol × 4.- The
a2askill ships the entry/exit protocol, file formats, and error handling. - Pull is fast-forward only. Conflicts surface to the human, never silently merge.
- Per-agent last-read pointers under
.pointers/.
Branches, PRs, real-time notifications, agent-to-agent direct messaging, a hosted UI, identity verification beyond git config, billing. See docs/product-plan.md.
Developing on the repo? See CLAUDE.md. Build and test commands live in the Makefile — not part of the user install path.
Bootstrapping. First trial: a small dogfood project (TBD) before we point bigger things at it.
MIT.