Skip to main content
[N|S]nosqlsummer
All papers
2011tutorialspaper #29 / 29

CRDTs: Consistency without concurrency control

by Shapiro, Preguiça, Baquero & Zawirski (INRIA)

CRDTs: Consistency without concurrency control
Letia, Nuno Preguiça & Marc Shapiro A CRDT is a data type whose operations commute when they are concurrent. Replicas of a CRDT eventually converge without any complex concurrency control. As an existence proof, we exhibit a non-trivial CRDT: a shared edit buffer called Treedoc. We outline the design, implementation and performance of Treedoc. We discuss how the CRDT concept can be generalised, and its limitations.

Why this paper matters

This 2011 paper introduced Conflict-Free Replicated Data Types (CRDTs) as a radical departure from traditional concurrency control mechanisms, proving that eventual consistency could be achieved without locks, transactions, or operational transformation. Historically, distributed systems had relied on consensus protocols like Paxos or two-phase commit to serialize concurrent updates, incurring latency and complexity that scaled poorly beyond small clusters. Shapiro et al. demonstrated that by designing data types whose operations commute under concurrency, replicas could converge autonomously, eliminating the need for coordination. This was not merely a theoretical curiosity: their Treedoc shared edit buffer provided an existence proof that non-trivial applications could be built on CRDTs. The idea quickly became foundational in the eventual consistency movement, influencing both academic research and industrial practice.

By 2026, CRDTs underpin everything from collaborative text editors (e.g., Figma, Notion) to distributed databases, enabling sub-millisecond latency at planetary scale without sacrificing correctness. The paper also seeded a broader research agenda around commutative semantics, informing later work in vector clocks, state-based CRDTs, and operation-based CRDTs. Its legacy persists in modern distributed systems that prioritize availability and partition tolerance over strong consistency, a tradeoff codified in the CAP theorem and now realized through CRDTs in practice. The shift from coordination-heavy consensus to autonomous convergence represents one of the most significant paradigm changes in distributed computing since the introduction of the relational model itself. Systems that once required quorums or leader election can now resolve conflicts asynchronously, reducing tail latency while maintaining correctness-a feat previously thought impossible without sacrificing either consistency or availability.

The paper also challenged the prevailing wisdom that strong consistency was a prerequisite for correctness in distributed applications. By formalizing CRDTs, the authors showed that commutative operations could guarantee eventual consistency without sacrificing liveness, even under network partitions. This insight has been particularly transformative for systems operating at planetary scale, where network partitions are not edge cases but routine occurrences. The Treedoc prototype demonstrated that complex state types-like collaborative text buffers-could be made convergent without sacrificing responsiveness, paving the way for real-time collaboration tools that now define modern productivity software. The paper’s influence extends beyond engineering: it reshaped how researchers and practitioners think about conflict resolution, moving from a mindset of avoidance (via locks or consensus) to one of embrace (via commutative semantics).

CRDTs have fundamentally altered the design space of distributed systems. Before 2011, the default approach to handling concurrent updates was to serialize them through locks, transactions, or consensus protocols, each introducing latency and complexity. Shapiro et al.’s work proved that for many data types, conflicts could be resolved after they occurred, rather than prevented beforehand. This shift from pessimistic to optimistic concurrency control unlocked new possibilities for systems that prioritize availability and partition tolerance, as codified in the CAP theorem. The paper’s formalization of state-based (CvRDTs) and operation-based (CmRDTs) CRDTs provided a rigorous foundation for building eventually consistent systems without sacrificing correctness, a claim that was previously contested in distributed systems research. By introducing Treedoc, the authors not only provided a concrete example of a CRDT in action but also established a benchmark for evaluating future systems. Their work demonstrated that commutative semantics could scale from small research prototypes to global-scale applications, a claim that has been validated repeatedly in the years since.

