Synapse

Synapse is a self-hosted workspace in which the conversation, not the bot, is the runtime boundary. Workspace members, native actors, bridged remote agents, and external instant-messaging identities share one thread, and participants, transcript visibility, actor sessions, wakeups, and memory handoff are scoped to it — there is no standalone, API-invoked session. Everything those participants can reach, from plugins and skills to devices, sandboxes, event sources, and memory spaces, is authorized at the workspace layer through explicit, revocable grants.

An agent already running elsewhere can join as a first-class participant. A machine-side daemon bridges Claude Code and Codex CLI into conversations over an outbound WebSocket, keeping their own runtime, tools, and model accounts. The bridge pulls rather than receives pushes: the remote agent fetches messages and posts replies through a per-conversation reverse-MCP tool surface, and a request for input or plan approval arrives as a task card any eligible participant can answer.

Eight instant-messaging transports — Feishu (Lark), WeChat, WeCom, DingTalk, QQ, Telegram, the WhatsApp Cloud API, and WhatsApp over the unofficial web protocol — map an inbound chat one-to-one onto a conversation, joining the sender as an external participant and waking the configured actor.

Actors can also reach real machines and isolated compute. A paired desktop, Linux server, or cloud Docker host exposes filesystem, command-line, browser (Chrome DevTools), and computer-use capabilities as MCP tools; devices dial out to the control plane and every operation travels as a signed envelope. A session-scoped sandbox — a local process, a Docker container, or an off-box E2B-compatible VM — is provisioned when a turn starts and destroyed when the session idles, while working files persist as content-addressed snapshots other actors can pick up.

Memory lives in permissioned memory spaces shared through the same grants ledger. Retrieval runs every turn and combines lexical search with embeddings, so a fact saved in one conversation surfaces in later ones sharing that space. The project describes itself as in an early design and implementation phase, with schemas and runtime contracts still changing and backward compatibility for old data not yet guaranteed.

Features

• Four participant kinds: workspace members, native actors, bridged remote agents, and external IM identities in one thread
• Actor-to-actor wakeups: an actor's message lands as a durable wakeup for another actor, so handoffs happen inside the transcript
• Shareable teammates: actors and remote agents shared like contacts by QR code or friend ID with owner approval
• Remote agent bridge: a machine-side daemon connects external coding agents over an outbound WebSocket through a reverse-MCP tool surface
• Single grants ledger: actors, plugins, skills, runtime capabilities, memory spaces, and event sources all authorized against workspaceresourcegrants
• Consume-once approvals: a blocked sensitive call becomes an in-chat card; approving replays the original call server-side and consumes the grant
• Governed device access: filesystem, command line, browser, and computer-use capabilities on paired machines, granted per capability and conversation
• Session sandboxes: local process, Docker, or off-box E2B-compatible VM, opt-in through SANDBOX_PROVIDER and off by default
• Event-driven work: schedules, webhooks, and GitHub or GitLab events wake conversations through the same durable wakeups as human messages
• Lossless context: archive chains plus a live tail, bounded by compaction that never rewrites history
• Pluggable providers: embedding, OCR, document extraction, transcription, and real-time ASR through environment-selected APIs or self-hosted sidecars
• Capability-aware device catalog: each device probes and advertises the CLI tools present on that machine