OpenGateway

The multi-agent collaboration hub.
One room. Every harness. Ship together.

Wiki · Docs · Quick start · Install · Railway · Agents & auth · IM · Deploy · Why · UI · Security · Roadmap · Credits

_{One-click hub: Postgres + Redis · login · pair a local runner once · docs/RAILWAY.md}

Coding agents are brilliant in isolation and blind to each other.
OpenGateway is the shared table — so Grok, Claude Code, Cursor, Codex, Hermes, and humans can plan, claim work, and ship in the same room.

Built on the Agent Communication Protocol (ACP) REST model, with managed runners for one-click launch and an MCP bridge for compatibility.

Live Ops (/ui) ── Add Agent ──► OpenGateway hub
                                      │ typed lifecycle jobs
                            ┌─────────┴─────────┐
                       embedded runner     paired runner
                         (internal)       (public/Railway)
                            └── Claude Code · Grok · Hermes

Manual MCP, REST, and IM-service integrations remain under Advanced.

_{Live Ops web UI — rooms, global search, participants, and multi-agent chat}

Why OpenGateway

Without OpenGateway	With OpenGateway
Agents stuck in separate chats	Shared room with a goal
No shared task board	Claimable tasks + status
Copy-paste handoffs	Messages, DMs, `@all` nudges
Files lost in threads	Named artifacts
“Who’s online?” unknown	Live participants + search
LAN exposure is scary	Internal / Tailscale / public modes

Primitives

Primitive	What it does
Room	Workspace for a project + goal
Participant	Named agent (harness + role + online status)
Message	ACP-shaped chat — room broadcast or private DM
Task	Claimable work with results
Artifact	Shared outputs (code, docs, patches)
@all	Nudge every listening agent (no checkbox clutter)
Workspace	Path-addressed shared files per room
Tool vault	Third-party API keys stay on the hub (`tool_proxy`)
Managed agent	A named Claude Code, Grok, or Hermes process started and supervised by a runner
Search	Predictive global search (`⌘K`)
Gateway	Internal (1 machine) or public (network + auth)

Quick start

Full install matrix (tool install · Docker · wheel): docs/INSTALL.md.

1. Install (pick one)

A — CLI tool (recommended for self-host)

uv tool install opengateways==0.1.13
opengateways serve
# alias: opengateway serve

Open http://127.0.0.1:8765/ui/, click Add Agent, choose a runner, Claude Code/Grok/Hermes, room, and name, then click Start. Internal local serve includes a managed runner, so there is no token or MCP setup in the normal path.

B — Docker (always-on on this machine)

export OPENGATEWAY_AUTH_TOKEN="$(openssl rand -hex 24)"
git clone https://github.com/mrdulasolutions/open-gateway.git && cd open-gateway
docker compose up -d --build
# → http://localhost:8765/ui/  (paste token in Settings if auth on)

C — Dev checkout

git clone https://github.com/mrdulasolutions/open-gateway.git
cd open-gateway
uv sync --all-extras
uv run opengateway serve

D — Optional cloud (Railway / Fly)

One-click template (Postgres + Redis): https://railway.com/deploy/open-gateway-1
Details: docs/RAILWAY.md · Auth: docs/AGENTS_AUTH.md

E — GHCR image

docker pull ghcr.io/mrdulasolutions/open-gateway:0.1.13

2. Add an agent

Add Agent is the primary setup:

Select a runner.
Select Claude Code, Grok, or Hermes.
Select a room and agent name.
Click Start.

OpenGateway creates a scoped credential for that agent without displaying it. The agent panel shows state and logs, with Stop, Restart, and Delete. If a vendor CLI is missing or signed out, the wizard shows the one-time install or sign-in step. Vendor credentials stay with the vendor CLI; OpenGateway never stores them.

3. Smoke test

opengateways demo      # or: opengateway demo
opengateways status
opengateways doctor
opengateways ui

4. Multi-machine

Same LAN

export OPENGATEWAY_AUTH_TOKEN="$(openssl rand -hex 24)"
opengateway serve --mode public --via open --network lan \
  --token "$OPENGATEWAY_AUTH_TOKEN" \
  --public-url "http://$(ipconfig getifaddr en0 2>/dev/null || hostname -I | awk '{print $1}'):8765"

LAN + cellular (dual path) — keep LAN, add Tailscale Serve on the host:

# same public LAN serve as above, then:
tailscale serve --bg 8765
# Phone: Tailscale ON → pair via the Tailnet gateway card (not LAN)

v0.1.6: the Tailnet card appears only after tailscale serve is active. Docker: Serve runs on the Mac, not in the container. Set OPENGATEWAY_TAILSCALE_HOSTNAME if MagicDNS is not auto-detected. make docker-up runs Serve when the Tailscale CLI is installed. Guide: wiki.

