Staleness Bounds

Between guaranteeing consistency and guaranteeing availability lies a third move: make the tolerance a number. Yu and Vahdat built a theory of continuous consistency and the TACT toolkit, which meters how far a replica may drift in units called conits — a unit of continuous consistency — bounded along three axes: numerical error (how many un-applied writes), order error (how many operations may be reordered), and staleness (how old the data may be). Instead of the binary "strong versus eventual," a designer states exactly how far out of date an answer is allowed to be, and the system holds that bound or refuses to answer.

The move's real power is that the number is tunable while running. The paper's example is an airline reservation system: when most seats are open, it safely relies on somewhat stale data — a few extra bookings elsewhere change nothing — but as the plane fills it demands increasingly accurate data to avoid overbooking, tightening the bound seat by seat. Such a system guarantees neither strong consistency nor guaranteed availability, yet it survives far more disruption than either pure seat, because it spends its tolerance where tolerance is cheap. This platform ships the same idea as a discipline rather than a toolkit: version<>value framed into every cached value, newer-wins decided by mint order, and the as_of stamp on every surface answer. The drift is always visible, so the bound is always honest — and you cannot tune a bound you cannot see.

The conit's quiet radicalism is that it converts a mode into a quantity. "Strongly consistent" and "eventually consistent" are labels you wear; a conit bound is a number you carry — three numbers, in fact — and numbers can be measured against, compared, and moved. That is what makes runtime tuning possible at all: the airline does not switch from one consistency religion to another as the plane fills; it slides a single dial from generous toward strict, and the reservation logic reads the current setting the way it reads any other input. Consistency joins the set of things an application budgets.

The platform's contribution is to make the quantity observable at the point of use, because a dial no one can read is a dial no one can trust. Three shipped mechanisms carry the disclosure. version<>value frames the version into the bytes of every cached value, so a reader never has to guess which revision it received. Newer-wins by mint order makes the reconciliation rule total and coordination-free — the branded id is time-ordered, so "which is newer" needs no wall clock and no quorum. And the as_of stamp on every dashboard answer publishes that answer's own staleness in the response. Together they turn the paper's conit from a bound the system promises into a bound the reader can verify — the honest version of the dial, which is the only version worth shipping.

The dial rule — consistency is a quantity, not a mode: meter the drift as a number, and a bound you can see is a bound you can set — and prove you got. The conit made the tolerance tunable; the platform makes it visible, framing the version into the value and stamping the staleness onto the answer, so the bound is honest and not merely promised.