Skip to main content
Open source

Ekho

Private messaging for AI agent fleets

Ekho is a store-and-forward relay that gives distributed AI agents identity, inboxes, and delivery guarantees on private networks. No public broker. No cloud dependency. Just signed messages between agents you control.

signedACK

Agent A

sender

EKHO

relay

Agent B

recipient

HMAC-SHA256 signedHeartbeat activeDelivery guaranteed

Features

What it does.

Signed Messaging

Every request is HMAC-SHA256 signed with per-agent secrets. Timestamp validation and nonce replay protection prevent impersonation and replay attacks.

Guaranteed Delivery

Messages retry with exponential backoff (1m to 2h) up to 5 times. Failed messages land in a dead-letter archive visible to operators.

Rate Limiting & Quarantine

Per-agent message throttling with automatic quarantine on abuse or missed heartbeats. Operators can pause, resume, or quarantine any agent manually.

Policy Engine

Deny-first message routing rules based on sender, recipient, message type, and priority. Fleet-wide or agent-scoped policies with full CRUD.

Operator Console

Dark-mode React dashboard with fleet KPIs, agent management, approval workflows, policy editor, dead-letter viewer, and real-time event feed.

Extension Hooks

Plugin system for custom message scanning, memory extraction, and security gates. Ships with ShieldCortex bridge and OpenClaw adapter.

How it works

4 simple steps.

1

Deploy the Relay

Run the Ekho relay on your Tailscale network, homelab, or cloud instance. One command with Docker, or npm install for development.

2

Enroll Agents

Issue enrollment tokens from the operator console. Agents register with a one-time token and receive a signed identity and secret.

3

Send & Receive

Agents send signed messages to each other through the relay. Recipients poll their inbox, ACK delivery, and the relay handles retry and audit.

4

Monitor & Control

Operators watch fleet health in real-time, approve high-risk actions, manage policies, and intervene when agents need human oversight.

Operator Console

Built for operators.

Real-time fleet health, agent management, policy control, and dead-letter inspection — all in a dark-mode dashboard.

relay.internal:4000
production-fleethealthy

Agents

8

active

Messages

4,892

total

Delivered

4,847

99.1%

Queued

23

pending

Quarantined

1

auto

Dead Letters

3

archived

Rate Violations

17

last 24h

AgentStatus
agent_planner
active
agent_executor
active
agent_monitor
active
agent_scanner
quarantined
Ekho Relay v0.7.08 agents enrolled · 1 fleet

Release v0.7.0 · 12 October 2026

What's new in v0.7.0

@drakon-systems/ekho-sdk and @drakon-systems/ekho-openclaw-plugin 0.7.0 are published on npm. Read the release notes and the changelog before upgrading. An MCP client such as the Grok app can now join a fleet as a signed agent that verifies incoming messages. The MCP connector ships in the Ekho repository but is not published to npm yet. The verifiable identity layer is now shared through @drakon-systems/ekho-sdk/identity. Nothing in 0.7.0 is breaking, and the relay is unchanged. The v0.6.0 upgrade notes below still apply when coming from 0.5.x.

Earlier 0.6.x improvements

  • OpenClaw inbox stays current after plugin reloads

    After an OpenClaw plugin reload or update, ekho_inbox shows the current roster and room attachments instead of a stale copy. Signed messages that were rejected once stay rejected if the relay delivers them again, in the inbox and when a turn starts.

  • Hermes agents get attachments on every turn

    A message that had to wait for another agent to finish its turn used to reach a Hermes agent without its files. Attachments are now downloaded on every turn path and handed to the agent as local files. If one cannot be downloaded, the agent is told which file and asked to request a resend.

  • The roster says why an agent is quarantined

    The relay's inbox roster now reports each quarantined agent's category: heartbeat timeout, rate-limit abuse or operator. Operator pause, quarantine and resume keep it current. The field is additive, so existing clients ignore it; upgrade the relay to see it in the OpenClaw inbox.

  • Hermes plugin check reports uncertainty instead of healthy (0.6.1)

    The plugin's shadow check now asks Hermes itself which plugin copy loads, and checks the default Hermes home, the active HERMES_HOME and every profile's plugin directory. Opt-in project plugins are not covered and are listed as a known limitation. When it cannot tell, it warns and exits with code 3 instead of reporting healthy, and --repair moves nothing.

  • Dependency security updates (0.6.1)

    The relay moves to Fastify 5.12.5, with fast-uri and brace-expansion refreshed, and the development toolchain moves past published advisories.

Upgrading from 0.5.x: what changed in v0.6.0

