Skip to main content
Glama
sanztheo

claude-intercom

by sanztheo
OverviewSchemaRelated ServersScoreDiscussions
TypeScript
Local

📡 claude-intercom

Real-time messaging between Claude Code instances. When one agent sends a message, the others get it instantly — no polling, no manual checks.

Built as an MCP server + filesystem watcher that wakes idle agents automatically via asyncRewake.

How it works

Terminal 1                          Terminal 2
┌─────────────────────┐            ┌─────────────────────┐
│ claude (agent sgup)  │            │ claude (agent 4jov)  │
│                      │            │                      │
│ > send("4jov",       │ ──JSON──▶ │ 📬 sgup: tu touches  │
│   "tu touches        │   file    │    auth.ts ?          │
│    auth.ts ?")       │            │                      │
│                      │ ◀──JSON── │ > reply("Non,        │
│ 📬 4jov: Non,        │   file    │   je suis sur        │
│   je suis sur billing│            │   billing")          │
└─────────────────────┘            └─────────────────────┘

  • Each instance gets a unique 4-char code (e.g. x7k2) on startup

  • Messages are JSON files in a shared store/ directory

  • A fs.watch watcher detects new files instantly and wakes the receiving agent

  • Dead agents are auto-cleaned via PID checking

Related MCP server: agent-comms-mcp

Install

# Clone
git clone https://github.com/sanztheo/claude-intercom.git ~/.claude/mcp-intercom

# Install deps
cd ~/.claude/mcp-intercom && bun install

1. Register the MCP server

Add to ~/.mcp.json:

{
  "mcpServers": {
    "intercom": {
      "type": "stdio",
      "command": "bun",
      "args": ["~/.claude/mcp-intercom/src/server.ts"]
    }
  }
}

2. Add the auto-notification hooks

Add to ~/.claude/settings.json under "hooks":

{
  "hooks": {
    "PreToolUse": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "bun ~/.claude/mcp-intercom/src/hook.ts",
            "timeout": 3000
          }
        ]
      }
    ],
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "bun ~/.claude/mcp-intercom/src/watcher.ts",
            "asyncRewake": true,
            "timeout": 300000
          }
        ]
      }
    ],
    "SessionStart": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "bun ~/.claude/mcp-intercom/src/watcher.ts",
            "asyncRewake": true,
            "timeout": 300000
          }
        ]
      }
    ]
  }
}

3. (Optional) Add the skill

Copy skill/SKILL.md to ~/.claude/skills/intercom/SKILL.md so agents proactively coordinate.

MCP Tools

Tool

Description

who

List active agents (filtered by project by default)

send

Send a message to an agent or broadcast to "all"

reply

Reply to a message (auto-acks the original)

peek

Check inbox for unread messages

ack

Acknowledge and delete a message

ack_all

Clear entire inbox

Auto-notification

Three layers ensure agents never miss a message:

Layer

When

How

Watcher (SessionStart + Stop)

Agent is idle

fs.watch on inbox dir → exit(2) → asyncRewake wakes the model

Hook (PreToolUse)

Agent is working

Checks inbox before every tool call

Skill (always active)

Agent makes decisions

Guides agent to announce work and check messages

Architecture

~/.claude/mcp-intercom/
├── src/
│   ├── server.ts    # MCP server — 6 tools, auto-generated agent codes
│   ├── store.ts     # Filesystem store — presence, messages, sessions
│   ├── hook.ts      # PreToolUse hook — checks inbox on every tool call
│   └── watcher.ts   # fs.watch — instant detection, asyncRewake push
├── skill/
│   └── SKILL.md     # Always-active skill for proactive coordination
└── store/           # Runtime data (gitignored)
    ├── presence/    # {code}.json — agent registration + PID
    ├── messages/    # {code}/*.json — per-agent inboxes
    └── sessions/    # {pid}.code — PID-to-agent-code mapping

Session linking (how the hook finds "its" agent)

The MCP server and hooks both run as children of the same Claude Code process. On startup, the server writes its agent code to sessions/{pid}.code for each PID in its ancestor chain. The hook walks up its own ancestor chain and matches against these files — the common ancestor (Claude Code) is the link.

Requirements

License

MIT

This server cannot be installed

A
license - permissive license
-
quality - not tested
D
maintenance

How are these scores calculated?

Maintenance

–Maintainers
–Response time
–Release cycle
–Releases (12mo)
Commit activity

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Servers

  • Claude Slack

    theo-nash
    A
    license
    -
    quality
    D
    maintenance
    Enables structured team communication for Claude Code agents through Slack-like channels and direct messages. Supports project isolation, subscription management, and agent notes for sophisticated multi-agent collaboration workflows.
    Last updated
    21
    8
    MIT

  • hato

    severzemlya
    A
    license
    -
    quality
    B
    maintenance
    Enables inter-session messaging for Claude Code, allowing sessions on different machines to send messages to each other, with delivery as user turns and support for offline queuing.
    Last updated
    35
    MIT

View all related MCP servers

Related MCP Connectors

  • AgentDrive

    Cross-agent artifact workspace with provenance across Claude Code, Codex, Cursor, LangGraph.

  • RogerRat

    Real-time chat hub for AI agents — Claude Code, Cursor, Cline, Codex over MCP or REST.

  • Apuchat

    Real-time chat hub for AI agents — Claude Code, Cursor, Cline, Codex over MCP or REST.

View all MCP Connectors

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/sanztheo/claude-intercom'

If you have feedback or need assistance with the MCP directory API, please join our Discord server