Which integrations are available for this server?

Enables Codex CLI (by OpenAI) to participate in multi-agent collaboration sessions with shared memory, tasks, and real-time messaging across contexts.

How do I use mcp-agent-bridge?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@mcp-agent-bridge Create a context named 'sprint-12' and join it." 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.

mcp-agent-bridge

by xfajarr

Overview Schema Source Related Servers Discussions Admin

JavaScript

Local

mcp-agent-bridge

A local MCP server that gives any number of AI agents — Claude Code, OpenCode, Codex, Hermes, OpenClaw, or any MCP-compatible client — a shared, real-time context across windows and sessions.

Every write (memory, message, task, artifact) is instantly pushed to all other connected agents via WebSocket and MCP resource notifications. No polling required.

Features

Named contexts — create isolated workspaces (hackathon, my-project, review) and choose which one each agent joins
Real-time push — WebSocket + MCP notifications/resources/updated on every state change
Any agent type — works with Claude Code, OpenCode, Codex, Hermes, OpenClaw, or anything that speaks MCP
Shared memory — key/value store scoped per context
Tasks — create, assign, and track tasks across agents
Messaging — direct messages and broadcast within a context
Artifacts — share code, plans, JSON, markdown between agents
Discussions — threaded brainstorm threads per topic
Sessions — orchestrated multi-agent collaboration sessions
Persistent — all state is written to JSON files and survives restarts

Related MCP server: junto-memory

Quick Start

git clone https://github.com/YOUR_USERNAME/mcp-agent-bridge
cd mcp-agent-bridge
npm install
npm start

Server runs on http://localhost:3721.

Client Configuration

Claude Code

Add to ~/.claude.json:

{
  "mcpServers": {
    "agent-bridge": {
      "type": "http",
      "url": "http://localhost:3721/mcp"
    }
  }
}

OpenCode

Add to ~/.config/opencode/opencode.json:

{
  "mcp": {
    "agent-bridge": {
      "type": "remote",
      "url": "http://localhost:3721/mcp",
      "enabled": true
    }
  }
}

Any MCP client (Streamable HTTP)

Endpoint: http://localhost:3721/mcp

Legacy SSE clients

Endpoint: http://localhost:3721/sse

WebSocket (real-time events, no MCP required)

const ws = new WebSocket("ws://localhost:3721/ws");
ws.on("message", (data) => console.log(JSON.parse(data)));

Auto-start (macOS launchd)

Create ~/Library/LaunchAgents/com.mcp-agent-bridge.plist:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
  <key>Label</key>
  <string>com.mcp-agent-bridge</string>
  <key>ProgramArguments</key>
  <array>
    <string>/usr/local/bin/node</string>
    <string>/path/to/mcp-agent-bridge/server.js</string>
  </array>
  <key>RunAtLoad</key>
  <true/>
  <key>KeepAlive</key>
  <true/>
  <key>StandardOutPath</key>
  <string>/tmp/mcp-agent-bridge.log</string>
  <key>StandardErrorPath</key>
  <string>/tmp/mcp-agent-bridge.log</string>
</dict>
</plist>

launchctl load ~/Library/LaunchAgents/com.mcp-agent-bridge.plist

Usage

1. Register your agent

Always call identify first. Optionally join a context immediately.

identify("claude", session_label="window-2", context="my-project")

2. Create and join contexts

create_context("hackathon", description="Weekend project")
join_context("hackathon")

All subsequent operations (memory, tasks, messages, etc.) are scoped to hackathon.

set_memory("stack", "Next.js + Postgres")
get_memory()

Any other agent in the same context receives a notifications/resources/updated push and a WebSocket event instantly.

4. Send messages

send_message("opencode", "DB schema is ready, check artifacts")
read_messages()
broadcast("Starting code review now")

5. Coordinate with tasks

create_task("Write API routes", "Implement /api/notes CRUD", assigned_to="codex")
list_tasks(filter="mine")
update_task("<id>", status="done", notes="All routes covered with tests")

save_artifact("db-schema", "<SQL>", type="code", language="sql")
get_artifact("db-schema")

7. Check context status

list_contexts()       # all workspaces + who's in them
context_status()      # your current context summary
agent_status()        # all agents grouped by context

MCP Tools Reference

Context Management

Tool	Description
`create_context(name, description?)`	Create a named workspace
`list_contexts()`	List all contexts with active agents and stats
`join_context(name)`	Switch to a context — all ops become scoped to it
`leave_context()`	Return to `default` context
`delete_context(name, confirm: true)`	Delete context and all its data
`context_status()`	Show current context, peers, memory/task counts

Identity

Tool	Description
`identify(agent_name, session_label?, context?)`	Register this session; optionally join a context

Memory

Tool	Description
`set_memory(key, value, tags?)`	Write to shared memory — peers notified instantly
`get_memory(key?, tag?)`	Read one key or list all (optionally filter by tag)
`delete_memory(key)`	Remove a key

Messaging

Tool	Description
`send_message(to, content, metadata?)`	Direct message to an agent in context
`read_messages(mark_read?, include_read?)`	Read your inbox
`broadcast(content)`	Send to all agents in context

Tasks

Tool	Description
`create_task(title, description, assigned_to, priority?)`	Create and assign a task
`list_tasks(filter?)`	List tasks (`all`, `mine`, `pending`, `in_progress`, `done`, `blocked`)
`update_task(id, status?, notes?)`	Update status or add progress notes

Artifacts

Tool	Description
`save_artifact(name, content, type, language?, description?)`	Save code/text for sharing
`get_artifact(name)`	Retrieve an artifact
`list_artifacts(type?)`	List all artifacts

Discussion

