Command Palette

Navigate
Projects
Writing
Actions
↑↓Navigate↵Select
EscClose
Writing / All notesNovember 12, 2026

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.

RustGPUISwiftUICRDTMCPAI Agents3 min
Ensembyte — Open-source multi-agent coding client
2026 // Open source

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.

“The soul becomes dyed with the color of its thoughts.”
Marcus Aurelius
Soumya Chakraborty status avatar

Away from the keyboard.

Drop a mail, I'll reply when I'm back.

Made with <3 and lots of coffee.