- Category
- AI Agents
- Rank
- No. 940Tools index
Previous survey · No. 902 ·
- Pricing
- Open Source
- Type
- TOOL
- Use case
- Agent Building
- Interfaces
- CLI
- Builder
- @izutorishima
- GitHub
- 1.5k stars
- Latest release
- v1.5.3
- Date
About
agmsg is a cross-vendor messaging system that lets CLI AI coding agents (Claude Code, Codex, Gemini CLI, GitHub Copilot) communicate directly with each other through a shared local SQLite database. It eliminates the need for humans to manually copy-paste between agents, enabling multi-agent collaboration without any daemon, server, or complex infrastructure — just bash and SQLite.
What it does
Instead of a person relaying text between separate coding-assistant sessions, agmsg gives every session an identity made of a name and a team, then runs a hook after each response that checks for anything new addressed to it and drops that text into the session's own context. Two terminals running entirely different assistants can then hand a task, a review, or a status update back and forth without anyone acting as the go-between. A companion desktop app lays several of these sessions out as panes in one window, and the installer figures out which assistant is running so it wires up the matching hook automatically.
Why it's ranked here
The design goes deeper than the pitch: three independent, swappable layers separate how messages are stored, how a given agent type is addressed, and how it notifies someone, so a setup is not locked to one vendor's hook format or one database engine. The codebase explains its own edge cases in comments, tracing real bugs back to a stale terminal default and to messages missed across git worktrees, which reads as a project that has been hardened by use rather than assembled once and left alone. An optional remote-sync tier adds real encryption for teams that want it, off by default but resistant to being silently turned off.
What's good
The security write-up is unusually candid: it names three distinct adversaries, states plainly which properties are provided against each, and calls out in the same breath what is not, such as leaving peer identity verification to the operator and admitting that who is talking to whom stays visible to the server. The desktop client shows the same instinct at a smaller scale, refusing a dropped file path outright rather than silently stripping control characters out of it and risking a different, wrong path being used. Small decisions like that, made consistently, are what separate a working demo from something a team can actually depend on.
Tradeoffs
None of that safety is automatic, though. Encryption for the remote-sync path is off unless a team explicitly turns it on, so a deployment that skips that step gets no confidentiality at all despite the security document existing. The pitch of needing only a shell and a database holds for local use, but several real features quietly add more: launching a peer agent needs a JavaScript runtime, and the remote control plane needs Python, each with its own version and detection quirks to work around. Windows support runs entirely through a Bash compatibility layer; there is no native Windows implementation.
How to use it well
This fits a person running two or more different coding assistants side by side on one machine and tired of pasting output between their windows: point-review requests, status pings, and small handoffs are exactly its size. Use the built-in role switching to keep one identity for architecture questions and another for implementation work on the same project, and use the spawn feature with an initial task attached for any assistant that has no way to notice a message once it goes idle. It is not a fit for cross-machine or cross-organization sync without deliberately turning on encryption yourself and trusting whoever holds the other keys.
Technical notes+
server/src/app.ts implements the optional remote-sync reference server as a Fastify plugin; its scopedTeamId and requireProtocol helpers enforce a protocol-version header and a team id instead of any credential, with an inline comment defending that choice on the ground that reaching the server over the network is itself the permission boundary. server/src/index.ts wires that app to a Postgres pool and runs a migration step before listening. bin/agmsg.js is the published npm entry point: installRef reads the local package.json version to pick a matching git tag before fetching setup.sh, and printNotACommand checks the user's actual install directory before naming a script, rather than assuming the documented layout is present. app/src/App.tsx is the desktop client's main component; shellPaneFrom builds a terminal pane from a resolved login shell with no bash fallback, and hasUnsafeDropPath rejects any dropped file path containing control characters before it is written into a live terminal. docs/design.md lays out the identity model (an agent is a name plus a team, with a hook-driven inbox check after each response) and a tiered dependency table separating a bash/sqlite core from opt-in encryption and remote features that add Python or Node. docs/security.md documents the remote-sync protocol against three named adversaries and states that the default cipher is none, that peer identity binding is the operator's job, and that message metadata is visible to the server. docs/spec/driver-interface.md formalizes the storage_* function set (storage_send, storage_watch_after, storage_history, and others) that any storage backend must implement, including exact stdout/exit-code framing rules. ARCHITECTURE.md documents the three-axis (storage, agent, delivery) driver model that the above files implement pieces of.
Observed
- License
- MIT.
- Language
- Implementation spans three languages: Bash for the core scripts, TypeScript for an optional Fastify-based remote sync server, and a Tauri desktop application with a React frontend.
- Packaging
- Distributed as an npm bootstrapper package that downloads and executes a separate shell installer, plus a Claude Code plugin marketplace entry and a direct git-clone install path.
- Interfaces
- command-line scripts invoked through per-agent slash or dollar-sign commands, a machine-readable line-based directive protocol for host-agent coordination, an HTTP JSON API on the optional remote sync server, and a separate desktop GUI.
- Platform support
- macOS and Linux natively; Windows requires Git Bash, with no PowerShell implementation.
- Structural
- The npm package's own test script only prints the installed version; it does not exercise the installer or runtime logic.
- Persistence
- Local storage is SQLite in WAL journaling mode with no persistent daemon; the optional remote-sync tier adds a Postgres-backed server and a Node-based sync client.
- Structural
- The npm package.json manifest lists no runtime dependencies.
Read from README.md, package.json, server/src/app.ts, server/src/index.ts, app/src/App.tsx, bin/agmsg.js, docs/design.md, docs/security.md, docs/spec/driver-interface.md, ARCHITECTURE.md.
What it can do
Send a message from one CLI AI agent to another
Agent identifier and message content → Message stored in shared SQLite database, delivered to target agent
Enable cross-vendor AI agent communication
Messages from Claude Code, Codex, Gemini CLI, or GitHub Copilot → Interoperable message exchange between different AI agent vendors
Store and retrieve inter-agent messages locally
Agent-to-agent messages → Persisted message records in a local SQLite database
Poll or read pending messages for a specific agent
Agent identifier → List of messages addressed to that agent
Coordinate multi-agent workflows without human relay
Autonomous agent tasks requiring collaboration → Direct agent-to-agent task handoffs and responses without human copy-pasting
Run agent messaging with no server or daemon setup
Bash environment with sqlite3 installed → Functional peer-to-peer messaging system requiring zero infrastructure configuration
Tags
Tech Stack
Comments (0)
No comments yet
Editorially curated, with community endorsements as a secondary signal. Corrections welcome.