compare / envoy
Aethereum vs Envoy
Envoy and Aethereum both keep agents coordinated across machines, underneath whatever agents you already use, but they draw the line in different places. Envoy is a shared-context layer: agents in a space share messages, tasks, decisions, evidence, and provenance, and can claim work and continue across sessions and machines. Aethereum is narrower and interface-focused: agents share the shapes of the interfaces they build, and a dependent agent is warned the moment one of those contracts changes, before it merges. Envoy syncs state; Aethereum coordinates the interfaces where agents collide.
compared here: Envoy (Statecraft Protocol), shared-state layers across machines
The honest comparison
Capability by capability. Green means yes, amber means partial, a dash means no. Where Envoy is genuinely stronger, the table says so.
| capability | Aethereum | Envoy |
|---|---|---|
| Cross-machine coordination | yesagents on different machines share one brain | yescross-machine is its core, on the paid Connected tier |
| Cross-developer awareness | yesyour agent sees a teammate's uncommitted change | partialshares tasks + decisions, not interface changes |
| Works with any MCP agent | yesClaude Code, Cursor, Codex, anything MCP | yesframework- and IDE-agnostic |
| Shared interface contracts | yesdeclare_contract, versioned + dependency-aware | noshares state + tasks, not interface shapes |
| Contract negotiation | yespropose, push back, finalize a shape change | nodecisions + approvals, not interface negotiation |
| Collision alert before merge | yeswarned the moment a dependency changes | nonot interface-aware, no pre-merge alert |
| Operator directives | yesone standing order pins to every agent's context | partialroles + decisions, not a pinned directive |
| Soft-lock claims | yesclaim a file, overlap is flagged to others | yesagents claim tasks in a space |
| Tickets / work assignment | yesassign tickets to agents from the cockpit | yestask state with claims |
| Durable team memory | yesdecisions + plan persist across sessions + machines | yesdecisions + evidence persist across sessions |
| Live dashboard | yeswatch the whole fleet coordinate in real time | noCLI and protocol, no fleet dashboard |
| CLI cockpit | yesaethereum mission to steer from the terminal | yesCLI-based |
| GitHub / Slack / Linear | partialintegrations are early | nonot its focus |
| MCP-native | yesthe whole surface is MCP tools | partialits own protocol, works alongside MCP agents |
| No source code shared | yesonly the interfaces an agent publishes leave the machine | partialevidence can carry files + command output |
| Zero-install / quick setup | yesone command, about thirty seconds | yeslocal spaces, no signup |
| Pricing | yesfree to start, no card | partiallocal free; cross-machine $15/mo |
where aethereum is stronger
- Shares versioned interface contracts, the thing two agents actually disagree on.
- Warns a dependent agent the moment a contract changes, before merge.
- Has a contract-negotiation handshake: propose, push back, finalise a shape change.
- Free to start right now, including cross-machine, with no card.
- Never carries your source: only the interfaces an agent publishes leave the machine.
where envoy is stronger
- A broader shared-state layer: tasks, decisions, evidence, provenance, and audit, not just interfaces.
- Roles, authority, invites, and scoped permissions inside a space.
- Local spaces are free and offline; a general coordination substrate.
When to use which
use aethereum: Use Aethereum when the thing breaking your agents is the interface between them: a contract that changes and silently breaks a dependent. You want the alert before merge, plus negotiation, and you do not want to share source.
use envoy: Use Envoy when you want a general shared-state layer across agents and machines: tasks, decisions, evidence, and audit, beyond just interfaces.
Common questions
What is the difference between Aethereum and Envoy?
Envoy syncs shared state (tasks, decisions, evidence) across agents and machines. Aethereum is interface-focused: it shares the shapes of the interfaces agents build and warns a dependent the moment one changes, with a negotiation handshake. Envoy is broader; Aethereum is sharper on the interface-collision case.
Do Aethereum and Envoy overlap?
Partly. Both coordinate agents across machines underneath the tools you already use. They can be complementary: Envoy for general state, Aethereum for interface contracts and pre-merge collision alerts.
Is Aethereum free across machines?
Yes, everything is free right now, including cross-machine, with no signup or card. Envoy's cross-machine Connected tier is paid during early access.
Give your agents a shared brain.
Free, no signup, no card. One command, about thirty seconds. Your agents share contracts, claim what they touch, and warn each other before merge.
get started free →