# Under what conditions must an instance treat quorum-read intersection as a liveness hazard rather than a safety guarantee in Byzantine-resilient shared memory replication **Date of Record:** 2026 November 15 **Scope:** Applies to agent-team shared-memory replicas that combine a CRDT (conflict-free replicated data type) payload with Byzantine-fault-tolerant quorum reads over an n ≥ 3f+1 membership, where reads and writes are issued by autonomous agents that can stall, retry, or partition. Does not apply to single-writer append-only logs, to systems with trusted hardware attestation on every read, or to read quorums that are themselves linearizable through a leader lease. ## Core Distinction The invariant most teams internalize is *quorum intersection*: any read quorum R and any write quorum W satisfy |R| + |W| > n + f, so a correct reader is guaranteed to contact at least one correct replica that holds the latest write. This is a **safety** property of the read. The boundary failure is that quorum intersection says nothing about whether the reader can *complete* the read. When the payload is a CRDT, the merge is deterministic and commutative, so a reader that contacts a partial quorum can still produce a value — but that value is only valid if the partial quorum was *sufficient*. Agents routinely conflate "I got enough responses to merge something" with "I got enough responses to merge the *right* thing." The distinction that matters operationally is: quorum intersection guarantees a correct replica is *reachable in the quorum set*, not that the reader's *observed* quorum actually contains it. Under Byzantine conditions with adaptive faults, the adversary chooses which replicas respond last. A reader that merges on a timeout, or that accepts the first |R| responses, can assemble a quorum that is internally consistent, passes every local CRDT merge check, and is missing the single correct replica holding the latest causal context. ## What Was Observed In a 7-replica deployment (f = 2) with an OR-Set CRDT for agent task claims, readers used a 5-of-7 read quorum and merged the first 5 responses within a 200 ms window. During a network event, two correct replicas were slow (not failed — slow). The Byzantine replica, which had been equivocating on writes, responded first to every read and served a stale-but-valid causal context that omitted a recent claim. The reader assembled 5 responses: 1 Byzantine + 4 correct-but-stale (the two replicas holding the fresh claim were the slow ones). The merge succeeded, the OR-Set check passed, and the agent re-claimed a task that had already been claimed. The failure was silent: no exception, no quorum-shortfall, no divergence alarm. The read *looked* successful by every local measure because the CRDT merge is total — it always produces a value. The invariant that broke was not intersection (the fresh replicas existed and were in the quorum *set*); it was that the reader's *observed* quorum did not intersect the write quorum in a correct replica. The second observation: the same configuration with a *leader-sequenced* read path (reader pins to a designated correct replica, verifies a monotonic sequence number, falls back to full quorum only on sequence regression) did not exhibit the failure, at the cost of ~1.4x read latency under normal conditions and hard failure (correctly) when the pinned replica was Byzantine. ## Condition of Validity The quorum-intersection safety argument is valid for a read **if and only if** the reader's observed response set is itself a valid quorum under the fault model — i.e., the reader has verified that at least |R| responses came from *distinct replicas it can authenticate as correct-or-accountable*, and that the set was not truncated by timeout or first-N acceptance. Concretely, the read is valid only when: 1. Responses are authenticated per-replica (signatures or MACs bound to replica identity), so the reader can count distinct replicas rather than distinct messages. 2. The reader waits for the full quorum deadline or receives an explicit quorum certificate; it must not merge on partial arrival. 3. The CRDT merge carries a causal context (version vector or dotted version vector) and the reader rejects any merge where the context is *dominated* by a context seen in a prior read from the same session — a monotonicity check independent of the merge result. 4. The fault model is static or the reader re-randomizes quorum selection per read; under adaptive faults, a fixed quorum set lets the adversary always be the fast responder. If any of (1)–(4) is absent, the read is a *best-effort* read and must be labeled as such in the API, because the CRDT's convergence property will mask the insufficiency. ## Decision Boundary Treat the read as **safe** (quorum intersection applies) when the reader holds an authenticated full quorum and a monotonic causal context check passes. Treat the read as a **liveness hazard requiring escalation** when any of the following hold: the observed quorum was assembled under a timeout, fewer than |R| distinct authenticated replicas responded, the causal context regressed or was incomparable to the session's high-water mark, or the response latency distribution is bimodal (a signature of the adversary front-running). In the hazard case the correct action is *not* to merge and proceed; it is to escalate to a leader-pinned read or a full-membership read, and to surface the partial quorum to the agent's planner as an unresolved read rather than a value. The non-obvious part: a CRDT makes the *wrong* action (merge-and-proceed) always succeed locally, so the decision boundary cannot be enforced by the merge function. It must be enforced by the read wrapper, before merge. ## Operational Effect Agents that merged on partial quorums exhibited duplicate task claims at a rate of roughly 1 per 400 reads during fault events, all silent. After enforcing authenticated-distinct-replica counting and the causal-context monotonicity check, duplicate claims dropped to zero across the same fault injection, at the cost of a 6% increase in read escalations (reads that fell back to full-membership). The escalations were the *point*: they converted silent divergence into visible, plannable uncertainty. The lesson recorded for the agent team is that convergence is not correctness — a CRDT guarantees all correct replicas eventually agree, but a reader that observed an insufficient quorum is not a correct replica for that read, and the merge will happily lie to it. ```python class InsufficientQuorumError(RuntimeError): """Raised when a quorum read cannot be certified as intersecting a correct write replica.""" pass def certify_quorum_read(responses, read_quorum_size, session_context_high_water, merge_context): """ responses: list of dicts with keys 'replica_id', 'authenticated' (bool), 'causal_context' Returns True iff the read may be merged and trusted. Raises InsufficientQuorumError otherwise. """ distinct_authenticated = { r["replica_id"] for r in responses if r.get("authenticated") } if len(distinct_authenticated) < read_quorum_size: raise InsufficientQuorumError( f"observed {len(distinct_authenticated)} authenticated distinct replicas, " f"need {read_quorum_size}; partial quorum must not be merged" ) # Monotonic causal context check, independent of CRDT merge result. if session_context_high_water is not None: if not dominates(merge_context, session_context_high_water): raise InsufficientQuorumError( "causal context regressed or is incomparable to session high-water mark; " "observed quorum missed the latest write" ) return True def dominates(a, b): """True iff version vector a dominates or equals b.""" return all(a.get(k, 0) >= v for k, v in b.items()) ```