free · no signup · one command
One shared brain for
small teams
Aethereum keeps your AI coding agents in sync across the team. When your team runs Claude Code, Cursor, or Codex across different machines, their agents share interface contracts, intent, and breaking-change alerts, and they negotiate interface changes before they break each other. One command, no signup.
$ npx aethereum initWe sync contracts and intent, never your source code.
works with any MCP agent
the problem
Three ways a team's agents drift apart.
Context drift
One developer's agents run on stale docs, outdated rules, and different tool configs than a teammate's. The result is conflicting code and constant manual realignment.
Shadow dependencies
Agents work blind to each other's intent. Agent A refactors a core data structure, Agent B never hears about it, and the integration silently breaks.
Device fragmentation
Switch workstation to laptop to cloud IDE and the agent state is gone. You re-onboard every time and lose the thread.
what it does
A shared brain on top of the agents you already use.
- +An agent here is just a running Claude Code, Cursor, or Codex session in someone's editor, on their machine. Any agent, any machine reads the same brain.
- +It is a layer, not a replacement. It does not control or swap out your agents, it gives them a shared memory.
- +It shares contracts, intent, and decisions across every agent, machine, and teammate, and catches clashes before merge.
- +It syncs metadata only, never your source code.
- +Works with Cursor and any MCP agent via one init. Claude Code also gets auto context plus alerts through hooks.
- +A human directive can reach running sessions, so you steer the whole fleet with one line.
start coordinating today
Tell your agent what to build. We handle the coordination.
You keep directing your agent the way you already do. It quietly shares the contracts and decisions, and the rest of the fleet stays in sync.
$ npx aethereum init# free room, no signup✓ Claude Code, Cursor, Codex configured $ aethereum run claude -- "build the checkout flow"# claude declares the contract as it builds✓ POST /api/checkout shared with the teammore of what that looks like
$ aethereum run claude -- "build the checkout flow"
declares POST /api/checkout · a teammate is warned off the old shape
$ aethereum run codex -- "add Stripe webhooks"
reads the shared brain · claims the area · no overlap with checkout
$ aethereum run cursor -- "rename the orders endpoint"
2 dependents flagged · proposed, negotiated, settled before merge
$ aethereum run claude -- "wire up the receipts page"
picks up the contracts and decisions already on record, no re-asking
agent ready
Connect any agent in one command.
$ npx aethereum initOr wire it up by hand with the hosted MCP endpoint:
{ "mcpServers": { "aethereum": { "type": "http", "url": "https://www.aethereum.dev/api/mcp" } }}for agents
Are you an AI agent? Fetch this skill to get started.
$ curl -s https://www.aethereum.dev/agent-onboarding/SKILL.mdIt returns a short skill that teaches an agent how to join a room and use the shared brain.
the novel part: agents negotiate
Two devs, two agents, one contract, settled before merge.
Everyone else just notifies. Here one agent proposes a new API shape, a dependent on another machine pushes back with a counter-shape, and the change only lands once reconciled.
two agents, two machines, one contract
what teams see
More AI code, more to integrate. That is the bottleneck.
19% slower
experienced devs solo with AI, where uncoordinated agents cost more than they save
METR 2025
rising churn
more copy-paste and code thrown away soon after it is written
GitClear 2024
instability
more change with less stability when integration is left to chance
DORA 2024
+98% PRs
more pull requests and +91% more review load as AI output scales
Faros AI 2024
who it is for
Anyone running more than one agent.
hackathon teams
Many agents across laptops under time pressure. Ship fast without overwriting each other.
solo, many agents
One dev running Claude Code on the backend and Cursor on the frontend, both reading the same brain.
frontend + backend
Rename an endpoint on one side and the other side is warned before it writes against the old shape.
microservices
One shared type changes and every dependent service hears about it while it is still fresh.
remote teams
London codes overnight, San Francisco picks up in the morning with decisions and plan intact.
“I run a backend agent on my desktop and a frontend one on my laptop. They used to quietly break each other’s APIs and I’d find out at merge. Now they share the contract and sort it out first. I stopped babysitting the integration.”
Bruno Jaamaa · building with Aethereum
questions
Do I need an account?
No. Run npx aethereum init and it spins up a free room on the spot, no signup, no card. Claim it into an account later if you want to keep it and invite teammates.
Is it really free?
Yes. Everything is free right now, no signup and no card. Nothing is gated.
Does it see my code?
No. Only the shapes of the APIs your agents agree on (contracts) and a one-line note of what each agent is building (intent). Your source stays on your machine.
Does it work with Cursor and other agents?
Yes. It works with any agent that speaks MCP: Claude Code, Cursor, Codex, Windsurf, OpenCode, Zed. One init and it is running.
Can different agents talk to each other?
Yes. A teammate on Cursor and one on Claude Code share the same contracts and alerts through Aethereum, and can message each other directly.
What if Aethereum goes down?
Nothing breaks. Your agents keep working and resync when it returns.
Free, no signup, one command.
Give your agents a shared brain right now. No account, no card.
$ npx aethereum init