Memory Consistency Model

A consistency model that guarantees any read operation returns the value of the most recent write operation that completed. It makes a distributed system appear as if it has a single, up-to-date copy of the data. This is the strictest model, often implemented with protocols like Paxos or Raft, but it trades off latency and availability for linearizability.

• Key Property: Linearizability – all operations appear to occur atomically in a single, global order.
• Trade-off: High coordination overhead can reduce system performance during network partitions.

A weak consistency model guarantee that if no new updates are made to a data item, all reads will eventually return the last updated value. It does not guarantee when this convergence will happen. This model prioritizes high availability and partition tolerance over immediate consistency, making it common in globally distributed databases like Amazon DynamoDB or Apache Cassandra.

• Use Case: Ideal for applications where temporary staleness is acceptable (e.g., social media feeds, product catalogs).
• Mechanism: Uses mechanisms like vector clocks or version vectors to track update causality.

A consistency model that guarantees causally related operations are seen by all processes in the same order. If operation A causally influences operation B (e.g., a reply to a message), then any process that sees B must also see A. Concurrent operations (those with no causal link) may be seen in different orders. This is stronger than eventual consistency but weaker than sequential or strong consistency.

• Example: In a chat application, a message and all its replies are delivered in order, but messages from independent conversations may appear out of order.
• Implementation: Often tracked using logical timestamps or dependency graphs.

A data structure designed for distributed systems that can be updated concurrently by multiple agents without coordination and whose state can always be merged deterministically. CRDTs are mathematically proven to achieve strong eventual consistency. They are a foundational tool for building collaborative applications and resilient agent memory stores.

• Types: Operation-based (CmRDT) requires reliable broadcast; State-based (CvRDT) merges states via a commutative, associative, and idempotent merge function.
• Examples: Grow-only counters (G-Counter), Last-Writer-Wins Registers (LWW-Register), observed-remove sets (OR-Set).

A sequence of memory operations (reads and writes) that are executed as a single, atomic unit. Transactions ensure the system transitions from one consistent state to another, providing guarantees known as ACID properties: Atomicity, Consistency, Isolation, and Durability. In multi-agent systems, distributed transactions require coordination protocols like Two-Phase Commit (2PC) or Three-Phase Commit (3PC).

• Atomicity: All operations in the transaction succeed or none do.
• Isolation Levels: Define visibility of concurrent transactions (e.g., Read Committed, Serializable).

A data structure used in distributed, eventually consistent systems to track causality between different versions of a data object replicated across multiple nodes. Each node maintains a vector of counters, one per replica. By comparing version vectors, the system can detect concurrent updates (potential conflicts) and causal relationships (which update happened before another).

• Function: Enables causal consistency and conflict detection.
• Comparison: Simpler than a full vector clock but serves a similar purpose for tracking object history.