A local-first agent client where sync is the hard part
Ensembyte drives several coding agents at once over loopback IPC and keeps every view of the shared session consistent with a Loro CRDT + Durable Objects sync engine — zero telemetry included.
The tooling landscape for multi-agent coding is split in two. One camp is entirely cloud-locked: your context, prompts, and diffs stream through someone else's API, and the "local" part of the stack is just a remote's UI. The other camp is duct tape: terminal CLIs wired together by hand, with no shared session and no consistent view across agents.
Ensembyte is the attempt at the middle path — a native macOS and desktop client (SwiftUI on the front, Rust 2024 + GPUI underneath) that orchestrates *local* agent runtimes and treats the session as a first-class, synchronized document. It's open source, and by design zero-telemetry: nothing about your work leaves the machine.
The orchestration layer
The client drives several runtimes — Claude Code, Codex, Antigravity, Cursor, and others — through two channels:
- MCP (Model Context Protocol) for tool and capability surfacing, so an agent can act on the workspace.
- JSON-RPC over loopback IPC for the agent process itself.
Everything stays on the machine, on the loopback interface. No agent traffic goes to a relay. That's not just a privacy posture; it's what makes "local-first" more than a slogan — the whole coordination graph is addressable from the client, and a runtime failing or hanging is something the client can observe directly instead of inferring from API latency.
Where the real engineering was: the sync engine
Running multiple agents against one session sounds simple until you watch what actually happens. Each agent streams updates to the shared document as it works. Two agents editing near the same region, a user typing in the UI while an agent is writing, a laptop lid closing mid-stream — the naive "last write wins" approach falls over immediately.
The sync engine solves this with Loro, a CRDT framework, combined with Cloudflare Durable Objects:
- Loro gives each edit a commutative, conflict-free merge order. Two agents touching the same paragraph converge to the same result no matter which client observes the updates first. That's the property you can't patch in with lock files or optimistic retries.
- Durable Objects host the shared session authoritatively: one deterministic instance per session, so concurrent writers aren't merging against each other — they're all sending intents to a single sequencer.
- Coalescing is the part people underestimate. Agents stream at token-level granularity. If you forward every update as-is, you flood the pipeline with churn that's invisible to a human. The engine coalesces a burst of streaming document updates into a renderable batch, which is where "consistent" turns into "smooth."
The net effect: any two clients viewing a session — even after one was offline and reconnected — arrive at the same document state, and the streaming path stays fast.
Native, not a webview
The UI is SwiftUI with a Liquid Glass treatment on macOS, and GPUI (the GPU-based immediate-mode GUI toolkit in Rust) on desktop. The reason I don't ship a webview here is deliberate: this is a tool that sits on top of your terminal and editor all day. It has to feel native, start instantly, and not carry a second runtime's memory footprint. The Rust + GPUI combination also means the client and the sync engine share the same systems language — no FFI seams between the two.
Why zero telemetry is load-bearing
For a tool that orchestrates your *code*, telemetry isn't just an annoyance — it's a trust issue. If the orchestrator phones home, you can't reason about what it saw. Ensembyte's design is that the only network calls it makes are the ones *you* configure (agent providers, the Durable Objects host). Everything else — session history, prompts, file contents — stays on the machine or in storage you control.
What I learned
The hard problems in multi-agent tooling aren't the agent integration layer. They're the synchronization and trust problems underneath it: CRDTs, sequenced writes, coalescing, and a threat model honest enough to say what never leaves the box. If you're building agent infrastructure, start with the sync engine and work outward — the rest is adapters.