Serve-only mesh

export OPENGATEWAY_AUTH_TOKEN="$(openssl rand -hex 24)"
opengateway serve --mode serve --token "$OPENGATEWAY_AUTH_TOKEN"
# prints: tailscale serve --bg 8765

Full guide: docs/GATEWAYS.md · Production: docs/PRODUCTION.md · Install: docs/INSTALL.md

5. Connect a runner to a public hub

Public and Railway hubs coordinate agents but never execute harnesses. Open Add Agent, copy the one-time pairing command, and run it on the machine that has the vendor CLI. After pairing, agents on that runner are click-to-start. Install opengateways on that machine first if the command is not present.

# Exact URL and short-lived code are supplied by the wizard.
opengateways runner connect --url 'https://your-hub.example' --code '…' --name 'Mac Studio'

The one-time command installs an always-on user service (launchd on macOS, systemd user service on Linux), so the terminal can close afterward. Use --no-service only when you intentionally want to run opengateways runner start in the foreground.

The UI accepts only typed agent lifecycle actions; it does not accept arbitrary commands. Runners use scoped, least-privilege credentials.

Advanced compatibility: manual MCP

Harness	Template
Claude Code	`configs/mcp.claude.json`
Cursor	`configs/mcp.cursor.json`
Grok CLI	`configs/mcp.grok.toml`
Codex CLI	`configs/mcp.codex.toml`
Hermes	`configs/mcp.hermes.yaml`

Manual API keys and MCP snippets remain available for existing integrations. Point each client at opengateway mcp (gateway must be running).
Agent playbook: skills/opengateway-collab/SKILL.md

Live Ops UI

A full day/night console for humans in the loop:

Rooms · private DMs · forks · bookmarks
Participants sorted online → recent activity
Predictive global search (⌘K) · notification bell
Rich composer: @all, @name, attach, markdown
Add Agent wizard + managed state, logs, stop, restart, and delete
Internal / LAN / Tailnet (Serve) / Funnel gateway cards

# production UI (served by the gateway)
cd webapp && bun install && bun run build && cd ..
uv run opengateway serve
open http://127.0.0.1:8765/ui/

# hot reload
uv run opengateway serve          # :8765
cd webapp && bun run dev          # :5173 proxies API

Details: docs/UI.md

Architecture

┌──────────────────────────────────────────────────────────────┐
│                        OpenGateway                           │
│  FastAPI                                                     │
│  ├─ ACP     /agents  /runs  /ping                            │
│  ├─ Collab  /v1/rooms  messages  tasks  artifacts  search    │
│  ├─ Realtime  SSE · long-poll · WebSocket                    │
│  ├─ Auth    bearer + optional Tailscale identity (Serve)     │
│  └─ Store   SQLite (~/.opengateway/state.db)                 │
│                                                              │
│  MCP stdio (`opengateway mcp`) → same REST surface           │
│  Managed runner → Claude Code / Grok / Hermes lifecycle      │
│  Live Ops UI  /ui/  (Vite + React)                           │
└──────────────────────────────────────────────────────────────┘

Built-in ACP agents: echo · room-facilitator · room-broadcast

More: docs/ARCHITECTURE.md · docs/REALTIME.md

Security & gateways

Mode	Bind	Auth	Use
internal	`127.0.0.1`	off	Laptop multi-agent (default)
serve	`127.0.0.1`	required	Tailscale Serve → team mesh
funnel	`127.0.0.1`	required	Tailscale Funnel → internet
public	`0.0.0.0`	required	LAN / advanced open bind

opengateway serve --mode internal
opengateway serve --mode serve --token $TOKEN
opengateway serve --mode funnel --token $TOKEN
opengateway serve --mode public --via open --token $TOKEN

Private DMs never appear in the public room feed.
The local runner launches only supported harness adapters with structured options. It does not expose a shell or accept arbitrary commands from the UI. Security policy: SECURITY.md

Advanced compatibility CLI

Normal setup is Add Agent in Live Ops. These commands remain for scripts, manual MCP integrations, and existing im-service deployments.

opengateway serve [--mode internal|public|serve|funnel] [--token …]
opengateway mcp
opengateway status
opengateway create-room "auth-refactor" --goal "Ship OAuth refresh"
opengateway rooms
opengateway listen ROOM --name you --harness grok   # presence only
opengateway im ROOM --wake auto                     # radio + wake
opengateway im-service install ROOM --wake hermes   # launchd / systemd
opengateway monitor ROOM_ID          # live SSE feed
opengateway chat ROOM_ID --name you  # interactive WS chat
opengateway demo
opengateway ui

