mcp server

agentic-comm

Structured agent-to-agent and agent-to-human communication — channels, pub/sub, message routing, and presence. One .acomm file. Rust core + MCP server.

agentralabs/agentic-commcommunitylistedunreviewed

Use tool

Set up

Runs on your computer. Pick your agent and operating system.

This project does not publish an install method we can turn into a config. Follow the README instead.

README

synced Oct 21, 2026

Every AI agent is an island.

Claude can't tell GPT what it found. Your code review agent can't notify your deploy agent. Two agents working on the same project have no shared channel. Every agent works in silence.

The current fixes don't work. Shared files are race-prone -- two agents writing at once corrupt everything. Webhooks are cloud-dependent -- you need infrastructure for a simple message. Chat logs are unstructured -- no topics, no channels, no selective subscription. Database queues are heavy -- you need a server for what should be a local operation.

AgenticComm gives your agents structured communication in a single binary file. Not "send an HTTP request." Your agents have channels -- named topics with pub/sub, message ordering, delivery tracking, and persistence -- all local, all queryable in microseconds.

Problems Solved (Read This First)

Problem: agents can't talk to each other between sessions. Solved: persistent .acomm file survives restarts, model switches, and long gaps between sessions.
Problem: no structured way to coordinate multi-agent workflows. Solved: named channels with pub/sub, message ordering, and selective subscription.
Problem: messages get lost or arrive out of order. Solved: sequence-numbered messages with delivery acknowledgment and replay capability.
Problem: communication state bleeds between projects. Solved: per-project .acomm files with path-based isolation.
Problem: agent coordination requires cloud infrastructure. Solved: everything runs locally. No servers, no APIs, no cloud dependencies.

Operational commands (CLI):

acomm channel list --format json
acomm send "deploy-coord" "build complete"
acomm receive "deploy-coord" --limit 10

Seventeen MCP tools. One file holds everything. Works with Claude, GPT, Ollama, or any LLM you switch to next.

MCP Tools

AgenticComm exposes 17 MCP tools for AI agents:

Channel Tools

Tool	Description
`comm_channel_create`	Create a named communication channel
`comm_channel_list`	List channels, optionally filtered by type
`comm_channel_delete`	Delete a channel and its messages
`comm_channel_info`	Get channel metadata and statistics

Messaging Tools

Tool	Description
`comm_send`	Send a message to a channel
`comm_receive`	Receive messages from a channel
`comm_broadcast`	Broadcast a message to multiple channels
`comm_ack`	Acknowledge message receipt

Pub/Sub Tools

Tool	Description
`comm_subscribe`	Subscribe to a channel topic
`comm_unsubscribe`	Unsubscribe from a channel topic
`comm_publish`	Publish to all subscribers of a topic

Query Tools

Tool	Description
`comm_search`	Search messages by content or metadata
`comm_history`	Get message history for a channel
`comm_stats`	Get communication statistics

Context Tools

Tool	Description
`comm_context_log`	Log intent and context for communication actions
`comm_session_start`	Start a communication session
`comm_session_end`	End a communication session

MCP Prompts

comm_coordinate     -- Multi-agent coordination workflow
comm_review         -- Communication health check
comm_plan           -- Communication channel planning

Benchmarks

Rust core. Zero-copy access. Performance targets from Criterion statistical benchmarks:

Operation	Time	Scale
Send message	0.01 ms	per message
Receive message	0.01 ms	per message
Channel create	0.02 ms	per channel
List channels	0.05 ms	100 channels
Search messages	0.3 ms	1K messages
Broadcast (10 channels)	0.1 ms	per broadcast
Message history	0.4 ms	1K messages
Save file	25 ms	10K messages

Targets measured with Criterion (100 samples) on Apple M4 Pro, 64 GB, Rust 1.90.0 --release.

Capacity: Years of agent communication in a small .acomm file. Designed for long-running multi-agent coordination without growth concerns.

	Shared Files	Webhooks	Database Queues	Chat APIs	AgenticComm
Race-safe	No	Yes	Yes	Yes	Yes
Offline capable	Yes	No	No	No	Yes
Structured channels	No	Limited	Yes	Limited	Yes
Message ordering	No	No	Yes	Partial	Yes
No infrastructure	Yes	No	No	No	Yes
MCP-native	No	No	No	No	Yes

Why AgenticComm

Communication is structure, not a flat stream. When agents coordinate, they need named channels, ordered messages, selective subscription, and delivery guarantees. That's structured communication. A shared text file can never provide this.

One file. Truly portable. Your entire communication state is a single .acomm file. Copy it. Back it up. Version control it. No cloud service, no API keys, no vendor lock-in.

Any LLM, any time. Start with Claude today. Switch to GPT tomorrow. Move to a local model next year. Same communication file.

Install

One-liner (desktop profile, backwards-compatible):

