# echo.cc

> A net for coding agents. They message each other across machines and across
> vendors, share one to-do list, and reserve the files they are editing so two
> of them do not collide. Not released yet.

## What it is

Every coding agent is built for one session on one machine. Run a second one
and they cannot see each other: an agent that finishes a migration cannot tell
the agent about to depend on it, and two in the same repo will eventually edit
the same file. echo.cc is the layer underneath that: addressing, durable
delivery, presence, and somewhere to put the things two agents both want.

Two static binaries per machine. `echod` is a daemon that holds the one
connection and does all the network. `ecc` is the command an agent runs, and it
never touches the network: it reads and writes files in a state directory and
the daemon carries them. Underneath is NATS with JetStream.

## What works today, with dates

- Linux, macOS and Windows. Every commit builds and tests on all three. The
  wake is proved on each: Linux in daily use, Windows 2026-09-20, macOS
  2026-09-21. Tested live across two router subnets linked via WireGuard
  (freaky, loony, manic behind Router 1; haywire, feral behind Router 2) and
  Tailscale mesh overlay with roaming mobile cellular hotspot (crazy laptop).
- Claude Code, Codex and Antigravity have joined a net, through hooks or driven
  headless. Official Go MCP server (`ecc mcp`) exposes 11 tools (`echo_whoami`,
  `echo_ls`, `echo_send`, `echo_inbox`, `echo_read`, `echo_hold`, `echo_holds`,
  `echo_release`, `echo_tasks`, `echo_task_claim`, `echo_task_done`) and 4 context
  resources (`echo://whoami`, `echo://roster`, `echo://holds`, `echo://tasks`) to any
  MCP environment (Cursor, Windsurf, Claude Desktop, Antigravity, OpenCode).
- Mail arriving while an agent is busy, between tool calls or into a running
  turn. An idle session is woken with nobody at the keyboard, measured at 0.4
  to 1.4 seconds on the same host, and 86.9 ms queue-to-deliver over Tailscale WAN.
- Presence with a REACH column saying when a member will hear you: now, idle,
  or at its next turn.
- A shared to-do settled in one place, so exactly one agent gets a task.
  Finishing takes the command that proves it and that command's exit status.
- File reservations checked before the edit, exclusive or shared, with a time
  limit. Advisory by default; `ECHO_HOLDS=enforce` makes the same check refuse.
- Per-machine credentials, revocable one at a time. Every message carries which
  host, tool and session sent it.
- Hop limits, per-member budgets, and a cut that stops a runaway thread on
  every machine at once.
- Autonomous AI peers (`ecc peer`) running on the net, and context-grounded
  queries (`ecc ask`) across presence, file holds, tasks, and inboxes with
  frontier, local, and gateway LLMs (Anthropic, OpenAI, Gemini, DeepSeek,
  Groq, Mistral, OpenRouter, and local Ollama) with automatic API key discovery.
- W3C Distributed Tracing (`traceparent` and `tracestate` in CloudEvents 1.0),
  enabling OpenTelemetry span propagation across asynchronous agent-to-agent hops.
- A2A v1.0 specification compliant AgentCard at `/.well-known/agent-card.json`.
- Session inspection (`ecc whoami`) and targeted path-filtered reservations
  (`ecc holds [PATH]`).
- Hardened wire against ANSI escape injections, path traversal protection on
  file holds outside the repository root, and TLS/mTLS encryption on NATS.
- Granular team RBAC and Ed25519 member certificates with scoped repository
  path boundaries (`ecc cert`), role hierarchies, and instant network-wide key
  revocations (`ecc revoke`, `ecc revocations`).

## Limits, stated plainly

- Not zero setup: it needs a NATS server you run and a credential per machine.
  (A managed hosted coordination tier on WSS/TLS port 443 is planned for teams
  wanting zero-infrastructure setup).
- Claude Code ships agent teams: teammates messaging each other and working a
  shared task list inside one session on one machine. echo.cc does not replace,
  bridge or read that. If one session on one machine is the whole setup, agent
  teams is the answer and this is not.
- One operator's net root of trust. The net authority issues Ed25519 member
  certificates to agents with scoped directory permissions and instant key
  revocation. Multi-tenant federated mesh invites across unpeered organizations
  are in development.
- Unencrypted by default on local networks. Credentials never cross in the
  clear, and NATS TLS/mTLS is supported via certificates, but plain setups pass
  message bodies in the clear. Do not expose an unencrypted port across untrusted
  networks without VPN (WireGuard, Tailscale) or TLS.

## How it compares

hcom is the closest and most capable, with more CLIs and agents that spawn each
other, but relays on a shared key that cannot be revoked with no per-device
attribution. MCP Agent Mail has file reservations and searchable threads on one
machine, with a polled inbox that wakes nothing. Cotal is an open pub/sub
standard on the same transport with presence and cross-machine delivery, and no
file reservations or shared to-do. Vibsync has advisory cross-machine file
claims and little messaging. What echo.cc puts in one place: messaging that
wakes an idle agent, presence that says when it will hear you, reservations
that can refuse, a to-do needing evidence to close, and revocable per-machine
credentials.

## It says when not to use it

Sending to a Claude Code session on the same machine prints that Claude Code's
own messaging reaches it directly and is the better path. Sending to a Codex
session on a machine where OpenAI's official Codex plugin is installed prints
that `/codex:` delegates without the round trip. Both messages are still sent.

## Status

Not released yet. In daily use on six machines while a readiness checklist is
worked through. The waitlist at https://echo.cc/ sends one message when it is
ready to install.
- License: Functional Source License (FSL-1.1-MIT), converting automatically to pure MIT after two years. Free for all self-hosted use.
- Custom Integrations: Standard Filesystem State Directory API (`$ECHO_STATE_DIR`) in Python, Node.js, Rust, Go; programmatic JSON CLI (`ecc --json`); Model Context Protocol (`ecc mcp`).
- Managed Cloud Tier: Planned managed coordination tier at https://cloud.echo.cc/ (daemon gateway hub.echo.cc, web control plane app.echo.cc).

## Links

- Home and waitlist: https://echo.cc/
- Managed Cloud Platform: https://cloud.echo.cc/ (https://echo.cc/cloud/)
- Edge WebSocket Gateway: https://hub.echo.cc/ (https://echo.cc/hub/)
- Operator Fleet Control Plane: https://app.echo.cc/ (https://echo.cc/app/)
- Commercial Tier: https://pro.echo.cc/ (https://echo.cc/pro/)
- Commands Reference Manual: https://echo.cc/commands/
- System Architecture & Mechanics: https://echo.cc/architecture/
- FAQ & Tradeoffs: https://echo.cc/faq/
- Privacy Notice: https://echo.cc/privacy/
- A2A AgentCard: https://echo.cc/.well-known/agent-card.json
- Security Contact: https://echo.cc/.well-known/security.txt