Zed Industries builds a version control system for AI agent context using Rust

Zed Industries has unveiled DeltaDB, a new version control system designed specifically to track the context and reasoning of AI agents. Released in late October 2026, this infrastructure aims to solve the problem of lost conversational history when developers collaborate with autonomous coding tools. The system uses Rust and conflict-free replicated data types to merge human and agent edits into a single causal graph.

What happened

The team behind the Zed code editor, founded in 2021 by Nathan, Max, and the author, has spent the last year developing technology to improve how teams collaborate with software agents. They observed that while agents accelerate code production, the critical thinking process often remains trapped in ephemeral chat interfaces or compressed into unreadable commit messages. DeltaDB serves as their solution, creating a persistent record of agent context that links every code change to the conversation that produced it.

DeltaDB allows users to point at any piece of code and recover the full reasoning behind it. It streams changes from both humans and agents in real time, merging them into a monotonically growing directed acyclic graph. This architecture ensures that the context behind software decisions is not lost, enabling developers to query why specific code looks the way it does, whether written by a human or an AI.

How it works

At its core, DeltaDB is a collection of CRDTs stored locally in SQLite and linked via a directed acyclic graph. Each node in this graph, called a delta, represents the smallest unit of change. This design allows clients to make progress offline and synchronize later, ensuring resilience against network failures. The system resembles the Eg-walker approach, using a DAG to represent every intermediate state rather than relying on version vectors, which can grow indefinitely as actors join and leave threads.

To handle performance, the system uses copy-on-write B+ trees to cache snapshots of recent states. When applying concurrent edits or scrubbing through history, the engine walks back to the nearest cached ancestor and replays only the necessary deltas. This method is significantly faster than rebuilding entire states, as it reuses most nodes from previous snapshots and only modifies the paths touched by new changes. Text edits are defined structurally, allowing precise identification of positions even during concurrent modifications.

Synchronization occurs through timelines, where each client subscribes to specific frontiers in the DAG. When a thread is shared, a WebSocket connection exchanges missed deltas by finding a common ancestor. Each thread is managed by a separate Cloudflare Durable Object, creating a share-nothing architecture that scales horizontally. This setup allows multiple agents and humans to write simultaneously within a single thread without requiring traditional Git commits for coordination.

Key details

• DeltaDB stores all data locally in SQLite, using a directed acyclic graph to link CRDTs.
• The system avoids version vectors in favor of DAG ancestry queries to handle transient agents.
• Copy-on-write B+ trees enable efficient state reification by reusing unchanged nodes from snapshots.
• Each agent thread runs in its own Cloudflare Durable Object, allowing horizontal scaling.
• A Rust macro called #[derive(Replicate)] simplifies the creation of complex replicated structures.
• Timelines allow parallel work by subagents, which can be merged back into the main thread later.

Why it matters

For engineers building AI-integrated tools, managing state consistency between human intent and agent output is a major challenge. Current workflows often lose the nuance of decision-making, making it difficult to audit or understand automated changes. DeltaDB demonstrates a practical approach to treating agent conversations as first-class citizens in version control, rather than secondary logs. This shift enables more reliable collaboration and easier debugging of AI-generated code.

The use of Rust and CRDTs highlights a trend toward local-first software architectures that prioritize responsiveness and offline capability. By decoupling the network representation from internal state, developers can build systems that feel instantaneous while maintaining strong consistency guarantees. This model reduces the friction of real-time collaboration, allowing teams to work with agents as seamlessly as they work with each other.

What you can do

• Evaluate how your current AI tools store and retrieve conversational context for code changes.
• Explore CRDT libraries in Rust if you are building real-time collaborative features.
• Consider implementing local-first storage patterns to improve offline resilience in your apps.
• Investigate Cloudflare Durable Objects for stateful, scalable serverless components.
• Review the Eg-walker paper to understand alternative approaches to conflict resolution in distributed systems.
• Experiment with mapping agent thoughts to structured data objects rather than plain text logs.