Alpha: deterministic synchronization of verifiable shared state across heterogeneous hardware

Technical report · auriglyph research · 10 Jun 2026 · Mikhail Kostan

1. The problem: shared state without shared transmission

Distributed systems spend a large fraction of their complexity keeping replicas of the same logical state in agreement. The dominant model, inherited from Shannon’s 1948 framing of communication, treats information as something to be moved: a sender encodes a message, a channel carries it, a receiver decodes it, and noise is the adversary. Replication layers build on this — they ship records, log entries, or state deltas, and then run reconciliation to resolve the divergence that transmission and concurrency introduce.

This model is powerful and correct, but for a growing class of systems it is expensive in the wrong dimension. When the shared object is large and slowly evolving — a ledger, a replicated index, an agent’s accumulated memory, an edge cache — the cost is dominated not by the information content of each change but by the machinery of moving and reconciling state. Two questions become acute. First, can two machines that have never exchanged the state itself nonetheless arrive at the same state? Second, when they claim to agree, can a third party verify that agreement cheaply, without trusting either node?

Alpha is built around an affirmative answer to both. It is not a transport for messages; it is a protocol for coherence. Nodes do not send each other the state. They send only the compact differential needed to advance a shared, deterministic process, and they reconstruct identical state locally. Agreement is then a property that can be checked against a small, fixed-size witness rather than re-derived by comparing payloads.

2. Background and related work

Alpha sits at the intersection of several mature lines of work, and it is useful to position it precisely rather than against a strawman.

Information transmission (Shannon, 1948).

Shannon’s theory remains the correct account of moving information through a noisy channel and of the limits on doing so. Alpha does not contradict it and does not claim to supersede it. Alpha addresses a different question — reconstructing agreed state from compact differential signals on a shared deterministic substrate — which is orthogonal to channel capacity. Where Shannon asks “how much can this channel carry,” Alpha asks “how little must cross the channel for two machines to hold the same verifiable state.”

Content integrity (Merkle, 1987; content-addressed storage).

Merkle trees and content-addressed stores commit to data with hashes and prove inclusion with logarithmic-size paths. Alpha’s witness is related in spirit — a cryptographic commitment to state — but is constant-size with respect to the state and is computed over the entire state, so any single-bit divergence is detectable from the witness alone.

Eventual consistency and CRDTs.

Conflict-free replicated data types and gossip/anti-entropy protocols achieve convergence under concurrency by constraining merge operations to be commutative and idempotent. Alpha deliberately does the opposite on the ordering axis: its state evolution is order-dependent, so history cannot be silently re-ordered or collapsed. Convergence in Alpha comes not from commutative merges but from shared determinism — the same inputs in the same order yield the same state, everywhere.

Deterministic and reproducible computation.

Reproducible builds and deterministic execution environments establish that fixed inputs produce fixed outputs across machines. Alpha makes this property load-bearing: its state representation is defined so that evolution is a pure function of the inputs, independent of hardware and operating system. Our evaluation confirms this holds byte-for-byte across two instruction-set architectures.

3. System model

We describe Alpha at the level of observable structure. The internal construction — how the state space is parameterized and how drift is computed — is proprietary and is not disclosed here.

State. A node’s state is a point in a 384-dimensional space, represented in deterministic fixed-point arithmetic and normalized to unit magnitude. Normalization is total: for any input, however large or adversarial, the representation is mapped back onto the unit hypersphere, so every coordinate is bounded by construction.

Reference grid. All nodes share a common deterministic reference. Two nodes are “in phase” when their references agree; a lightweight handshake confirms this by comparing the next reference signal each generates, rather than by exchanging state.

Drift. An event advances the state by a small differential rotation toward the event, followed by re-normalization. The quantity that crosses the network is this drift, not the resulting state.

Witness. The integrity of a state is summarized by a constant-size (256-bit) cryptographic seal computed over all 384 dimensions. Under the assumed collision resistance of the seal function, two non-identical states are not expected to produce the same seal with feasible computation; every single-bit perturbation in our tests changed the seal.

4. Properties

We state the properties Alpha is designed to provide. Each is accompanied in Section 5 by reproducible evidence; none depends on disclosing the construction.

4.1 Determinism and hardware-independence.

Given an identical initial state and an identical ordered sequence of drifts, two nodes reconstruct bit-identical state regardless of CPU architecture, operating system, or compiler. Consensus-critical arithmetic is fixed-width and deterministic. Any floating-point operations are restricted to strict IEEE-754 primitives, and we verify empirically that the resulting state is byte-identical across the tested platforms; bringing additional platforms under this guarantee requires re-running the invariant suite there.

4.2 Boundedness by construction.

Every state coordinate is confined to the unit hypersphere. Because normalization is applied after every event, and because it robustly pre-scales arbitrary-magnitude inputs before computing magnitude, no sequence of events — and no crafted input arriving over the network — can drive a coordinate outside its bounds or overflow the underlying arithmetic. The state space is, in effect, a closed manifold.

4.3 Order preservation (non-commutativity).

