What Is Decision Coherence?
Decision coherence is the property that concurrent automated decisions about the same entity act on the same version of shared state. In a coherent system, two services evaluating one account at the same moment reach conclusions that could both be true of a single world. Systems lose decision coherence when each service reads its own copy of state — a cache, a projection, a feature snapshot — sitting at a different propagation stage, so simultaneous decisions are made against different versions of reality.
Updated
What is decision coherence?
The term is part of the context-gap vocabulary Tacnode uses to name what distributed decisioning actually requires, as distinct from what individual components provide. Every component can be healthy — the fraud cache 3 seconds behind the event stream, the authorization cache 1 second behind, both within their SLOs — while the system is incoherent: the fraud model and the authorization service are looking at different realities, and their combined behavior (one blocks, one approves; both approve against the same limit) is something no single version of the world would produce.
The concept generalizes cache coherence from hardware to decision systems. CPU designers solved copy-divergence with invalidation protocols because multicore programs are incorrect without them; distributed architectures quietly dropped the guarantee when they decomposed into services with private state pipelines, and the cost lands on whatever reads across them. The canonical treatment is the decision coherence pillar.
How decision incoherence happens
A concrete sequence, one account, two services:
- 1.
T + 0 ms— a $9,000 transfer clears; the event enters the pipeline. - 2.
T + 800 ms— the limits service's projection updates; available headroom now $1,000. - 3.
T + 900 ms— two requests arrive concurrently: a $5,000 payment (evaluated by the payments service, cache still pre-transfer) and a $4,000 withdrawal (evaluated by the limits service, projection current). - 4.The payments service sees $10,000 headroom and approves; the limits service sees $1,000 and blocks a smaller amount.
An approval and a rejection, same instant, same account — decided against two versions of history. Neither service misbehaved; the incoherence lives between them. Note this is not fixed by making each pipeline faster: unequal lags of 300 ms and 100 ms produce the same class of contradiction at higher frequency, as explored in context under concurrency.
Why decision coherence matters
Incoherent decisions are worse than uniformly stale ones, because they are exploitable and unreproducible. Adversaries deliberately race concurrent requests across services precisely because each service's view lags differently — the fraud-burst pattern analyzed in real-time fraud detection architecture. And when the contradiction surfaces downstream (a negative balance, an over-committed limit), every component's logs show it behaving correctly, which is why these incidents resist root-cause analysis.
Coherence is restored architecturally, not per-cache: concurrent readers must share one snapshot of the relevant state — the property a shared context layer provides and per-service pipelines structurally cannot, however tuned. That is the argument of the shared context pillar. For AI agents the stakes rise again: multi-step agent workflows interleave at machine speed, and agents acting on divergent state compound each other's errors faster than humans can intervene.
FAQ
Related terms
A context gap is the difference between the state of the world an automated decision acts on and the actual state at the moment the decision commits.
The divergence problem: services each maintain their own pipeline over the same events, advancing at different paces, so their views of shared state disagree.
The Composition Impossibility Theorem: no composition of independently advancing data systems can guarantee a decision one coherent view of reality.
Cache coherence keeps multiple copies of shared data consistent across CPU caches or distributed services, so every reader sees the same value after a write.
A race condition occurs when a system's outcome depends on the timing of concurrent operations, letting interleaved reads and writes corrupt shared state.
A Context Lake is real-time, multi-modal data infrastructure that gives AI agents and decision systems fresh, internally coherent context at decision time.