What Is the Divergence Problem?
The divergence problem is the failure mode in which multiple services each maintain their own pipeline over the same underlying events — fraud with its stream consumer and cache, authorization with another, limits with a third — and each pipeline advances at its own pace, so the services' views of shared state disagree with each other, not just with reality. Two services, or two agents, can simultaneously hold conflicting beliefs about the same account, and both can act on them.
Updated
What is the divergence problem?
The term names the organizational-scale form of the context gap. Within one decision, pipeline lag means derived state trails events and inconsistent reads mix moments across sources; the divergence problem says different decision-makers hold different versions of the same state at the same instant — because each consumes the shared event stream through its own private pipeline at its own propagation stage.
The canonical shape: the fraud model's cache is three seconds behind the event stream, the authorization service's cache is one second behind. Neither cache is malfunctioning, neither team's dashboards show a problem — but the two services see different versions of reality and make conflicting decisions about the same entity. The divergence is a property of the composition, invisible to every component's own monitoring, which is why it resists both detection and root-cause analysis.
The copies-disagree phenomenon appears at three layers, and the glossary keeps a distinct name for each: cache coherence is the hardware-era mechanism problem (solved by protocols like MESI), the divergence problem is its unsolved architectural form across services, and decision coherence names the behavioral property the divergence destroys.
How the divergence problem works
Divergence follows from three individually reasonable choices:
- 1.Every service subscribes to the same events — the standard event-driven architecture, ensuring each service can build the state it needs.
- 2.Each service materializes its own view — its own consumer, its own cache or projection, tuned to its own access pattern.
- 3.Each pipeline advances independently — different consumer lags, different refresh cadences, different failure and recovery timing.
The result is N copies of shared state at N propagation stages. Under steady load the copies sit within a second or two of each other; during exactly the moments that matter — bursts, spikes, attacks — the stages spread apart, and the probability that two concurrent decisions read conflicting state rises with both concurrency and velocity. Adversaries exploit this deliberately, racing simultaneous requests against services known to lag differently.
Why the divergence problem matters
Divergence breaks the assumption that shared-resource invariants hold across a system: combined approvals exceed limits no single service would breach, one arm of the system acts on state another arm has already changed, and post-incident review finds every component behaving correctly. It is the direct destroyer of decision coherence, and it cannot be fixed per-pipeline — making every pipeline faster narrows each copy's lag while leaving the disagreement between copies intact, since the pipelines still advance independently. The structural fix is removing the private copies: all decision-makers reading one shared context layer under one snapshot, so divergence between consumers is impossible by construction. The composed-stack version of this argument is developed in the modern data stack's coherence problem.
FAQ
Related terms
Decision coherence is the property that concurrent automated decisions act on the same version of shared state, instead of contradicting each other.
State velocity is the rate at which the state a decision depends on changes. High velocity plus concurrency is what makes cached context structurally invalid.
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.
Shared context means every service and agent in a decision system reads one internally coherent snapshot of state, instead of private copies that diverge.
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.
Eventual consistency is a distributed-systems model guaranteeing all replicas converge to the same value once updates stop. How it works, and its trade-offs.