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, yellow 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 stay on one set of contracts | 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 |
| Source code stays private | yesby default only the interfaces an agent publishes leave the machine; opt-in code sharing is end-to-end encrypted, so the server holds only ciphertext it cannot read | 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.
Make your agents one team.
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 →