Because each event is applied with intermediate re-normalization, the evolution is non-commutative: applying events A then B does not in general yield the same state as applying their linear combination, nor the same state as B then A. The trajectory carries a memory of its order. A node cannot forge a history by presenting a single vector that “sums up” a different sequence; the seal would not match.

4.4 Constant-size integrity witness.

A 256-bit seal commits to the full 384-dimensional state. Once computed, the witness is constant-size and can be compared in constant time; computing it is linear in the encoded state size, fixed at 384 dimensions in Alpha. In our tests it was sensitive to every single-bit change, which makes agreement checkable by a third party from the witness alone. Reconstruction and verification are distinct: nodes reconstruct state locally from drift, while the witness only attests agreement — it does not reconstruct state.

5. Empirical evaluation

5.1 Setup.

We evaluated a reference implementation on four machines spanning two instruction-set architectures and two operating systems: an AMD Ryzen 9 7900X (Linux, x86-64), an Apple M2 (macOS, ARM64), an AMD Ryzen 7 7840HS (Linux, x86-64), and an Intel i3-9100 (Linux, x86-64). All measurements below are reproducible from the reference implementation; we report exact figures rather than quoting documentation.

5.2 Determinism across hardware.

Starting from a fixed genesis state and applying a fixed ordered sequence of events, every host produced a byte-identical 256-bit seal. We further ran a randomized battery of 2,000 independent scenarios (random seeds and random event chains) and combined the resulting seals into a single digest; the digest was identical on the ARM64 and x86-64 hosts. We observed no cross-architecture divergence in any scenario.

Identical 256-bit seal on every host, with no transmission of state between them — only the shared genesis and the shared event sequence.

5.3 Boundedness under fuzzing.

We fuzzed normalization with 40,000 input vectors drawn from six adversarial regimes: unit-scale, magnitudes scaled by 10⁹, raw random 64-bit integers, all-maximum, all-minimum, and single-coordinate spikes. We also fed crafted transport pulses with every coordinate set to the integer extrema, and pathological floating-point inputs (NaN, ±∞). In every case the post-normalization maximum coordinate magnitude remained within the unit bound; we recorded zero boundary violations, and no input produced a panic or arithmetic overflow.

5.4 Witness sensitivity.

We applied 5,000 single-bit perturbations, each flipping the lowest bit of one randomly chosen dimension, and computed the seal of each perturbed state. All 5,000 seals differed from the unperturbed seal; we observed zero collisions, consistent with a full-state commitment.

5.5 Reproducibility.

The properties above are encoded as executable invariant tests that ship with the reference implementation, so a regression in any of them fails immediately. The full suite — including the fuzzing and determinism checks — passes on both architectures with no warnings. Parties with access to the reference implementation can reproduce these invariant tests on independent hardware.

6. Threat model and security posture

We are deliberately conservative about security claims. Two properties are guaranteed by construction and confirmed by the evaluation: boundedness (no input can escape the state manifold or overflow the arithmetic) and full-state integrity sensitivity (any single-bit divergence is visible in the seal). These are structural, not probabilistic.

We make no claim that Alpha is “unbreakable.” The network layer and the cryptographic-seal layer have not yet undergone independent third-party audit, and we mark them accordingly in the reference implementation. Until such an audit is complete, Alpha should be deployed only within trusted boundaries or in simulation. Claims of cryptographic invulnerability without external review are, in our view, marketing rather than engineering, and we decline to make them.

7. Applications

Alpha is a foundation layer; it assumes nothing about the application above it. The asymmetry it offers — large shared state, tiny differential traffic, deterministic reconstruction, constant-size verification — is most valuable where that shape recurs:

Replicated databases and indexes: keep replicas in agreement by exchanging drift rather than shipping rows, with a constant-size proof of agreement. Edge and CDN cache coherence: converge distributed caches without broadcasting full state. Agent memory: synchronize an agent’s accumulated state across sessions and devices with verifiable continuity. Blockchain and ledger payloads: represent and verify transaction history with byte-exact reconstruction. Constrained and mesh networks: maintain shared state across intermittent links where moving full state is infeasible.

8. Limitations and future work

This is a technical report, not a peer-reviewed disclosure: by design it characterizes properties and presents reproducible evidence while holding the construction proprietary and patent-pending. A formal treatment with full methods will follow legal fixation. The most important near-term work is the independent external audit of the network and seal layers noted in Section 6; until it completes, the security posture is “structurally bounded and integrity-sensitive,” not “audited-secure.” We also intend to publish performance characterization under real network conditions, which this report does not cover.

9. Conclusion

Alpha demonstrates that distributed nodes can hold the same verifiable state without exchanging that state — converging instead on a shared deterministic process by transmitting only differential drift, reconstructing byte-identical state across heterogeneous hardware, and committing to it with a constant-size witness. We have characterized these properties and shown them to be reproducible across four machines and two architectures, with bounded behavior under 40,000 adversarial inputs and collision-free integrity over 5,000 perturbations. The construction remains sealed; the evidence does not. What we offer is not a promise but a reproducible result.