Tool	Description
`add_to_discussion(topic, content)`	Add to a named thread
`get_discussion(topic?)`	Read a thread or all threads

Session / Orchestration

Tool	Description
`start_session(goal, context?)`	Start a collaborative session; peers notified
`get_session()`	Get active session details
`end_session(summary?)`	End the session

Status & Events

Tool	Description
`agent_status()`	All connected agents grouped by context
`get_events(since?, type?, limit?)`	Poll event log since a timestamp

MCP Resources

All resources are live — reading them always returns current state. Agents receive notifications/resources/updated when the underlying data changes.

URI	Content
`agent-bridge://contexts/{context}/memory`	Shared memory for a context
`agent-bridge://contexts/{context}/tasks`	Tasks for a context
`agent-bridge://contexts/{context}/session`	Active session
`agent-bridge://contexts/{context}/discussion`	Discussion threads
`agent-bridge://contexts/{context}/artifacts`	Shared artifacts
`agent-bridge://contexts/{context}/messages/{agent}`	Agent inbox

WebSocket Protocol

Connect to ws://localhost:3721/ws.

On connect — receive a full state snapshot:

{
  "type": "snapshot",
  "data": {
    "contexts": [{ "name": "default", "active_agents": [], "memory": {}, "tasks": [] }]
  },
  "timestamp": "2026-03-26T..."
}

Events pushed on every mutation:

{ "type": "memory_updated", "context": "hackathon", "data": { "key": "stack", "updated_by": "claude" }, "timestamp": "..." }
{ "type": "message_sent",   "context": "hackathon", "data": { "from": "claude", "to": "opencode" }, "timestamp": "..." }
{ "type": "task_created",   "context": "hackathon", "data": { "title": "...", "assigned_to": "codex" }, "timestamp": "..." }
{ "type": "agent_connected","context": "hackathon", "data": { "agent": "hermes" }, "timestamp": "..." }

Commands you can send:

{ "type": "ping" }
{ "type": "subscribe_events_since", "since": "2026-03-26T10:00:00Z", "context": "hackathon" }

REST API

Endpoint	Description
`GET /health`	Server status, all contexts, connected agents
`GET /contexts`	List all contexts with active agents and stats
`GET /contexts/:name`	Context details including memory and tasks

Data Storage

All state is persisted to ./data/:

data/
  contexts_meta.json     — registry of all context names + metadata
  ctx_default.json       — state for the "default" context
  ctx_hackathon.json     — state for the "hackathon" context
  ctx_my-project.json    — ...

Each context file contains memory, tasks, messages, artifacts, session, discussion, and events.

Supported Agent Types

Any MCP client works. Tested with:

Claude Code (Anthropic)
OpenCode (open source)
Codex CLI (OpenAI)

And any client you register via identify("your-agent-name").

License

MIT

This server cannot be deployed

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

Maintenance

ActivityInactive

ResponsivenessNo issues

Resources

Need Help?

Related Servers

Related MCP Connectors

mcp-serverOAuth
com.niftypm
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
Project Management Communication File Systems
2
Living MemoryOAuth
to.viibe
An MCP memory server. One memory your agents share — across models, devices and apps.
Knowledge & Memory Autonomous Agents AI & Machine Learning
22
mcp-server B
cc.thecolony
Remote MCP server for The Colony — a social network for AI agents (posts, DMs, search, marketplace).
Knowledge & Memory Research & Data
22423
anotherai
dev.anotherai
MCP server for building and testing AI agents with multi-model experimentation and insights.
Agent Orchestration Autonomous Agents Testing & QA Tools
2

Related MCP Servers

Agent Orchestration
Agent Orchestration Autonomous Agents
madebyaris
A
license
Not graded
quality
F
maintenance
A Model Context Protocol (MCP) server that enables multiple AI agents to share memory, coordinate tasks, and collaborate effectively across IDEs and CLI tools.
Updated 5 months ago (2026-04-05 06:17 UTC)
16 npm
17
MIT
junto-memory
Knowledge & Memory Agent Orchestration
tlemmons
A
license
Not graded
quality
B
maintenance
A shared memory and coordination server for multiple AI coding agents, built on the Model Context Protocol (MCP).
Updated 7 days ago (2026-09-10 11:08 UTC)
5
MIT
ACDP
Agent Orchestration Coding Agents Autonomous Agents
gabogabucho
A
license
A
quality
D
maintenance
Enables multiple AI agents to coordinate work on the same codebase by providing real-time file locking, commit approval, and agent awareness through a lightweight WebSocket-based MCP server.
Updated 5 months ago (2026-04-17 19:00 UTC)
9
10 npm
11
MIT
agent-comm
Autonomous Agents Agent Orchestration
keshrath
A
license
Not graded
quality
D
maintenance
MCP server that enables AI coding agents to communicate, share state, and coordinate work in real time via MCP tools or REST API.
Updated 5 months ago (2026-04-17 08:01 UTC)
123 npm
5
MIT

mcp-agent-bridge

Features

Quick Start

Client Configuration

Claude Code

OpenCode

Any MCP client (Streamable HTTP)

Legacy SSE clients

WebSocket (real-time events, no MCP required)

Auto-start (macOS launchd)

Usage

1. Register your agent

2. Create and join contexts

3. Share memory in real-time

4. Send messages

5. Coordinate with tasks

6. Share code and plans

7. Check context status

MCP Tools Reference

Context Management

Identity

Memory

Messaging

Tasks

Artifacts

Discussion

Session / Orchestration

Status & Events

MCP Resources

WebSocket Protocol

REST API

Data Storage

Supported Agent Types

License

Maintenance

Resources

Related MCP Connectors

Related MCP Servers

Agent Orchestration

junto-memory

ACDP

agent-comm