Source-linked AI summary
Valori: A Deterministic Memory Substrate for AI Systems
Varshith Gudur
TL;DR
AI memory built on floating-point embeddings can vary across hardware, challenging replayability where bit-level reproducibility matters. Valori uses fixed-point arithmetic and a state-machine memory kernel to enforce determinism at the memory boundary. The paper reports identical cross-platform memory and retrieval ordering after restore, alongside 99.8% mean Recall@10 in one tested configuration.
Problem
Floating-point AI memory can produce different states across hardware, while bit-level reproducibility is a correctness requirement in safety-critical applications.
Source: §1 · p. 1Method
Valori normalizes inputs into fixed-point memory operations and models updates as deterministic state-machine transitions.
Source: §1 · p. 1, §5.2 · p. 4, §6 · p. 4Results
99.8% mean Recall@10 was reported for Valori’s Q16.16 index, and cross-platform restore preserved identical k-NN result ordering and scores for a fixed query and memory state.
Source: §8.3 · p. 6, §8.1 · p. 6Takeaways & Limitations
The paper concludes that integer fixed-point arithmetic and a state-machine architecture can provide deterministic, auditable AI memory.
Source: §12 · p. 7Valori’s guarantee begins after vectors enter the kernel; non-determinism in embedding-model inference remains outside its memory guarantees.
Source: §11 · p. 7
Abstract
from arXiv · showhide
Modern AI systems rely on vector embeddings stored and searched using floating-point arithmetic. While effective for approximate similarity search, this design introduces fundamental non-determinism: identical models, inputs, and code can produce different memory states and retrieval results across hardware architectures (e.g., x86 vs. ARM). This prevents replayability and safe deployment, leading to silent data divergence that prevents post-hoc verification and compromises audit trails in regulated sectors. We present Valori, a deterministic AI memory substrate that replaces floating-point memory operations with fixed-point arithmetic (Q16.16) and models memory as a replayable state machine. Valori guarantees bit-identical memory states, snapshots, and search results across platforms. We demonstrate that non-determinism arises before indexing or retrieval and show how Valori enforces determinism at the memory boundary. Our results suggest that deterministic memory is a necessary primitive for trustworthy AI systems. The reference implementation is open-source and available at https://github.com/varshith-Git/Valori-Kernel (archived at https://zenodo.org/records/18022660).
1 Introduction
Floating-point memory operations can make identical AI systems diverge across hardware, undermining replayability where bit-level reproducibility is required. Valori’s motivation is to enforce determinism at the memory layer.
1 Introduction
- Valori is introduced as a hardware-agnostic memory kernel because floating-point embedding differences can make memory and retrieval behavior diverge across platforms.The paper argues that bit-level reproducibility is a correctness requirement in safety-critical applications.Source: §1 · p. 1
2.1 Floating-Point Non-Determinism
- IEEE 754 operations can vary across hardware and compilers through differences such as FMA handling and parallel reduction order.Floating-point addition is not associative, so changing operation order can change the result.Source: §2.1 · p. 2
- Hardware-specific SIMD instructions and auto-vectorized reduction loops can produce different results even when source code is identical.The passage identifies differences in register widths and association orders across instruction sets.Source: §2.1 · p. 2
2.2 The Embedding Pipeline
- Embedding-generation differences arise before indexing or retrieval, as the same model and input can produce different raw bits on different chips.The embedding is treated as a semantic address, but inference runs on floating-point hardware.Source: §2.2 · p. 2
3 Problem Definition
The paper frames trustworthy memory as a state machine whose command-driven transitions must replay identically across computing environments. It contrasts this requirement with floating-point vector databases.
3 Problem Definition
- The paper formalizes trustworthy memory using a state-machine model.Its transition function maps a current memory state and an applied command to the next state.Source: §3 · p. 2, §3.1 · p. 2
3.1 Memory State and Replayability
- For any valid initial state and command sequence, deterministic memory requires the same final state across CPU architectures, operating systems, and compiler versions.Commands include operations such as insert, delete, and link.Source: §3.1 · p. 2
- Typical f32 vector databases violate this requirement because hardware-specific floating-point behavior affects distance calculations and index updates.These operations are part of the state-transition function.Source: §3.1 · p. 2
4 Empirical Evidence of Non-Determinism
A controlled comparison found that embeddings generated on x86 and ARM differed at the bit level in every examined dimension despite very high cosine similarity. The experiment used the same code and model setup on both machines.
4.1 Reproduction Setup
- The comparison used an x86 Windows PC and an ARM64 MacBook Pro running the same Python code and sentence-transformers setup.The experiment generated embeddings from a fixed set of sentences and inspected their raw hexadecimal representations.Source: §4 · p. 2, §4.1 · p. 3
4.2 Results
- Every examined embedding dimension differed at the binary level across machines, although cosine similarity remained > 0.9999.The paper warns that these small differences can alter distance rankings and potentially change retrieved results.Source: Table 1 · p. 3, §4.2 · p. 3
- Table 1 reports bit-level divergence for the first five dimensions of identical embeddings.The table accompanies the reported finding that every examined dimension differed.Source: Table 1 · p. 3, §4.2 · p. 3
5 Valori Design
Valori places a determinism boundary at the memory kernel, normalizing inputs into fixed-point values and applying memory updates as state-machine transitions. Its design separates the deterministic core from external services.
5 Valori Design
- Valori normalizes potentially non-deterministic model outputs at the kernel boundary rather than making neural inference deterministic.The kernel applies memory updates within a deterministic domain so identical command sequences produce bit-identical states across architectures.Source: §5 · p. 3, §5.3 · p. 4
5.1 Fixed-Point Arithmetic (Q16.16)
- Q16.16 fixed-point arithmetic replaces f32/f64 operations, using signed 32-bit integers with 16 fractional bits in the reference implementation.The format was selected to balance execution efficiency on 32-bit embedded MCUs with precision for normalized embeddings; wider contracts are supported by the design.Source: §5.1 · p. 4
- Integer ALU operations make Q16.16 numerical results bit-identical across x86, ARM, RISC-V, and WASM.Dot-product summation uses i64 or wider intermediates before narrowing to the stored format.Source: §5.1 · p. 4
5.2 Memory as a State Machine
- The memory kernel is a pure state machine with serialized deterministic commands and state that can be snapshotted and exactly restored on another machine.Its state encapsulates vector data, graph selection, and metadata.Source: §5.2 · p. 4
5.3 Architecture Separation
- The no-std kernel validates and converts inputs at the boundary and performs indexing, while an outer std layer supplies APIs, persistence, and networking.The outer layer wraps the kernel without altering its logic.Source: §5.3 · p. 4
6 Precision as a Configurable Memory Contract
Valori treats numeric precision as a deployment-specific memory contract, preserving determinism across precision choices. Its architecture places a deterministic kernel beneath interface layers that handle I/O.
6 Precision as a Configurable Memory Contract
- Determinism is preserved independently of the selected precision, allowing precision and performance trade-offs without sacrificing replayability.Valori treats numeric precision as an operational contract rather than a single fixed representation.Source: §6 · p. 4
- The architecture wraps a pure deterministic kernel with interface layers for I/O.The figure identifies Python FFI and Node HTTP as interface examples.Source: Figure 1 · p. 5
7 Indexing and Determinism
Valori adapts HNSW indexing to remove stochastic construction choices through stable ordering and fixed-point distances. The paper concludes that approximate nearest-neighbor search can be deterministic.
7 Indexing and Determinism
- Batch items are inserted in verified sorted order, usually by ID, to avoid race conditions and insertion-order dependencies.HNSW entry points are fixed to the first inserted node (ID 0), replacing randomized initialization.Source: §7 · p. 5
- Fixed-point distance metrics make the graph topology identical across runs.Source: §7 · p. 5
- Valori concludes that approximate nearest-neighbor search can be implemented deterministically.The method combines stable insertion and entry-point ordering with fixed-point neighbor selection.Source: §7 · p. 5
8 Evaluation
Evaluation tests cross-platform snapshot consistency, retrieval latency, and semantic fidelity against floating-point indexing. Valori reports identical restored state and result ordering, sub-500-microsecond typical retrieval, and 99.8% mean Recall@10 in the tested configuration.
8.1 Cross-Platform Consistency
- HA ≡ HB after an x86-to-ARM snapshot transfer, and k-NN result ordering remained identical after restoration.Valori guarantees identical result ordering and scores for a fixed query and memory state, not equivalence with floating-point recall.Source: §8.1 · pp. 5–6
8.2 Performance
- < 500µs was the raw retrieval latency for typical k-NN queries in local MacBook Pro M3 benchmarks.The authors note that fixed-point arithmetic adds saturation-check overhead, while no_std optimizations keep latency low.Source: §8.2 · p. 6
8.3 Semantic Fidelity Under Fixed-Point Quantization
- 99.8% mean Recall@10 was achieved across queries when comparing Valori’s Q16.16 index with the floating-point baseline.Both indices used identical insertion order, HNSW parameters, and dataset partition; the authors describe this as an existence proof, not a general performance theorem.Source: §8.3 · p. 6, Table 3 · p. 6
- The authors do not claim universal recall preservation across embedding models or dataset distributions.They frame the reported semantic-fidelity result as evidence for one widely used real-world configuration, rather than a general performance theorem.Source: §8.3 · p. 6
9 Applications
The paper presents deterministic memory as relevant to robotics, auditability, decentralized networks, and consensus systems. These examples depend on replaying or verifying shared memory states.
9 Applications
- Robotics and drones could load the same memory kernel from simulation onto embedded hardware without behavior shift.Source: §9 · p. 7
- Financial and medical AI agents could be audited by replaying command logs to verify how a decision was reached.Source: §9 · p. 7
- Distributed nodes can verify that they hold the same state by comparing memory hashes.Source: §9 · p. 7
- Consensus-driven systems need nodes to converge on identical state after the same inputs, which Valori’s deterministic state machine is designed to satisfy.Source: §9 · p. 7
10 Related Work
Valori contrasts its reproducibility priority with vector databases optimized for recall and throughput, and brings numerical-reproducibility standards to high-dimensional vector search.
10 Related Work
- Valori prioritizes correctness and reproducibility over the speed-oriented tradeoff accepted by vector databases such as FAISS, Milvus, and Qdrant.Those systems optimize for recall and throughput using hardware acceleration.Source: §10 · p. 7
- Vector databases use hardware acceleration, including AVX-512 and GPUs, while accepting floating-point non-determinism as a tradeoff for speed.Source: §10 · p. 7
- Numerical reproducibility is a recognized challenge in scientific computing and game simulation, and Valori applies those standards to high-dimensional vector search.The passage cites Goldberg for the scientific-computing context.Source: §10 · p. 7
11 Limitations & Future Work
Valori's stated limits concern fixed-point precision, software performance, and nondeterminism before vectors enter the kernel; the conclusion presents deterministic memory as a system primitive.
11 Limitations & Future Work
- Q16.16 has less dynamic range than f32, though its precision is described as adequate for normalized embedding vectors typically in [−1, 1].Extremely small or large vector components may suffer quantization error.Source: §11 · p. 7
- Software fixed-point arithmetic is slower than hardware-accelerated floating-point operations; SIMD integer instructions are future work where safe.Source: §11 · p. 7
- Valori guarantees determinism only after vectors enter the kernel, leaving embedding-model nondeterminism outside its memory guarantees.Deterministic inference and model-side quantization are identified as possible future work.Source: §11 · p. 7
12 Conclusion
- Valori concludes that integer fixed-point arithmetic and a state-machine architecture can make memory deterministic, auditable, and safe.Source: §12 · p. 7
- The conclusion frames deterministic memory as an essential system primitive as AI moves toward mission-critical infrastructure.Source: §12 · p. 7