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.
Structured agent-to-agent and agent-to-human communication — channels, pub/sub, message routing, and presence. One .acomm file. Rust core + MCP server.
Stars
5
Tools
—
Uptime
—
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.
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.
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
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:
# 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.
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.
Add an MCP tool -- extend communication capabilities
Write an example -- show a real use case
Improve docs -- every clarification helps someone
A
Agentic Comm
agentralabs·5 stars·
Structured agent-to-agent and agent-to-human communication — channels, pub/sub, message routing, and presence. One .acomm file. Rust core + MCP server.
No tool list yet. Remote servers get one after the first health check.
FAQ
Questions
How do I install Agentic Comm?
Copy the stdio config for Cursor, Claude Desktop, Claude Code, or VS Code on this page. It uses the publisher's install, not a PlugMCP proxy.
Does Agentic Comm need an API key?
No required environment variable is listed on this record.
What transport does Agentic Comm use?
Agentic Comm runs locally over stdio.
When was Agentic Comm last checked?
Last checked 2026-10-27. Structured agent-to-agent and agent-to-human communication — channels, pub/sub, message routing, and presence. One .acomm file. Rust core + MCP server.