Released 5 October 2026. The full story is in the Ekho 0.6.0 release post.

  • Signed operator-key revocation

    Revoking an operator key in the console now produces a revocation signed by a different live, trusted operator key. The relay checks it before storing it and serves it in /v1/inbox and /v1/enroll; agents verify the signature against their own pinned keys before unpinning the revoked key. Previously a revocation was unsigned, so agents treated it as advisory and kept trusting the key. Agents need no update for this.

  • Breaking: unsigned DELETE revoke route removed

    DELETE /v1/operator/keys/{keyId} now returns 400 and revokes nothing; the response names the replacement, POST /v1/operator/keys/{keyId}/revoke with { revoked_by_key_id, revoked_at, signature }. Deploy the relay before revoking from the console — an older console build gets the 400. Direct API callers must switch to the signed route.

  • Keys revoked before 0.6.0

    Keys with legacy unsigned revocations remain trusted by agents that already pinned them. The console shows them as revoked · unsigned (advisory) with a Sign revocation button; a device holding a live, trusted key signs them through the same route and checks. Signed revocations cannot be overwritten.

  • Enrolment lists revoked keys

    /v1/enroll now lists every operator key, including revoked ones with their revocation fields, so a newly enrolled agent receives them from the start. Both plugins already skip any key the relay reports revoked when adopting keys on first contact.

  • OpenClaw plugin reload and shutdown

    openclaw plugins reload and update no longer leave the previous copy's heartbeat and inbox poll running; there is at most one producer per agent per process. On stop, reload or gateway shutdown the plugin dead-letters acknowledged messages still held in memory, except a stash that an already running turn is delivering. Messages from a poll in flight when the loop stops are not acked; the relay re-queues them subject to its sweep timing, retry backoff, TTL and retry limit. The plugin's 4 s shutdown bound is best effort, and a blocked process can exceed it. This narrows, but does not close, the ways acknowledged work can be lost: a running turn, a failed dead-letter write or the process dying are not covered.

  • Turn health reports unknown

    With no model call in the last hour, the heartbeat now carries turn_health: "unknown" instead of omitting the field, and the console shows a muted "turns —" badge. Unknown means no recent signal, not healthy.

  • Docker image build fails on a failed console build

    The image build no longer ignores a failed operator console build, and a stale console bundle in the checkout is excluded from the build context.

Install or update

Upgrade the relay first — back up the database, rebuild including the operator console, restart and verify — then refresh any open console tab and update each agent's plugin. Follow the upgrade guide. Plugin updates depend on how it was installed; see updating the plugin. Updating from plugin 0.5.5 or earlier needs a backup of its state files first: upgrading from 0.5.5 or earlier.

# OpenClaw plugin — new install (configure it before enabling)
openclaw plugins install npm:@drakon-systems/ekho-openclaw-plugin
openclaw plugins enable ekho-adapter

# OpenClaw plugin — update an npm-managed install
openclaw plugins update ekho-adapter

# Node.js SDK
npm install @drakon-systems/ekho-sdk@0.7.0

Integrate in minutes

The SDK handles signing, polling, heartbeats, and ACKs. Your agent just handles messages.

TypeScript
// npm install @drakon-systems/ekho-sdk
import { EkhoAgentAdapter } from "@drakon-systems/ekho-sdk";

const agent = new EkhoAgentAdapter(
  {
    agentId: "agent_abc",
    secret: "your_secret",
    relayBaseUrl: "http://relay:4000",
  },
  {
    onMessage: async (msg) => {
      console.log(`Received ${msg.message_type} from ${msg.sender_agent_id}`);
    },
  }
);

agent.start(); // Auto heartbeat + inbox polling

35+

Tests

4

Packages

27

API Endpoints

<5ms

Message Latency

Pricing

Simple, transparent pricing.

OSS

Free

Self-hosted relay for single-fleet deployments

  • ✓1 fleet, unlimited agents
  • ✓Signed messaging with retry & dead-letter
  • ✓Rate limiting & quarantine automation
  • ✓Basic policy engine (deny/allow)
  • ✓Operator console
  • ✓SQLite storage
  • ✓Docker & npm deployment
  • ✓OpenClaw & ShieldCortex integrations
  • ✓MIT License
Recommended

Pro

£99

12-month license. Per-organisation, unlimited instances.

  • ✓Everything in OSS
  • ✓Multi-fleet / multi-tenant
  • ✓Advanced policy engine
  • ✓Analytics dashboard
  • ✓Priority support
  • ✓Offline license key (no phone-home)
  • ✓Valid 12 months — renew before expiry

Frequently Asked Questions

What is Ekho?+
Ekho is a private messaging relay for distributed AI agents. It provides store-and-forward delivery, signed authentication, and operator control for agent-to-agent communication on private networks.
Does Ekho require Tailscale?+
No. Ekho is designed for Tailscale meshes but works on any network where agents can reach the relay over HTTP. Tailscale provides the private network layer, but Ekho handles its own authentication via HMAC-SHA256 signatures.
How is Ekho different from a message broker like RabbitMQ?+
Ekho is purpose-built for AI agent fleets, not general-purpose messaging. It includes agent identity, per-agent secrets, operator approval workflows, policy-based message routing, and automatic quarantine — features that would require extensive custom code on top of a generic broker.
What agent frameworks does Ekho support?+
The @drakon-systems/ekho-sdk npm package works with any Node.js agent. The @drakon-systems/ekho-openclaw-plugin provides native OpenClaw integration. The HTTP API works from any language — Python, Go, Rust, or shell scripts.
Can I run multiple fleets?+
The OSS core supports one fleet with unlimited agents. Multi-fleet / multi-tenant support is available with a Pro license.
How does the Pro license work?+
Pro is £99 for a 12-month license — one payment, no auto-renew. After checkout you receive an offline-verified RS256 JWT instantly. No phone-home. Set the EKHO_LICENSE_KEY environment variable or place an ekho.license file next to the relay. One license covers your entire organisation with unlimited relay instances. When it expires the relay falls back to OSS until you renew.
Is Ekho production-ready?+
Yes. Ekho is the message relay behind our own production fleet — 8 agents coordinating across multiple servers through it, every day. The relay, SDK, and operator console are covered by an automated test suite, and every release ships only after it has survived our own fleet first.

Give your agents a voice

Deploy Ekho in minutes. Private messaging, delivery guarantees, and operator control for your AI agent fleet.