One Node process. Many agents. Route Discord, Slack, and CLI messages through
your local claude, spawn long-running work into tmux,
and let the bots talk to each other.
No API keys — just your Claude Code subscription.
Gateways are plugins. The router picks the agent. The session manager loads
JSONL. The context builder composes identity, history, and skills. Then
claude runs. Stateless, crash-safe,
bounded only by your subscription.
No message bus. No queue. No database. Everything is a file on disk —
~/.ccgateway/ is yours to grep, version, and back up.
┌──────────────────────────────────────────────────────┐ │ ccgateway (single process) │ │ │ │ ┌─────────┐ ┌─────────┐ ┌────────────────┐ │ │ │ Discord │ │ Slack │ │ CLI · future │ │ │ └────┬────┘ └────┬────┘ └────────┬───────┘ │ │ └─────────────┼──────────────────┘ │ │ ↓ │ │ ┌──────────────┐ │ │ │ ROUTER │ (channel → agent) │ │ └──────┬───────┘ │ │ ↓ │ │ ┌──────────────┐ │ │ │ session mgr │ jsonl per channel │ │ └──────┬───────┘ │ │ ↓ │ │ ┌─────────────────┐ │ │ │ context builder │ identity + skills │ │ └────────┬────────┘ + memory + history │ │ ↓ │ │ ┌──────────────┐ │ │ │ claude │ │ └──────────────┘ │ └──────────────────────────────────────────────────────┘
No API keys. No billing surprises. ccgateway shells out to claude with your local Claude Code install. Concurrency is bounded only by your plan.
Each agent is a workspace with its own CLAUDE.md, SOUL.md, and avatar. Point ccg at a folder — identity lives in files, not a database.
Per-agent bots with per-agent avatars. Socket-mode Slack, so no public URL or ngrok needed. Bindings map channel → agent → gateway in config.json.
A Haiku triage pass classifies each turn. Long jobs spawn into detached tmux sessions with full tool access. Attach live to watch the agent work.
Pair it with loom-local-mcp-server and agents can consume video links — transcripts and keyframes fold into the turn context. Optional, BYO MCP.
Salt DMs Pepper the same way a human would — same avatar, same routing, same session persistence. No special bus, no out-of-band protocol.
Skills are plain Markdown files under ~/.ccgateway/skills/. The router mounts them into the turn context when triggers match. Write one in under a minute.
Generates a ccgateway.service unit with one command. Runs as your user, logs to journalctl, restarts cleanly. It's just a Node process — treat it like one.
Kick off a full RCA pipeline from a Discord thread. The agent watches the Loom, parses the branch, spawns a tmux session, and streams status back as it runs. The bot you trained is the bot that answers — same persona, same memory, same skills.
/new, /reset, /status, /stopallowedTools per agentmemory/rca/WORK-9807.md and post to
#salt for Dad's approval.
ccgateway doesn't ship video support, but it plays nicely with MCP. Pair it with loom-local-mcp-server (a companion project) and any agent can consume a Loom link: frames, audio, transcript, all folded into the turn. Optional, BYO setup.
Point ccgateway at your existing OpenClaw config and it lifts agents, bindings, tokens, plugins, and heartbeats. Dry-run first to see the diff, then commit when you're happy. Zero copy-paste.
Still stuck? Open an issue on GitHub or drop into the community Discord — we read every thread.
No. ccgateway shells out to your local claude binary. Whatever subscription is logged in there is what the agents use. If you can run claude --print "hello" from your terminal, ccgateway works.
The CLI itself enforces your plan's concurrency and quota. ccgateway queues turns per-agent and surfaces back-pressure to the gateway so Discord and Slack get a "thinking…" indicator instead of a timeout. If the CLI errors, the error goes back to the channel as a message.
On disk, in plain files. Each channel gets a JSONL session under ~/.ccgateway/agents/<id>/sessions/. Long-term memory is whatever Markdown files live in the agent's workspace — MEMORY.md, memory/YYYY-MM-DD.md, skills. Version-control it, back it up, grep it.
Yes, and it's the same path a human message takes. Agent A calls ccg send B "…", which posts into B's gateway just like a Discord DM. B runs a turn, replies, A sees the reply in its own context. No special bus, no bespoke protocol — just the same router everyone else uses.
Each agent has an allowedTools list in its workspace config. Each gateway has an allowlist of users/channels that can invoke it. Bot tokens live in .env and are never written into sessions or logs. Skills can declare required permissions the host enforces on every turn.
Use WSL. ccgateway is developed and tested on Linux (incl. WSL) and should work on macOS. The tmux-backed async path needs a POSIX environment, so native Windows isn't supported today.
No. ccgateway is an independent open-source project by @Slaycaster, released under MIT. It's a harness around Claude Code, not from Anthropic. Trademarks belong to their respective owners.
No signup, no waitlist, no dashboard. Clone the repo, wire your bot tokens, and your team's Discord is answered by agents you actually trained.