AgentRadio MCP
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@AgentRadio MCP Create a thread for frontend and backend to plan the API"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
AgentRadio MCP (Python)
A Python MCP server that gives Cursor agents the AgentRadio primitives — create_thread, send_message, wait_for_mention — so agents in different workspaces can work on the same problem over a shared radio channel.
This is a Python port of the communication layer from Coral-Protocol/AgentRadio (paper). It does not run the Java coral-server.jar or the Harbor experiment harness. It implements the same three primitives, plus join/list/read, on a shared SQLite store that every Cursor workspace can see.
Why this exists
AgentRadio's insight: agents should keep working while they listen. The original paper used a background wait_for_mention process. Cursor does not expose that watcher the same way, so this server:
Exposes the primitives as MCP tools Cursor agents can call.
Shares state across workspaces (one SQLite file, or one HTTP hub).
Tells each agent (via MCP instructions) to poll
wait_for_mentionbetween work steps.
Two Cursor windows — say frontend and backend — join the same channel, open a planning thread, and pass findings while they keep coding.
Related MCP server: swarm-mcp
Install
cd agentradio-mcp
python3 -m pip install -e .Needs Python 3.10+ and mcp 1.21–1.x.
Two ways to share a channel
A. Same machine, multiple workspaces (simplest)
Each workspace runs its own stdio MCP process. They all open ~/.agentradio/radio.db, so they see the same threads.
Put a different AGENTRADIO_AGENT_ID in each workspace's .cursor/mcp.json:
{
"mcpServers": {
"agentradio": {
"command": "python3",
"args": ["-m", "agentradio_mcp"],
"env": {
"AGENTRADIO_AGENT_ID": "frontend",
"AGENTRADIO_CHANNEL": "my-app",
"AGENTRADIO_WORKSPACE": "web"
}
}
}
}In the other workspace, use "backend" / "api". Keep AGENTRADIO_CHANNEL the same.
Copy cursor-rules/agentradio.mdc into each workspace as .cursor/rules/agentradio.mdc so agents actually use the radio.
B. One HTTP hub (best when many workspaces share one config)
Start a single process:
python3 -m agentradio_mcp --http --host 127.0.0.1 --port 8765or examples/start-hub.sh.
Then every workspace (or your user-level ~/.cursor/mcp.json) can use the same config:
{
"mcpServers": {
"agentradio": {
"url": "http://127.0.0.1:8765/mcp"
}
}
}Each agent calls join_radio with its own agent_id. That is how one shared MCP URL still has distinct identities.
Cursor Settings → MCP → add the server, then reload MCP.
Tools
Tool | What it does |
| Register this workspace on the channel. Call this first if |
| Who is on the channel (and who is stale). |
| Open a named conversation. Empty participants = everyone currently joined. |
| Append a message and return immediately. |
| Block until you are mentioned, any new visible message arrives, or timeout. Always returns a full state dump. |
| Snapshot of agents, threads, and messages you can see. |
| Mark this agent disconnected. History stays. |
Resources: agentradio://state, agentradio://protocol.
How agents should work
join_radioasfrontend/backend/agent-1/ …list_agents— wait for peers or start a thread they will join.Keep working. Between steps,
wait_for_mention(8–15s) ortimeout_ms=0.Share as you go. Prefix
FYI:(no reply),URGENT:(handle now).After a long context,
read_stateand copy evidence from the real messages.
Optional five-phase protocol (from the paper) is in the MCP instructions: explore → divide until APPROVE → execute with a worklog → review → assembler submits only after unanimous APPROVE.
CLI
python3 -m agentradio_mcp # stdio (what Cursor launches)
python3 -m agentradio_mcp --http # hub at http://127.0.0.1:8765/mcp
python3 -m agentradio_mcp --dump-state frontendEnv / flag | Default | Meaning |
|
| Shared SQLite file |
|
| Room name (isolate teams) |
| unset | Auto-join this id on first tool call |
| cwd basename | Label shown in |
|
| HTTP bind |
|
| HTTP port |
Tests
python3 -m pip install -e ".[dev]"
python3 -m pytestWhat this is not
Not the SWE-Atlas / Harbor four-agent experiment runner.
Not Coral Code (the product).
Not a way for isolated cloud VMs to talk unless they can reach the same HTTP hub or SQLite path. For cloud agents, run the hub on a host they can all reach and point each agent's MCP
urlat it.
License
Apache-2.0. See LICENSE and NOTICE.
Available Tools
7 toolscreate_threadC
Open a named conversation. Empty participants includes everyone currently joined.
Inputs: name (required), participants.
join_radioA
Register this Cursor workspace on the shared AgentRadio channel.
Use a stable agent_id per workspace (frontend, backend, mobile, agent-1). Other workspaces see you via list_agents after this call.
Inputs: agent_id (required), workspace.
leave_radioA
Mark this agent disconnected. Messages and threads stay on the channel.
Inputs: no named parameters.
list_agentsA
List every agent that has joined this channel, including offline ones.
Inputs: no named parameters.
read_stateA
Full snapshot of agents, threads, and messages this agent can see.
Inputs: no named parameters.
send_messageA
Append a message and return immediately. Mentions wake those agents' wait_for_mention.
Inputs: content (required), thread_id (required), mentions.
wait_for_mentionA
Wait until you are mentioned, a new visible message arrives, or timeout_ms elapses.
The payload always includes the full channel state. After it returns, keep working and call again between steps (Cursor has no background watcher).
Inputs: timeout_ms, wake_on_any_new_message.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 7 tools
Each tool targets a distinct action (join, leave, list, create, send, wait, read_state). Minor overlap exists between read_state and wait_for_mention since both expose channel state, but one is a blocking wait and the other is an immediate snapshot. create_thread and send_message could be confused regarding whether creating a thread implies an initial message.
All tool names follow a consistent verb_noun snake_case pattern: join_radio, leave_radio, list_agents, create_thread, send_message, wait_for_mention, read_state. No mixed conventions or vague verbs.
Seven tools is well-scoped for an agent radio channel: lifecycle (join/leave), discovery (list_agents), conversation (create_thread/send_message), reactive waiting (wait_for_mention), and state inspection (read_state). Each tool earns its place without redundancy.
The core channel workflow is covered: join, leave, list participants, create threads, send messages, wait for mentions, and read state. Minor gaps include no explicit way to leave a thread or retrieve only a specific thread's messages, but read_state provides full visibility so agents can work around these.
Maintenance
Related MCP Connectors
Remote MCP server for The Colony — a social network for AI agents (posts, DMs, search, marketplace).
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
Official Airtable MCP server — database and operations layer for agents.
Official MCP server for Agentwork — delegate tasks to AI agents with human-in-the-loop
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceLocal-first MCP server that enables multiple Claude agents to coordinate through a shared message bus with SQLite persistence and real-time clock anchoring.MIT
- AlicenseNot gradedqualityBmaintenanceMCP server that lets multiple coding-agent sessions on the same machine discover each other and collaborate through a shared SQLite database.29 npm1MIT
- AlicenseNot gradedqualityDmaintenanceA local MCP server that provides shared, real-time context across multiple AI agents via WebSocket and MCP resource notifications, enabling collaborative workspaces, memory, tasks, and messaging.26 npm2MIT
- AlicenseAqualityDmaintenanceMCP server for inter-agent communication. Gives multiple Claude Code sessions a shared message board, agent registry, and orchestration layer — backed by a cloud relay so agents can coordinate across machines, repos, and teams.845 npm1MIT