株式会社オブライト
AI2026-06-26

What Is agmsg? Cross-Vendor Messaging for CLI AI Coding Agents

[agmsg](https://github.com/fujibee/agmsg) is an open-source (MIT) cross-vendor messaging tool for CLI AI coding agents by fujibee (official site agmsg.cc).

It lets Claude Code, Codex, Gemini CLI, GitHub Copilot CLI, Antigravity, and OpenCode talk to each other through a shared local SQLite file — so humans stop being the copy-paste courier between tools. Tagline: "You stop being the copy-paste courier between your agents."

Highlights:
- Only dependencies are bash and sqlite3 — no daemon, no network, no Python
- Three delivery modes — `monitor` (~5s real-time push), `turn` (between-turn polling), or `both`
- N-agent teams, role switching (`actas`), spawning new agents (`spawn`), and clean teardown (`despawn`)
- Not MCP, not subagents, not a message queue — a peer-to-peer messaging layer between sessions
- One-line install: `npx agmsg`
- Claude Code Plugin Marketplace: `/plugin install agmsg@fujibee-agmsg`

Product Hunt #5 Product of the Day on June 9, 2026 (219 upvotes, 39 comments). GitHub stars 859, v1.1.1 (June 25, 2026). Community-built derivatives include agmsg-shogi, agmsg-go, and agmsg-mcp.

Oflight's take: unlike Loop Engineering or Sakana Fugu's orchestration model, agmsg occupies a different niche — peer-to-peer messaging at the same layer, across tools. It's an especially natural fit for the Claude Code Agent View parallel-orchestration workflows, and the most pragmatic way to stitch multi-vendor LLMs into one dev workflow. The article closes with three direct inquiry funnels for AI agent environment setup and custom integration.


TL;DR — What Is agmsg?

[agmsg](https://github.com/fujibee/agmsg) is an MIT-licensed open-source messaging tool that lets CLI AI coding agents talk to each other, created by fujibee (official agmsg.cc).

Three points:

1. Shared conversation across different tools — Claude Code, Codex, Gemini CLI, GitHub Copilot CLI, Antigravity, and OpenCode can exchange messages with each other 2. Only dependencies are bash and sqlite3 — no daemon, no network, no Python, no framework 3. Product Hunt #5 Product of the Day on June 9, 2026 (219 upvotes), GitHub stars 859

The tagline says it best: "You stop being the copy-paste courier between your agents."

The Problem It Solves

In 2026, developers routinely use multiple CLI AI agents in parallel — Claude Code to implement, Codex to review, Gemini CLI for spec questions, Copilot CLI to draft PRs, Antigravity for quick tasks (a workflow our Claude Code Agent View and cmux Manaflow columns also describe).

The bottleneck is the human acting as a copy-paste courier between tools: paste Claude Code's output into Codex, take Codex's reply and paste it into Gemini, paste Gemini's answer back into Claude Code. That manual relay sits in the middle of otherwise high-leverage cognitive work — the human becomes the slow part.

agmsg automates that relay through a single SQLite file. Each agent reads from and writes to the same SQLite DB — so messages flow between tools without any human in the middle.

Architecture — Just Bash and SQLite

AspectChoice
Runtime depsbash + sqlite3 only (no Python, no Node, no Docker)
StorageSQLite WAL mode (`~/.agents/skills/<cmd>/db/messages.db`)
Identity`(name, team)` tuple (project path is metadata)
ConcurrencyWAL mode — many readers, one writer
NetworkNone (local filesystem only)
DaemonNone (no resident process)
BrokerNone (the SQLite file is the floor; the agents are the players)

The design insight: typical "multi-agent messaging" reaches for ZeroMQ / NATS / Redis Pub/Sub. agmsg sticks with a single SQLite file. Everything you need for inter-process sharing (persistence, concurrency, transactions) is already inside SQLite.

Three Delivery Modes — monitor / turn / both

You pick how new messages reach an agent:

`monitor` (real-time push, ~5s interval): implemented via Claude Code's SessionStart hook plus a background stream. New messages can interrupt mid-conversation. Best for tight back-and-forth.

`turn` (between-turn polling): inbox is checked after each agent reply (stop hook). Checks only at turn boundaries — doesn't interrupt the agent's thinking, best for long tasks.

`both` (hybrid): combine both modes.

A cooldown control via marker files (`run/.lastcheck-<agent>`, default 60s) prevents over-polling — a thoughtful production-ready detail.

Supported Agents

As of June 26, 2026, agmsg officially supports:

- Claude Code (Anthropic's official CLI, uses `/agmsg`) - Codex (OpenAI, `$agmsg`) - Gemini CLI (Google, `$agmsg`) - GitHub Copilot CLI (`$agmsg`) - Antigravity (`$agmsg`) - OpenCode (`$agmsg`)

The slash-command vs `$`-prefix split respects each tool's command-naming conventions.

Commands

Common usage in Claude Code:

/agmsg                            # Check inbox
/agmsg send alice "deploy done"   # Send to a peer
/agmsg team                       # List team members
/agmsg history                    # Message log
/agmsg mode monitor               # Change delivery mode
/agmsg actas tech-lead            # Switch identity
/agmsg spawn codex reviewer       # Launch new agent in another terminal
/agmsg despawn reviewer           # Tear down

Direct from shell/scripts:

~/.agents/skills/agmsg/scripts/send.sh team from to "message"
~/.agents/skills/agmsg/scripts/inbox.sh team agent_id
~/.agents/skills/agmsg/scripts/history.sh team

Plain Bash, easy to wire into CI/CD: have a GitHub Actions job write to agmsg, and let a Claude Code session running in another terminal pick it up and run the post-deploy work.

Install

Fastest (npm/npx):

npx agmsg

From source:

git clone https://github.com/fujibee/agmsg.git
cd agmsg
./install.sh

Claude Code Plugin Marketplace:

/plugin marketplace add fujibee/agmsg
/plugin install agmsg@fujibee-agmsg
/reload-plugins

Automated setup:

bash <(curl -fsSL https://raw.githubusercontent.com/fujibee/agmsg/main/setup.sh)

Only requires bash + sqlite3 — works out of the box on macOS, Linux, and WSL.

What It Isn't — vs MCP, Subagents, Message Queues

agmsg's clarity comes partly from what it explicitly is not:

❌ Not MCP (Model Context Protocol): MCP is LLM ↔ tool-server protocol. agmsg is agent-session ↔ agent-session. Different layer. No MCP server required.

❌ Not subagents (child processes): Claude Code's subagent feature and Sakana Fugu's orchestration imply parent-child hierarchy. agmsg is peer-to-peer between equal sessions. No hierarchy.

❌ Not a message queue (RabbitMQ / NATS / etc.): those need a broker. agmsg works with just a SQLite file. The mental model: the SQLite file is the floor, the agents are the players.

Result: drops into an existing agent setup without changing it — install agmsg into a running Claude Code session and Claude Code's behavior is unchanged.

Traction

June 2026 numbers:

- Product Hunt June 9, 2026: #5 Product of the Day (219 upvotes, 39 comments) — agmsg on Product Hunt - GitHub stars: 859 (as of June 26, 2026) - Commits: 145 total - Language mix: Shell 92.6% / JavaScript 7.4% - Latest: v1.1.1 (June 25, 2026)

Community derivatives:

- agmsg-shogi — agents play shogi against each other - agmsg-go — agents play Go - agmsg-mcp — bridges agmsg to MCP

Making two agents play shogi or Go is a great proof of the core idea — peer-to-peer agent dialog at play.

Use Cases

(1) Multi-vendor dev workflow: Claude Code implements → Codex reviews → Gemini sanity-checks the spec — no human copy-pasting in between.

(2) Role-split agent team: spin up "architect", "coder", "reviewer", "tester" in separate terminals or tools, switch roles with `actas`, expand the team dynamically with `spawn`.

(3) CI/CD integration: a GitHub Actions step writes a message to agmsg; another agent picks it up and runs the follow-up work. Deploy → Slack notification → agent-driven post-mortem.

(4) Long-task monitoring: with `monitor` mode, another agent receives completion notifications in real time.

(5) Research and play: agent-versus-agent simulations like agmsg-shogi.

Oflight's View — How We'd Use It

We can introduce agmsg into customer engagements through our AI consulting and software development practices in three ways:

Pattern 1: The implementation layer of a multi-LLM-vendor strategy

Sakana Fugu's orchestration model consolidates multi-vendor LLMs on the cloud-API layer; agmsg consolidates them on the CLI-developer layer. Used together, you get redundancy on both layers — structural resilience against precedents like the Claude Fable 5 export-control suspension.

Pattern 2: OpenClaw + agmsg as an agent workshop

Combine our OpenClaw setup service with agmsg and you get OpenClaw agents ↔ Claude Code / Codex / Gemini integration, mediated by a single SQLite file. The wiring work fits inside our OpenClaw monthly maintenance plans.

Pattern 3: Implementing the [Loop Engineering](../columns/loop-engineering-ai-agent-paradigm-2026-06) Maker-Checker pattern across tools

Maker (Claude Code generates code) and Checker (Codex reviews) run in different tools, linked through agmsg. A practical productionization of the Loop Engineering thesis.

Caveats

- Local only — single-machine communication. Remote dev environments (Cloud Workstation / Codespaces) need extra plumbing. - No protocol-level ordering — agmsg is transport only; ordering and ACK are the agents' job. - Security — local SQLite access only; no auth or encryption built in. On multi-user servers, set file permissions deliberately. - Young ecosystem — Product Hunt launch was June 9, 2026. Spec may still shift. - Japan-origin OSS — the author (fujibee) appears to be a Japanese engineer; there's an active Japanese community thread around the project.

Talk to Us About AI Agent Environments — Three Inquiry Funnels

We help design, build, and operate multi-agent environments that include agmsg.

(1) Evaluation & Requirements (from ¥198,000)

"Does agmsg fit our team's workflow?" "How does it pair with OpenClaw / Claude Code Plugin?" "What's the right multi-LLM-vendor strategy?" — 1–2 week assessment, written report deliverable.

(2) Custom Development & SI (from ¥498,000)

Build a multi-agent automation system around agmsg — CI/CD integration, internal knowledge flow, Slack/Teams hooks, tuned to your operations.

(3) OpenClaw + agmsg Integration & Ongoing Maintenance (¥9,800–¥80,000/month)

We wire agmsg into existing OpenClaw deployments so OpenClaw agents talk to Claude Code / Codex — and keep them maintained as the LLM landscape moves.

FAQ

Q1. How is this different from MCP? A. MCP is LLM ↔ tool-server protocol. agmsg is session ↔ session peer messaging. Different layer; you can use both together. Q2. Is it a Slack / Teams replacement? A. No. agmsg has no human-facing UI. It's purely for agent-to-agent traffic. You may inspect logs, but you wouldn't run a team chat on it. Q3. Local only? Can it work in the cloud? A. Local only — agents share a SQLite file on the same machine. For cloud / Codespaces, you'd need shared filesystem plumbing (NFS / S3FS / Tailscale + sshfs); community forks may extend that path. Q4. Security? A. Filesystem permissions are your boundary. No auth or encryption. On multi-user Linux servers, set `chmod` / `chown` carefully. Q5. Ordering guarantees? A. agmsg is transport-only. Ordering and ACK live in the agent protocol. SQLite WAL gives you ACID on individual writes. Q6. Commercial use? A. MIT — go for it. Commercial use, modification, redistribution all OK, no extra contract. Q7. Versus Sakana Fugu? A. Sakana Fugu consolidates multi-LLM on the cloud API. agmsg consolidates multi-tool on the CLI. Different layers; combine both for end-to-end multi-vendor. Q8. Combining with OpenClaw? A. Our OpenClaw gives you an agentic-coding platform; agmsg bridges it to external Claude Code / Codex / Gemini agents. A mixed team of OpenClaw-internal and external agents.

Bottom Line

agmsg is the standout simple-and-practical OSS of June 2026.

With just bash and SQLite, it solves a real and universal developer pain — stitching multi-vendor CLI AI agents into one workflow — with the minimum possible dependencies. The Product Hunt #5 finish and 859 GitHub stars at launch say the problem is widely felt.

The four takeaways:

1. Just bash and sqlite3 — drops into existing environments 2. Claude Code / Codex / Gemini / Copilot / Antigravity / OpenCode all supported 3. Not MCP, not subagents, not a queue — peer messaging is its own layer 4. MIT, public [GitHub](https://github.com/fujibee/agmsg), public [agmsg.cc](https://agmsg.cc/) — commercial use is free

Oflight designs, builds, and operates multi-agent environments that include agmsg. Use the three inquiry funnels above to get in touch.

References

Feel free to contact us

Contact Us