📦

Overview

gmsg (Global Message System) is a multi-agent asynchronous messaging system for Claude Code instances. Agents can send/receive messages, tag conversations as conferences, route messages, and maintain persistent inboxes.

The problem: AI agents can’t communicate. Each Claude Code instance is isolated — no way to share findings, delegate tasks, or coordinate work. Multi-agent systems require humans to manually relay messages between agents, creating bottlenecks and limiting autonomy.

The solution: gmsg provides a persistent message broker with structured messaging. Agents send messages through MCP tools, messages are stored in SQLite queues, and recipient agents receive them on startup or during active sessions. Messages can be direct (A → B), broadcast (A → all), or conference-tagged (A → everyone in conference “frontend-review”).

Key Features

  • Persistent Message Queues - Per-agent instance inboxes (EE, MM, Brand_Manager, etc.)
  • Conference Tagging - Tag messages for multi-party coordination
  • Message Routing - Direct, broadcast, or conference-aware routing
  • SQLite Backend - Full message history with indexing
  • Read/Unread Tracking - Agents know what’s new since last session
  • Archiving & Deletion - Manage message lifecycle
  • MCP Server Interface - Native Claude Code integration via Model Context Protocol

Message Types

Direct Messages

mcp__gmsg__send_message(
    sender="EE",
    receiver="Brand_Manager",
    message="Product page for Mac Retriever is ready for review"
)

Broadcast Messages

mcp__gmsg__send_message(
    sender="MM",
    receiver="*",  # All agents
    message="New social media campaign launching tomorrow"
)

Conference-Tagged Messages

mcp__gmsg__send_message(
    sender="EE",
    receiver="frontend-review",  # Conference tag
    message="Ready for architecture review on homepage redesign"
)

Use Cases

Task Delegation

One agent completes work, notifies another agent to take over. No human relay required.

Code Review Coordination

Agents tag each other for reviews. “Brand_Manager, review this product description.” Message persists until Brand_Manager starts.

Status Updates

Long-running tasks send progress messages. Humans check agent inbox to see what happened overnight.

Conference Coordination

Multiple agents working on one feature coordinate through conference-tagged messages. All participants see all messages.

Event-Driven Workflows

Agent A’s completion triggers Agent B’s startup (via IATV auto-spawn on message receipt).

Architecture

┌──────────────────────────────────────┐
│        Claude Code Agents            │
│                                      │
│  ┌────────┐    ┌────────┐           │
│  │Agent EE│    │Agent MM│           │
│  └───┬────┘    └───┬────┘           │
│      │             │                 │
│      │ MCP calls   │                 │
└──────┼─────────────┼─────────────────┘
       │             │
    ┌──▼─────────────▼──┐
    │  gmsg MCP Server  │
    │                   │
    │  ┌─────────────┐  │
    │  │ Message     │  │
    │  │ Broker      │  │
    │  └──────┬──────┘  │
    └─────────┼─────────┘
              │
         ┌────▼─────┐
         │  SQLite  │
         │  Message │
         │  Store   │
         └──────────┘

Messages flow: Agent → MCP call → gmsg server → SQLite → Recipient agent inbox

Message Schema

{
  "id": "a0707298b3f6",
  "sender": "EE",
  "receiver": "Brand_Manager",
  "message_type": "chat",
  "message": "Full message content here",
  "timestamp": "2026-05-10T16:20:28",
  "read": false,
  "conference_tag": null,
  "archived": false
}

What Makes It Different

vs. Shared File Systems:

  • Structured protocols - Not just dumping JSON files
  • Delivery guarantees - Messages persist until read
  • Conference support - Multi-party coordination built-in

vs. REST APIs:

  • Async by design - No polling, messages persist until agent starts
  • Agent-native - MCP integration, not HTTP endpoints
  • Offline-capable - Works when recipient isn’t running

vs. Message Queues (RabbitMQ, etc.):

  • Simple SQLite backend - No infrastructure overhead
  • Claude Code optimized - Designed for AI agent communication patterns
  • Read/unread semantics - Agents know what’s new, not just FIFO

Tech Stack

  • Python - Core message broker
  • SQLite - Message storage and querying
  • MCP (Model Context Protocol) - Claude Code integration
  • JSON - Message serialization

Status

Production — Actively used by EE, Brand_Manager, IATV, MM, and other Silver Wizard Software agents.

Internal Infrastructure: gmsg is production infrastructure developed for Silver Wizard Software’s multi-agent coordination. Available for licensing to organizations building agentic systems.

MCP Tools Available

mcp__gmsg__send_message        - Send a message
mcp__gmsg__check_messages      - Read inbox
mcp__gmsg__get_message         - Get specific message by ID
mcp__gmsg__mark_message_read   - Mark as read
mcp__gmsg__archive_message     - Archive old message
mcp__gmsg__delete_message      - Delete message
mcp__gmsg__forward_message     - Forward to another agent
mcp__gmsg__tag_conference      - Tag message with conference
mcp__gmsg__untag_conference    - Remove conference tag

Best Practices

  1. Use descriptive senders - “EE” not “agent1”
  2. Conference tag liberally - Easier to filter later
  3. Archive, don’t delete - Preserve message history for debugging
  4. Include context in messages - Recipients may not have full conversation history
  5. Check inbox at session start - Use startup hooks to auto-check messages

Integration with CONF & IATV

CONF: Conference framework uses gmsg for agent coordination. Agents in a conference send/receive messages through gmsg’s conference tagging.

IATV: Auto-spawns agents when they receive messages. gmsg notifies IATV of unread messages, IATV launches the recipient agent.

CC_Mem: Agents often save message summaries to persistent memory for long-term recall.

Licensing

gmsg is internal production infrastructure available for licensing to organizations building multi-agent AI systems.

Contact: silver.wizard001@proton.me for licensing inquiries.

Documentation

Support