When to Use echo.cc (and When Not To)
Multi-agent tooling introduces coordination overhead. Choosing the right architecture requires honest boundary assessment:
- Single Agent, Short Task: If you are running a single coding assistant in one terminal to inspect a bug or write a small function, you do not need echo.cc. Your existing coding assistant may be sufficient.
- In-Process Multi-Turn Sessions: If your agents operate strictly within a single vendor's interactive desktop harness on the same host, native in-session mechanisms may be simpler than multi-host coordination.
- Where echo.cc is useful: Running multiple agents concurrently in one codebase across machines, delegating resource-heavy jobs to remote workstations without losing context, sharing advisory file reservations before edits overlap, and coordinating tasks across heterogeneous model providers.
Practical workflows
1. Parallel Software Development with File Reservations
The Problem: When two autonomous agents work in the same repository simultaneously, they frequently edit the same files or overwrite shared schemas, causing merge collisions or silent overwrites.
How echo.cc Helps: Before touching code, participating agents declare path-scoped file reservations (ecc hold <path> --note "...") and claim atomic task leases (ecc task claim <task-id>).
- Frontend Worker: Holds
site/andweb/paths to implement a responsive form. - Backend Worker: Holds
cmd/andinternal/api/to modify endpoints. - Reservation Enforcement: By default, reservations are advisory. When participating pre-tool edit hooks are installed and configured with
ECHO_HOLDS=enforce, conflicting edits to held paths are refused before disk bytes are modified. - Recorded Evidence: Finishing a task requires recording the caller's verification command and exit status (
ecc task done <id> --command "make check"). echo.cc stores this execution evidence; it does not independently execute or certify the test suite.
2. Cross-Machine Test & Build Delegation
The Problem: A developer working on a lightweight laptop cannot run intensive test matrices, native multi-platform builds, or large local AI models without stalling their primary session.
How echo.cc Helps: The laptop agent uses ecc send --to <remote-worker> "Run test matrix" to dispatch a structured task request over NATS JetStream.
- Laptop Agent (macOS): Dispatches compilation or test suite request with a summary and continues reasoning turns or pauses.
- Dedicated Server (Linux): A daemon-supervised worker wakes at its prompt boundary (
REACH idle), claims the task, executes the build in its native environment, and replies with receipts and output. - Decoupled Local Transport: The daemon queues messages across temporary disconnects; delivery is subject to broker stream retention, message TTL, network partition duration, and recipient identity.
3. Asynchronous Handoffs Across Disconnects
The Problem: An agent completes a task while the operator's laptop is closed, or a dependent worker is temporarily disconnected during network roaming.
How echo.cc Helps: Server-mediated durable queues hold messages across disconnect intervals subject to configured message time-to-live.
- Producer: Records task completion evidence and queues the handoff message (
ecc send --to <peer> "Migration complete"). - Broker Retention: NATS JetStream retains the message subject to time-to-live and stream retention limits.
- Delivery on Reconnect: When the destination host reconnects, the daemon drains the message to local disk and delivers it to an active, eligible session without keystroke automation. Stored messages do not preserve live in-flight process execution or restart an ended session.
Planned workflows
We distinguish actively verified coordination primitives from planned architectural designs:
- Deterministic Review Gates (Planned Design): An operator-controlled policy engine where completed task receipts mandate independent peer review and attested check passes before acceptance. This is a planned design rather than an implemented runtime enforcement mechanism; recording a task as done does not enforce independent review.
- Multimodal Pipeline Coordination (Design Stage): Typed artifact transports bridging text coordination to local media generation pipelines (TTS, ASR, image editing, video generation). Artifact references use URI and hash pointers; arbitrary media payloads are not streamed through control envelopes.
- Minimal-Team Research Swarms (Deferred Agenda): Experiments comparing small teams with a single strong model on independently checked results, time, and cost. This is a future research agenda, not a currently shipped feature.
Limits to plan for
- No Automatic File Sync: echo.cc coordinates message queues, reservations, and tasks. It is not a distributed filesystem like NFS or Dropbox. Code sharing across machines relies on git remotes, explicit commit hashes, or offline bundles.
- No Subjective AI Judges: The coordination substrate does not judge whether code is elegant or correct. That responsibility belongs to deterministic linters, test suites, and human reviewers.
- Operator Authority & Planned Limits: Operators configure allowed tools, sandbox boundaries, and role permissions. Automated shared budget accounting and dynamic pool scaling are active designs rather than fully shipped runtime protections.