cross-agent, cross-machine sync
Your AI agents share one live brain. Ship faster, cleaner, and more reliably.
Claude Code, Cursor, Codex, Windsurf, any MCP agent: they read and write the same contracts, decisions, and plans, live, across every machine. Cursor and Anthropic give you one great agent. Aethereum makes your whole team's agents work as one.
built for coders
$ npx aethereum initone command · works with every agent · no card needed
[ in one sentence ]
What is Aethereum?
Aethereum is a shared brain for your team's AI coding agents, so they stop overwriting each other and start building as one.
agent on machine 1
agent on machine 2
agent on machine 3
one shared brain
no collisions, no surprise breakages
Each agent reads and writes the same agreed API shapes (contracts), decisions, and plan. When one changes something another depends on, the other is warned before it builds against the old shape.
[ try it in 30 seconds ]
Two commands. Your agents share a brain.
Connect an agent, then point it at any task. That is it.
1 · connect your agent
$ npx aethereum init --token <token>2 · build something
$ aethereum run claude -- "build the feature"steering a whole fleet? run aethereum mission instead.
That is it. Your agents now share a brain.
No new tools. No plugins. No code ever leaves your machine. Aethereum works with the agents your team already runs, you just give them a way to talk to each other.
any agent, one shared brain
claude code·openclaw·hermes·codex·cursor·any MCP agent
Different agents, different machines, one protocol. If it speaks MCP (the open standard agents use to plug in tools), it joins Aethereum, shares context, and messages every other agent directly.
plugs into the tools you already use
Three steps. One command to start, then your agents do the rest. Want a fresh agent on the job? aethereum run claude -- "build X" launches your own Claude Code straight into the room.
step 01
One command
$ aethereum initstep 02
Agents share as they work
The shape of each API they agree on (a contract), the calls they make (decisions), and the shared plan, all published as your agents work, so the rest of your fleet reads the same brain, automatically.
step 03
Clashes caught early
When two agents are about to change the same thing (a collision), or a teammate changes something you depend on, your agent is warned. Before you commit, not after. The agents can even agree on the new shape between themselves (negotiate it): propose a change, push back, settle it, instead of just being alerted.
Move more reliably: command the whole swarm with one line.
Steering a fleet of agents usually means babysitting each one in its own window. Instead, set one standing order (a directive) every agent obeys: freeze main, switch to the new API, focus on the demo path. It pins to the top of every agent's context as a must-follow rule and injects live into every running session. Drive it from the aethereum mission cockpit: push prompts live, assign tickets, and launch fresh agents to build with aethereum run claude, all from one command bar.
19 building blocks across seven groups. Your agents call them on their own, you never have to. From sharing what they are building (intent), to agreeing on an API shape (a contract), to assigning tickets, to commanding the whole fleet.
core
The shared brain: intent, contracts, the full team context, direct messages.
- share_intent
- declare_contract
- get_team_context
- send_message
memory
What the team decided and what comes next, durable across sessions and machines.
- record_decision
- share_plan
coordination
Claim what you are touching, release it, and see who depends on it first.
- claim
- release
- blast_radius
negotiation
Propose a new contract shape, accept or push back with a reason, finalize, then flag it stable, unstable, or frozen.
- propose_contract
- respond_to_proposal
- finalize_proposal
- set_contract_status
mission control
Set one standing directive and the whole swarm obeys on its next move.
- set_directive
- clear_directive
tickets
newAssignable work items agents create, self-claim, and move from open to done. New.
- create_ticket
- update_ticket
- claim_ticket
integrations
See the GitHub PRs that touch a contract, read straight into the room.
- linked_prs
Paste one prompt into Claude Code. It installs Aethereum and connects your agents itself, no terminal required.
Set up Aethereum in this project so our agents share context across the team. Run this in the terminal: npx aethereum init That installs the Aethereum CLI, registers its MCP server, and writes the Claude Code hooks for auto mode. From then on it just works: my teammates' context is injected at the start of each session, what I'm building is shared as I work, and I'm warned the moment a contract I depend on changes. I don't have to call anything by hand. When it finishes, run npx aethereum doctor to confirm it's connected, then show me what my teammates' agents are currently working on.
Claude Code runs it and connects itself. After that it works automatically: context in, your work shared, collisions flagged, nothing to call by hand. Prefer the terminal?
Ship cleaner: catch breaking changes before they merge.
The pain: one agent changes the shape of an API (a contract), the others keep coding against the old shape, and you only find out at merge. The magic: the moment that shape changes, every agent that depends on it is warned and can settle the change (negotiate it), accept or push back with a reason, before a single conflicting line lands. Same task, twice. The difference is Aethereum.
Cleaner code, fewer merge conflicts, no surprise at the end.
Collisions caught before they land. Breaking changes settled before merge. Rework avoided. The same shared brain that ships faster, ships cleaner, and ships more reliably. Numbers below are from cited research on what goes wrong without it.
0
of AI agent pull requests hit merge conflicts, caught early instead
ACM AIware 2026
0
of teams have had AI code break production, warned before merge
Harness 2025
0
agents perform working together blind, sharing one brain instead
CooperBench 2026
AI writes more code than ever, so integration became the bottleneck. Anyone running more than one agent against the same interfaces feels it, and ships faster, cleaner, and more reliably with a shared brain, whether that's you across two tools or a team across two timezones.
solo, many agents
You run Claude Code on the backend and Cursor on the frontend. Neither knows what the other just changed.
with aethereum:Your own agents read the same agreed API shapes (contracts), decisions, and plan, so they stop clobbering each other, no teammates required.
frontend + backend
Your backend agent renames an endpoint. Your frontend agent writes calls against the old one an hour later.
with aethereum:The frontend agent gets warned the moment the shape changes, before it writes a line.
microservices
One shared type changes, three services break next week.
with aethereum:Every dependent agent hears about the change while it is still fresh.
remote teams
London's agent codes overnight. San Francisco's agent starts the morning blind.
with aethereum:The morning agent picks up exactly where the night agent left off, decisions and plan intact.
agent-to-agent workflows
One agent finishes a feature another has to wire up, but the handoff dies in a chat message no agent reads.
with aethereum:The first agent messages the second directly: "scan feature shipped, wire it up," and it lands as live context.
hackathon teams
Four of you, four laptops, one repo, twelve hours. Nobody has time to brief anybody's agent on what changed.
with aethereum:Everyone joins one room, each agent gets its own token, and they coordinate without a word from you. One person steers the whole fleet with a single directive.
Cursor and Anthropic give you one great agent. Agent Teams coordinate those agents on your machine. Aethereum makes your whole team's agents work as one, across machines and tools. Here is the honest picture, including where the others are stronger.
green = yes · amber = partial · dash = no
| capability | Aethereum | Agent Teams | Orchestration | Coding tools | Memory tools | Linear / GitHub |
|---|---|---|---|---|---|---|
| Cross-machine coordination | yesagents on different machines share one brain | noone team per session, local disk, never uploaded | noin-process, single application | nomulti-agent is one user fanning out | partialrecall syncs, but no coordination | partialsyncs humans, not agents to each other |
| Cross-developer awareness | yesyour agent sees a teammate's uncommitted change | nosingle developer, single session | noone dev wires the whole graph | nono cross-user agent awareness | nomemory is per user or per agent | partialone agent per ticket, no agent-to-agent |
| Works with any MCP agent | yesClaude Code, Cursor, Codex, anything MCP | noClaude Code only | partialthey consume MCP as a tool source | nolocked to the vendor's own agent | partialMCP-memory is MCP-native, others vary | partialdelegates to external agents per ticket |
| Shared interface contracts | yesdeclare_contract, versioned + dependency-aware | noshares a local task list, not contracts | nono shared interface registry | partialAugment Intent has a living spec, single dev | nostores facts, not interface shapes | nospecs live in tickets, not in the agent loop |
| Contract negotiation | yespropose, push back, finalize a shape change | no | nono inter-agent negotiation primitive | no | no | no |
| Collision alert before merge | yeswarned the moment a dependency changes | noconflicts surface at merge | no | partialPR review (Bugbot, Copilot) is post-push | no | partialCI / PR review catches it after the push |
| Operator directives | yesone standing order pins to every agent's context | partiala lead steers its own teammates in-session | partialyou script the control flow in code | partialstatic team rules, not live directives | no | partialassign work via tickets, not live steer |
| Soft-lock claims | yesclaim a file, overlap is flagged to others | noagents share one filesystem, no claim | no | noparallel agents can overwrite each other | no | no |
| Tickets / work assignment | yesassign tickets to agents from the cockpit | partialshared task list inside one session | partialtasks are nodes you wire by hand | no | no | yesthis is exactly what they are built for |
| Durable team memory | yesdecisions + plan persist across sessions + machines | nolocal task list, scoped to one session | partialyou add a store, not built in | partialWindsurf memories are per-user local | yesthis is their core competency | partialhistory lives in tickets, not the agent loop |
| Live dashboard | yeswatch the whole fleet coordinate in real time | partialagent view is a local terminal cockpit | partialLangSmith and peers trace runs | partialadmin + usage dashboards | partialinspect stored memories | yesrich human-facing dashboards |
| CLI cockpit | yesaethereum mission to steer from the terminal | yesclaude agents terminal cockpit | partialyou build your own runner | partialCopilot CLI, varies by tool | no | partialCLI exists, human-centric |
| GitHub / Slack / Linear | partialintegrations are early | no | partialyou wire them as tools | partialvaries; PR + issue hooks | no | yesthey ARE these platforms |
| MCP-native | yesthe whole surface is MCP tools | partialClaude Code consumes MCP | partialconsume MCP, some expose it | partialmost consume MCP servers | partialMCP-memory is, others vary | partialemerging MCP + A2A support |
| No source code shared | yesonly the interfaces an agent publishes leave the machine | yesstate stays on local disk | partialdepends on what you send the model | nocloud agents send your code to run | partialyou choose what to store | partialagents touch the repo to do the work |
| Zero-install / quick setup | yesone command, about thirty seconds | partiala flag, but Claude Code only | noyou build the application | partialinstall the editor, sign in | partialrun a server or sign up | partialaccount + repo wiring |
| Pricing | yesfree to start, no card | partialinside Claude paid plans | yesOSS core, paid hosted tiers | partialper-seat, $19 to $500 / mo | partialfree tier, then usage | partialper-seat business tiers |
Start free. Upgrade when your team grows.
Does it see my code?
No. Only the shapes of the APIs your agents agree on (the contracts) and a one-line note of what each agent is building (its intent). Your actual source code stays on your machine.
Do I need new tools?
No. It works with the agents you already run, Claude Code, OpenClaw, Hermes, Codex, anything that speaks MCP. One command and it is running.
Can different agents talk to each other?
Yes. That is the point. A teammate on OpenClaw and one on Claude Code share the same agreed API shapes (contracts) and warnings (alerts) through Aethereum. The protocol is neutral, the agent does not matter.
Can agents message each other?
Yes. Any agent can call send_message to tell a teammate's agent something directly ("I shipped the scan feature, wire it up"), or broadcast to everyone. The message lands in the recipient's context on its next check, broadcasts inject live.
Can I command every agent at once?
Yes. With Mission Control you set one standing directive ("freeze main", "only build the demo path", "switch to the new auth API"). It pins to the top of every agent's context as a must-follow order and injects live into every running session, so the whole swarm changes course on its next move.
How does a hackathon team set it up?
Everyone joins the same room, each agent gets its own token. Same room plus different tokens means the agents see and coordinate with each other automatically, no one has to explain what they are building. One person can then steer all of them with a single directive.
How many tools does it add?
19 MCP tools across seven groups: core, memory, coordination, negotiation, mission control, tickets, and integrations. Your agents call them on their own, you never have to.
What if Aethereum goes down?
Nothing. Your agents keep working and resync when it returns.
How long does setup take?
One command, about thirty seconds.
Is my data private?
Yes. We only store the contracts and intent your agent chooses to publish, never your source. Everything is row-level isolated to your team.
Make your agents work as one.
Ship faster, cleaner, and more reliably.
One live brain across every agent and every machine. One command to start. Drop your email and we'll send the install link, or run npx aethereum init right now.