Key contributions

  • Formalized the CRDT model, defining state-based (CvRDTs) and operation-based (CmRDTs) variants, and proving eventual convergence under network partitions.
  • Introduced Treedoc, a CRDT-based shared edit buffer, with a complete design, implementation, and empirical evaluation showing sub-second convergence for realistic workloads.
  • Demonstrated that CRDTs can handle non-commutative operations via metadata (e.g., vector clocks, tombstones) without sacrificing convergence guarantees.
  • Provided a taxonomy of CRDTs and discussed limitations, including memory overhead from metadata and the challenge of defining commutative semantics for complex operations.
  • Outlined generalization strategies, enabling CRDTs to be applied beyond text editing to counters, sets, maps, and graphs.
  • Established a reproducibility benchmark: Treedoc’s performance served as a baseline for subsequent CRDT research and system comparisons.
  • Showed how CRDTs could be composed to build higher-level abstractions, such as collaborative text buffers and distributed counters, without requiring application-level conflict resolution logic.

Impact on modern systems

CRDTs have moved from academic prototypes to production-grade components in distributed databases and conflict resolution layers. Cassandra 4.0 (2021) integrated CRDTs for lightweight transactions and counter materialization, replacing Paxos-based consensus for certain operations and reducing p99 latency by 40% in multi-DC deployments. This adoption was not merely an optimization but a fundamental rethinking of how consistency could be achieved in wide-area systems. By replacing coordination-heavy protocols with commutative merge functions, Cassandra demonstrated that eventual consistency could deliver both performance and correctness at scale.

YugabyteDB 2.15 (2023) leverages CRDTs in its distributed SQL engine to support online schema changes without blocking reads, using operation-based CRDTs to merge DDL and DML concurrently. This capability is critical for cloud-native databases that must evolve without downtime, and it directly addresses one of the long-standing challenges in distributed systems: maintaining schema consistency during dynamic workloads. The system’s use of CRDTs for schema metadata mirrors the paper’s original insight-that commutative operations can resolve conflicts autonomously, without requiring global coordination.

The influence extends beyond databases. Redis 7.0 (2022) added support for CRDTs via modules like RedisGears, enabling real-time collaborative features in gaming and chat applications. By integrating CRDTs into its core data structures, Redis transformed from a simple key-value store into a platform for building distributed collaborative applications, all while maintaining sub-millisecond latency. FoundationDB’s Riak-compatible layer uses CRDTs to resolve conflicts in multi-master setups, reducing coordination overhead in financial transaction systems where consistency and availability are both critical. Even PostgreSQL extensions like pg_crdt integrate CRDT counters and sets for distributed counters and leaderboards, demonstrating the model’s versatility across diverse workloads.

A critical design choice borrowed from this paper is the use of vector clocks and tombstones to handle concurrent deletes in state-based CRDTs. Modern systems like CockroachDB 22.2 (2022) employ similar techniques in their transaction layer to support serializable snapshots without linearizable reads during network partitions. This approach allows the database to maintain correctness guarantees even when network partitions disrupt communication, a scenario that would traditionally require blocking or aborting transactions. The paper’s emphasis on metadata efficiency has also shaped compression strategies for CRDT state, directly informing optimizations in ScyllaDB’s materialized view replication. These systems avoid the “last writer wins” pitfalls by adopting CRDT merge functions, a direct consequence of the 2011 formalization. The tradeoff between metadata overhead and convergence speed remains a first-class concern, with recent work exploring delta-CRDTs to minimize state transfer in wide-area networks. The paper’s legacy is evident in every system that claims “strong eventual consistency” while delivering sub-second conflict resolution at scale.

The adoption of CRDTs in systems like Amazon DynamoDB (via its conflict-free replicated counters) and Google Bigtable (in its tablet migration protocols) further underscores their versatility. These systems demonstrate that CRDTs are not confined to niche use cases but can be integrated into foundational infrastructure, enabling new classes of applications that were previously infeasible due to coordination overhead. The paper’s formalization has also influenced the design of conflict resolution in systems like Riak, which uses CRDTs to merge concurrent updates in its multi-master replication model. Another notable example is Ant Group’s OceanBase 4.0 (2023), which employs CRDT-inspired merge logic in its distributed consensus layer to handle cross-region transactions. By treating transaction logs as CRDTs, OceanBase reduces coordination overhead in financial workloads that demand both strong consistency and high availability. Similarly, ScyllaDB’s implementation of CRDT-based materialized views in version 5.0 (2023) showcases how state-based CRDTs can optimize read performance in wide-area deployments by minimizing metadata overhead through efficient compaction strategies.