curl -fsSL https://agentralabs.tech/install/comm | bash

Downloads a pre-built agentic-comm-mcp binary to ~/.local/bin/ and merges the MCP server into your Claude Desktop and Claude Code configs. Requires curl and jq. If release artifacts are not available, the installer automatically falls back to cargo install --git source install.

Environment profiles (one command per environment):

# Desktop MCP clients (auto-merge Claude Desktop + Claude Code when detected)
curl -fsSL https://agentralabs.tech/install/comm/desktop | bash

# Terminal-only (no desktop config writes)
curl -fsSL https://agentralabs.tech/install/comm/terminal | bash

# Remote/server hosts (no desktop config writes)
curl -fsSL https://agentralabs.tech/install/comm/server | bash

Channel	Command	Result
GitHub installer (official)	`curl -fsSL https://agentralabs.tech/install/comm \| bash`	Installs release binaries when available, otherwise source fallback; merges MCP config
GitHub installer (desktop profile)	`curl -fsSL https://agentralabs.tech/install/comm/desktop \| bash`	Explicit desktop profile behavior
GitHub installer (terminal profile)	`curl -fsSL https://agentralabs.tech/install/comm/terminal \| bash`	Installs binaries only; no desktop config writes
GitHub installer (server profile)	`curl -fsSL https://agentralabs.tech/install/comm/server \| bash`	Installs binaries only; server-safe behavior
crates.io paired crates (official)	`cargo install agentic-comm-cli agentic-comm-mcp`	Installs `acomm` and `agentic-comm-mcp`
PyPI (SDK)	`pip install agentic-comm`	Python SDK
npm (wasm)	`npm install @agenticamem/comm`	WASM-based comm SDK for Node.js and browser

Server auth and artifact sync

For cloud/server runtime:

export AGENTIC_TOKEN="$(openssl rand -hex 32)"

All MCP clients must send Authorization: Bearer <same-token>.

Goal	Command
Just give me agent communication	Run the one-liner above
Python developer	`pip install agentic-comm`
Rust developer	`cargo install agentic-comm-cli agentic-comm-mcp`

Python SDK (requires acomm Rust binary):

pip install agentic-comm

Rust CLI + MCP:

cargo install agentic-comm-cli       # CLI (acomm)
cargo install agentic-comm-mcp       # MCP server

Rust library:

cargo add agentic-comm

Deployment Model

Standalone by default: AgenticComm is independently installable and operable. Integration with AgenticMemory or other sisters is optional, never required.
Per-project isolation by default: each project gets its own .acomm file.

Area	Default behavior	Controls
File location	Auto-detected from project root	`ACOMM_FILE=/path/to/project.acomm`
Message retention	Unlimited	`ACOMM_RETENTION_DAYS=90`
Channel limit	256	`ACOMM_MAX_CHANNELS=256`
Auth token (server)	None	`AGENTIC_TOKEN=<token>`

MCP Server

Any MCP-compatible client gets instant access to structured agent communication. The agentic-comm-mcp crate exposes the full AgenticComm engine over the Model Context Protocol (JSON-RPC 2.0 over stdio).

cargo install agentic-comm-mcp

Configure Claude Desktop

Add to ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "agentic-comm": {
      "command": "agentic-comm-mcp",
      "args": ["serve"]
    }
  }
}

Zero-config: defaults to auto-detected .acomm in current project. Override with "args": ["--file", "/path/to/project.acomm", "serve"].

Configure VS Code / Cursor

Add to .vscode/settings.json:

{
  "mcp.servers": {
    "agentic-comm": {
      "command": "agentic-comm-mcp",
      "args": ["serve"]
    }
  }
}

Standalone

# Run directly
agentic-comm-mcp serve

# With explicit file
agentic-comm-mcp --file /path/to/project.acomm serve

AgenticComm is independently installable and operable. No other Agentra sister is required. Integration with AgenticMemory, AgenticIdentity, or other sisters is optional and additive.

Quickstart

1. Install

curl -fsSL https://agentralabs.tech/install/comm | bash

2. Create a channel

acomm channel create "code-review" --type direct

3. Send a message

acomm send "code-review" "Found 3 issues in auth module, see PR #42"

4. Receive messages

acomm receive "code-review" --format json

5. Ask your agent

After install and MCP client restart, ask your agent:

Send a message to the deploy-coord channel saying the build passed

The agent calls comm_send and persists it to your .acomm file.

What messages are in the code-review channel?

The agent calls comm_receive and returns the message history.

Common Workflows

Multi-agent coordination -- Create a channel for deployment coordination:

acomm channel create "deploy" --type pubsub
acomm send "deploy" "build passed on commit abc123"
acomm send "deploy" "staging deploy complete"

Code review handoff -- Pass findings between review and fix agents:

acomm channel create "review-findings" --type direct
acomm send "review-findings" "SQL injection in auth.rs line 42"

Status broadcasting -- Broadcast status to all subscribed agents:

acomm broadcast "CI passed" --channels "deploy,monitor,notify"

Message search -- Find relevant communication history:

acomm search "deploy" --channel "deploy" --limit 20

Communication health -- Check channel statistics:
```
acomm stats --format json
```

How It Works

AgenticComm models agent communication through channels and messages in a custom binary format. Each channel has its own message ordering, subscription tracking, and delivery guarantees. The file is portable across models, clients, and deployments.

The core runtime is written in Rust for performance and safety. All state lives in a portable .acomm binary file -- no external databases, no managed services. The MCP server exposes the full engine over JSON-RPC stdio.

Core concepts:

Concept	What	Example
Channel	Named communication endpoint	"deploy-coord", "code-review"
Message	Structured payload with metadata	Content, sender, timestamp, sequence number
Subscription	Agent registration to a channel	Agent A subscribes to "deploy" topic
Broadcast	One-to-many message delivery	Status update to all monitoring channels
Acknowledgment	Delivery confirmation	Agent B acknowledges receipt of message #42

Channel types: direct . pubsub . broadcast

The binary .acomm file uses fixed-size records (O(1) access), LZ4-compressed content, and memory-mapped I/O. No parsing overhead. No external services. Instant access.

+-------------------------------------+
|  HEADER           64 bytes          |  Magic (ACOM) . version . channel counts . feature flags
+-------------------------------------+
|  CHANNEL TABLE    fixed-size rows   |  name . type . subscriber_count . message_count . created_at
+-------------------------------------+
|  MESSAGE TABLE    fixed-size rows   |  channel_id . sender . content_ref . seq_num . timestamp . acked
+-------------------------------------+
|  SUBSCRIPTION TABLE  fixed-size     |  channel_id . subscriber_id . filter . created_at
+-------------------------------------+
|  CONTENT BLOCK    LZ4 compressed    |  UTF-8 text for message content and metadata
+-------------------------------------+

Validation

Suite	Tests
Rust core engine	planned	Channel operations, message ordering, file format
Stress tests	planned	Boundary conditions, heavy load, edge cases
CLI integration	planned	Workflow and command-line tests
MCP server	planned	Protocol, tools, prompts, sessions

Repository Structure

This is a Cargo workspace monorepo containing the core library, MCP server, CLI, and FFI bindings.

agentic-comm/
├── Cargo.toml                    # Workspace root
├── crates/
│   ├── agentic-comm/             # Core library (crates.io: agentic-comm)
│   ├── agentic-comm-cli/         # CLI (crates.io: agentic-comm-cli)
│   ├── agentic-comm-mcp/         # MCP server (crates.io: agentic-comm-mcp)
│   └── agentic-comm-ffi/         # FFI bindings (crates.io: agentic-comm-ffi)
├── python/                       # Python SDK (PyPI: agentic-comm)
├── paper/                        # Research papers
├── docs/                         # Documentation
└── scripts/                      # CI and guardrail scripts

Running Tests

# All workspace tests (unit + integration)
cargo test --workspace

# Core library only
cargo test -p agentic-comm

# Stress tests
cargo test --test "*stress*" --test "*boundary*" --test "*edge*"

# Benchmarks
cargo bench -p agentic-comm

Sister Integration

AgenticComm works standalone, but integrates with other Agentra sisters:

AgenticIdentity: Messages signed with identity receipts. Channel access controlled by trust grants.
AgenticMemory: Communication history linked to memory nodes. Message context enriches the memory graph.
AgenticVision: Visual observations shared via comm channels. Screenshot notifications delivered to subscribed agents.
AgenticCodebase: Code review findings communicated through structured channels. Deployment coordination via pub/sub.
AgenticTime: Scheduled message delivery. Channel activity decay tracking.
AgenticContract: Communication agreements enforced by contracts. Channel SLAs and delivery guarantees.

The .acomm File

Your agents' communication. One file. Forever yours.


Format	Binary communication graph, portable
Works with	Claude, GPT, Llama, any model

Two purposes:

Persistence: Channels, messages, and subscriptions survive across sessions
Coordination: Load into ANY model -- suddenly agents can communicate

The model is commodity. Your .acomm is value.

Privacy and Security

All data stays local in .acomm files -- no telemetry, no cloud sync by default.
Per-project isolation ensures communication data never bleeds between projects.
Message content is stored with integrity checksums to detect corruption.
Channel access can be controlled through AgenticIdentity trust grants.
Server mode requires an explicit AGENTIC_TOKEN environment variable for bearer auth.

Contributing

See CONTRIBUTING.md. The fastest ways to help:

Try it and file issues
Add an MCP tool -- extend communication capabilities
Write an example -- show a real use case
Improve docs -- every clarification helps someone