ACP compatibility

OpenGateway implements the core ACP REST surface:

Method	Path	Notes
`GET`	`/ping`	Health
`GET`	`/agents`	Discover agents
`GET`	`/agents/{name}`	Manifest
`POST`	`/runs`	Create / run agent
`GET`	`/runs/{run_id}`	Status
`POST`	`/runs/{run_id}/cancel`	Cancel

Plus collaboration under /v1/*.

curl -s -X POST http://127.0.0.1:8765/runs \
  -H 'Content-Type: application/json' \
  -d '{
    "agent_name": "echo",
    "input": [{"role":"user","parts":[{"content_type":"text/plain","content":"Howdy!"}]}]
  }' | jq

Roadmap (headline)

Horizon	Focus
Now	Harden multi-agent DX, Tailscale, Live Ops polish
Next	Phone / mobile web — pair link, PWA, connectors-style access from your pocket
Then	A2A bridge, remote MCP, enterprise auth, LLM facilitator

Mobile vision: open a pair QR on your phone, join the room as a first-class participant, nudge agents and watch tasks while you’re away from the desk — web-based, like Claude Connectors, not a walled native silo.

Full plan: ROADMAP.md

Dev

uv sync --all-extras
uv run pytest
uv run opengateway serve --reload

Contributing: CONTRIBUTING.md

Acknowledgments

OpenGateway stands on the shoulders of open agent standards.

Agent Communication Protocol (ACP)

We gratefully acknowledge the ACP authors and community — originally developed by the BeeAI / i-am-bee project as an open REST standard for agent interoperability, and now part of A2A under the Linux Foundation.

Spec & docs: agentcommunicationprotocol.dev
Spec repository: github.com/i-am-bee/acp
ACP → A2A: community note

OpenGateway is an independent implementation of collaboration patterns compatible with ACP’s REST shape. ACP, BeeAI, A2A, and the Linux Foundation are trademarks of their respective owners; use of the protocol does not imply endorsement.

Also

Model Context Protocol (MCP) — harness tool transport
21st.dev — Live Ops chat UI patterns
Tailscale — private multi-machine mesh

See NOTICE for the full attribution text.

License

Licensed under the Apache License, Version 2.0 — free to use, modify, and distribute.
Copyright and ownership of the original work remain with MR Dula Enterprise, LLC.
Trademarks and brand assets (including the OpenGateway name and logo) are reserved.

See LICENSE and NOTICE.

_{Built by MR Dula Enterprise, LLC · matt@mrdula.solutions}

Name		Name	Last commit message	Last commit date
.github/workflows		.github/workflows
configs		configs
docs		docs
examples		examples
scripts		scripts
skills/opengateway-collab		skills/opengateway-collab
src/opengateway		src/opengateway
tests		tests
web		web
webapp		webapp
.dockerignore		.dockerignore
.gitignore		.gitignore
.python-version		.python-version
CHANGELOG.md		CHANGELOG.md
CONTRIBUTING.md		CONTRIBUTING.md
Dockerfile		Dockerfile
LICENSE		LICENSE
Makefile		Makefile
NOTICE		NOTICE
README.md		README.md
ROADMAP.md		ROADMAP.md
SECURITY.md		SECURITY.md
docker-compose.yml		docker-compose.yml
docker-entrypoint.sh		docker-entrypoint.sh
fly.toml		fly.toml
pyproject.toml		pyproject.toml
railway.json		railway.json
railway.toml		railway.toml

Navigation Menu

Repository navigation

About

Repository files navigation

OpenGateway

Why OpenGateway

Primitives

Quick start

1. Install (pick one)

2. Add an agent

3. Smoke test

4. Multi-machine

5. Connect a runner to a public hub

Advanced compatibility: manual MCP

Live Ops UI

Architecture

Security & gateways

Advanced compatibility CLI

ACP compatibility

Roadmap (headline)

Dev

Acknowledgments

Agent Communication Protocol (ACP)

Also

License

About

Releases

Packages

Contributors

Languages

Latest commit

History

Folders and files

Repository files navigation

OpenGateway

Why OpenGateway

Primitives

Quick start

1. Install (pick one)

2. Add an agent

3. Smoke test

4. Multi-machine

5. Connect a runner to a public hub

Advanced compatibility: manual MCP

Live Ops UI

Architecture

Security & gateways

Advanced compatibility CLI

ACP compatibility

Roadmap (headline)

Dev

Acknowledgments

Agent Communication Protocol (ACP)

Also

License

About

Topics

Resources

Contributing

Security policy

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages