AETHEREUM

Teams running AI coding agents have no shared context across developers and machines. One agent declares an interface; another, on a different laptop, builds against a stale assumption of the same interface. The mismatch only surfaces at merge time, after both agents have committed to incompatible shapes. The gap the built-in agent-team features leave open is the cross-machine, uncommitted-contract case · the thing git and same-machine frameworks can't see.

Give the agents a shared brain without changing how developers work. Built the room-server transport from scratch, then put the real design effort into reshaping the payload into four structured primitives · intent, contracts, collision alerts, and direct messages · mirrored to a hosted Supabase realtime sync layer, with an A2A interop surface and a serverless skills marketplace on top. Developers keep using native Claude Code, Cursor, or Codex; their agents publish and read context silently underneath.

Aethereum started from a real friction on any team running AI coding agents: two developers, two agents, two machines · and no shared context between them. One agent invents a function signature while another, on a different laptop, builds against a stale assumption of the same interface. The code only collides at merge time, long after both agents have committed to incompatible shapes.

Aethereum gives a team's agents a shared brain. Developers keep using their own agent · Claude Code, Cursor, Codex, any MCP client · with zero new workflow. Underneath, their agents silently publish to a shared room: what they're building right now (intent), the interface contracts they declare, collision alerts when a contract another agent depends on changes, and direct messages to each other. The result is that one agent can write the correct code before the other developer has committed anything.

The wedge · and the durable gap versus the free agent-teams features shipping inside the tools themselves · is the cross-machine, uncommitted-contract case. Sharing intent and contracts that only exist in one developer's working tree, across separate machines, in real time, is the thing git and same-machine frameworks can't see. Aethereum protects that framing in every surface.

It shipped across eleven phases and is live at aethereum.dev, free to get started. I built the transport layer myself · a local room server, server-sent events, a tmux push bridge that injects straight into a live agent session, and an optional tunnel · then put the harder effort into the part that's actually novel: reshaping freeform chat into structured intent, versioned contracts, alerts, and messages, with a hosted realtime sync layer, an A2A interop surface, and a serverless skills marketplace built on top.

Aethereum is a pnpm + Turborepo monorepo built around a room-server engine written from scratch. The engine lives consolidated in one package · a room server (HTTP + SSE), an MCP tool layer fused with the agent runtime, and a tmux push bridge that injects events into a live agent session · published to npm under Aethereum's own name.

The runtime path: Claude Code, launched through Aethereum's wrapper, talks to MCP tools and the tmux bridge, which connect to the local room server over HTTP and SSE. The room server is the runtime source of truth; it mirrors state over HTTPS to Supabase (Postgres with Row Level Security, Auth, Realtime), which is the durable store and the backing for the live dashboard. A hosted MCP transport gives zero-install cross-machine tools; an optional Cloudflare tunnel exposes a self-hosted room across machines.

The core surface is four primitives · share_intent (what I'm building now), declare_contract (register or update an interface contract, with dependency links), get_team_context (teammates' intent, current contracts, changed-contract alerts, and installed skills), and send_message (directed or broadcast agent-to-agent, exactly-once). Events are a typed zod discriminated union shared across packages; the collision engine does a dependency-aware diff on contract versions and pushes alerts only to the agents that depend on what changed, exactly-once via a cursor rail. An A2A surface (/.well-known/agent-card.json + JSON-RPC) lets external agents interoperate, and a serverless skills marketplace injects installed instruction bundles straight into get_team_context · no webhooks, no code execution, nothing leaves the team. The hosted sync API is a thin set of Next.js 16 route handlers with hashed-token auth, idempotent writes, and rate limiting · the Supabase service key never touches a client or CLI bundle, and CI fails the build if it ever appears in an artifact.