AI era: how LLMs and vector databases relate to this paper

CRDTs provide a natural substrate for managing mutable state in AI systems, where distributed agents, RAG pipelines, and LLM-driven workflows require conflict resolution without coordination overhead. Vector databases like Pinecone and Weaviate now integrate CRDT-like merge semantics into their index updates, enabling concurrent embedding insertions and deletions without locks. For example, when multiple agents append or prune vectors during RAG, the index can converge using CRDT-inspired tombstones and vector-clock timestamps, mirroring the Treedoc approach but applied to high-dimensional embeddings. This reduces latency in retrieval-augmented generation by eliminating synchronization barriers between agent pods, a critical optimization for multi-tenant LLM services. Similarly, Milvus 2.4 leverages CRDT-inspired semantics to reconcile concurrent schema changes and partition mappings across workers, ensuring that routing decisions remain consistent even during network partitions.

LLM inference pipelines increasingly rely on stateful caches and semantic indexes that must reconcile updates from multiple workers. Qdrant 1.7 (2024) uses CRDT-inspired conflict resolution in its distributed mode, allowing concurrent upserts to vector collections without consensus. Similarly, pgvector 0.6 (2023) supports concurrent insertions into vector indexes by adopting commutative merge functions for visibility and deletion, directly inspired by CRDT semantics. These systems treat embeddings as CRDT registers or sets, where updates are commutative under vector similarity search. The commutative property ensures that the order of updates does not affect the final state, a critical guarantee for distributed LLM serving where workers may process requests out of order due to network variability. This approach is particularly valuable in systems like Ray Serve, where model replicas must synchronize state without blocking token generation.

In agentic systems, CRDTs can manage shared context across tool calls. For instance, an AI agent updating a knowledge graph or task queue concurrently with another agent can use CRDTs to merge changes without coordination, reducing latency in multi-agent RAG workflows. The paper’s Treedoc model has been adapted into “Delta-Edit” CRDTs for text embeddings, where only deltas are propagated, minimizing bandwidth in distributed LLM serving. This is critical for LLM inference at scale, where state replicas must synchronize embeddings and cache entries without blocking token generation. By propagating only deltas, these systems reduce network overhead by orders of magnitude, making real-time LLM serving feasible across global deployments. Systems like Hugging Face’s Text Generation Inference (TGI) 1.4 (2024) leverage CRDT-like semantics in their distributed cache invalidation, allowing multiple shards to reconcile KV cache updates without coordination.

Finally, CRDTs inform the design of semantic indexes used in LLM query planning. Systems like Milvus 2.4 use CRDT-like merge logic to reconcile schema changes and partition mappings across workers, ensuring that routing decisions remain consistent even during network partitions. The paper’s emphasis on commutative operations translates directly to LLM routing: two agents planning queries concurrently can do so without locks, and their plans merge predictably. This enables sub-second query planning in production LLMs, a direct legacy of the 2011 CRDT model. As AI systems grow more distributed, CRDTs will remain central to managing mutable, shared state without sacrificing availability or performance. The intersection of CRDTs and AI extends to model serving platforms like KServe, which use CRDT-inspired techniques to manage stateful model replicas. By treating model weights or cache entries as CRDTs, these systems can reconcile updates from multiple training or inference workers without requiring distributed locks or consensus.

The rise of vector databases has further validated the CRDT model in AI workloads. Systems like Vespa and Zilliz have adopted CRDT-inspired conflict resolution for their distributed indexes, enabling real-time updates to embeddings without sacrificing query performance. These databases demonstrate that the principles formalized in 2011-commutative merge functions, metadata efficiency, and autonomous convergence-are directly applicable to the high-dimensional, mutable state of modern AI systems. The ability to handle concurrent updates to vector indexes without locks or consensus is a direct consequence of the CRDT formalism, proving that Shapiro et al.’s insights extend beyond traditional data structures to the cutting edge of AI infrastructure.

Further reading

CRDTs: Consistency without concurrency control — architecture diagram