Concept
Modern distributed systems still treat state as something that emerges from messages. Every service invents its own rules for synchronisation, conflict, recovery, and failure. The result is a world of ad-hoc coordination, partial truths, and emergent behaviour that becomes impossible to reason about at scale.
Spook Systems reverses this model.
The transport layer becomes the shared state. Messages become minimal deterministic deltas. Collapse resolves pending mutations into committed state. Decoherence and re-entanglement are first-class behaviours with defined outcomes. State evolves predictably and identically across participants regardless of packet loss, topology, or failure.
This is a deterministic substrate for distributed computing.
The Protocol Family
The architecture is built from four cooperating protocols:
- ETCP — identity, pair formation, link-level conformance
- ESTP — deterministic shared-state synchronisation via minimal deltas, collapse, decoherence, and re-entanglement
- QSCS — multi-register correlation using entanglement-group semantics
- QN — deterministic multi-node correlation across distributed domains
These are classical distributed-systems protocols. They use quantum-inspired structural principles — isolated registers, deterministic transitions, correlation groups — to achieve properties no existing architecture provides.
The Core Insight
Every distributed system eventually has to answer the same questions: How do two endpoints agree on shared state? What happens when they diverge? What happens when one disappears? What happens when it comes back?
Today, these answers live in application code. They are inconsistent, non-deterministic, and fragile. Spook Systems answers them once, at the protocol level:
- How state is identified, correlated, and tracked
- How transitions are encoded as minimal deterministic deltas
- How pending mutations collapse into committed state
- How divergence is detected and resolved
- How multiple registers evolve through shared collapse events
- How multiple nodes maintain deterministic alignment across a network
Applications built on this substrate don't implement synchronisation. They inherit it.
How It Works
The fundamental primitive is the Pair — two correlated HalfPairs, one at each endpoint. Each HalfPair maintains:
- An immutable committed StateBlock
- A buffer of pending Candidates
- A deterministic lifecycle state machine
- Causal ordering metadata
State transitions are encoded as minimal deterministic deltas. They apply in constant time, are idempotent, and guarantee identical evolution at both endpoints.
Collapse resolves pending mutations into a single committed state.
Decoherence handles divergence cleanly.
Re-entanglement restores alignment using minimal deltas, not full state transfer.
Why This Matters
The architecture eliminates the overheads that dominate modern distributed systems:
This reduces bandwidth by orders of magnitude, removes protocol-level latency, and produces a coordination layer that behaves cleanly even under intermittent connectivity.
Beyond 1:1
Real systems require more than point-to-point synchronisation.
QSCS extends deterministic evolution across multiple registers through entanglement-group semantics.
QN extends it across nodes, enabling deterministic multi-node domains with predictable recovery under partition.
Adoption
The protocol family integrates through a plug-in wrapper model. Existing protocols adopt deterministic shared-state synchronisation without modification:
- SMB / Samba
- LDAP / OpenLDAP
- SSH
- HTTP / REST / WebSockets
- MQTT / CoAP
- SQL transports (TDS, Postgres wire protocol)
No rewrites. No specification changes. The daemon handles correlation, collapse, and deltas.
Hybrid Classical-Quantum Applicability
The same structural properties that make ESTP efficient for microservices and edge devices — isolated registers, deterministic transitions, minimal deltas, strict causal ordering — make it a natural substrate for hybrid classical-quantum workflows.
QSCS and QN extend this to multi-register and multi-node quantum coordination without modifying the protocol.
Summary
Spook Systems introduces deterministic shared-state as a transport-layer primitive. The architecture provides predictable evolution across links, registers, and nodes, with first-class handling of collapse, decoherence, and re-entanglement.
It is efficient today and structurally aligned with the requirements of emerging quantum-assisted compute.