Concurrence

A Timing Constraint on Distributed Systems

The Coordination Limit describes how coordination cost in distributed systems scales multiplicatively across independent dimensions. The Compliance Boundary describes the structural requirement that behavior be provable during execution rather than reconstructed afterward. Both conditions are presently visible across deployed systems.

Neither is the origin. Both describe manifestations of a single upstream condition that remains invisible in most architectural analyses because it is a property of timing rather than of design.

The dimensions now producing these failures (identity, policy, transport, modality, authority) have existed for decades. Sessions date to the 1990s. Continuous policy evaluation dates to the mid-2000s. Autonomous agents predate the current cycle. The structural components did not change. Their interaction rate did.

The condition that follows from that change is the subject of this document.

The Principle

Independence between subsystems is not a design property. It is the ratio between the rate of state change and the rate of cross-subsystem reconciliation.

When identity mutates once per session and reconciliation across subsystems completes in three seconds, identity and policy may be enforced in separate systems. The reconciliation window fits inside the mutation interval, and the subsystems behave independently at runtime.

When identity mutates at hundred-millisecond cadence, as occurs during agent context switching, and reconciliation still requires three seconds, identity and policy are no longer independent in any operational sense. The architecture declares them separable. The system exhibits coupling regardless. No configuration of the subsystems alters this. The coupling is a property of the ratio, not of the topology.

When the interval collapses, the independence collapses.

Authority and Transport: An Inversion

The Sound Surveillance System (SOSUS), deployed for submarine tracking across ocean basins over several decades, maintained contact designation across months of operation. Hydrophone arrays rotated. Cables degraded. Sensors dropped out of service. The contact identity persisted across all of these transport-layer discontinuities.

The architectural basis of that persistence: SOSUS treated authority as the primitive and transport as expected to fail. An authoritative tracking identity, held above the sensor layer, absorbed transport-layer failures without fragmenting the interaction context. The sensors supplied signal. The authority layer maintained identity. These responsibilities were architecturally distinct.

Contemporary distributed systems present the inverse condition. Transport continuity is robust. Connection pools, retry semantics, and message-delivery guarantees sustain packet flow at production-grade availability. Authority continuity is not maintained. Identity is re-established at each subsystem boundary. Policy is re-evaluated at each hop. AI context is reconstructed per invocation. The transport survives; the interaction does not.

Contemporary systems fail because transport is treated as the primitive and authority is assumed to be reconstructable after the fact. That assumption held while reconstruction completed within the interval between state changes. It no longer does.

The Fragmentation Assumption

Fragmentation as an architectural strategy rested on an implicit timing assumption: the interval between independent state changes would remain larger than the interval required to reconcile them. Under that assumption, the operational benefits of fragmentation (modularity, independent scaling, isolated fault domains, targeted optimization) exceeded the coordination costs it imposed. The assumption held for approximately two decades.

The equilibrium that sustained this arrangement was a property of the workload, not of the architecture. State transitions in identity, policy, residency, and multimodal state occurred at rates measured in seconds to hours. Cross-subsystem reconciliation completed well within that window. Eventual consistency was an accurate description of system behavior because the domains interacted sparsely. Prior architectural analysis of interaction continuity documents the same equilibrium and identifies the conditions under which it holds.

That equilibrium no longer holds.

Interval Compression

Three forces have compressed the ratio between state-change rate and reconciliation rate.

Above a threshold determined by the slowest subsystem's reconciliation latency, the ratio inverts. State changes faster than reconciliation completes. Operational independence ends.

Scaling Behavior Under Concurrence

If the failure were attributable to computational complexity, additional compute would reduce it. Empirically, it does not. Hyperscaler investment in coordination capacity has expanded continuously over the past three years, and coordination failures have scaled with that investment rather than against it.

The explanatory variable is not system scale. It is the mutation-to-reconciliation interval. A workload that executed correctly before agentic access cannot be correctly executed after agents are introduced into the same workload. Compute allocation is identical. Topology is identical. Event rate is not.

The Additive Fallacy

Each remediation commonly deployed to address these failures introduces an additional subsystem: idempotency layers, durable workflow engines, policy evaluation points, orchestration middleware, observability planes. Each additional subsystem is an additional domain that must be reconciled with every other domain it touches.

The introduction of a new subsystem lengthens reconciliation. It does not compress the event rate. The ratio moves further from the regime in which independence holds. Remediation strategies built on subsystem addition worsen the condition that produces the failure. Every added layer is an additional boundary through which state must pass before the system can assert consistency with itself.

The Condition

Concurrence is not concurrency.

Concurrency presupposes an arbitration locus: a lock, a transaction manager, a consensus protocol. Conflicts are routed to that locus and resolved. Concurrence describes the condition in which multiple domains, architected as independent, become operationally coupled by timing while no arbitration locus exists. Each domain continues to operate on the assumption of isolation that the system cannot provide.

Concurrence is the structural condition that forces the Coordination Limit and renders the Compliance Boundary unsatisfiable. It is not a failure mode. It is the regime within which fragmented architectures now operate.