---
title: Deterministic Projection Memory (DPM)
url: https://www.emergentmind.com/topics/deterministic-projection-memory-dpm
type: topic
---

# Deterministic Projection Memory (DPM)

Searching arXiv for the cited works to ground the article in current papers.
Deterministic Projection Memory (DPM) denotes a family of memory architectures in which memory formation, retention, retrieval, or readout is governed by a deterministic projection rather than by stochastic summarization, unconstrained floating-point behavior, or drift-prone physical conduction. The term is used explicitly for a stateless enterprise agent architecture based on an append-only event log and one task-conditioned projection at decision time [2604.20158]. Closely related work maps the Deterministic Memory Framework (DMF) for conversational agents onto the same idea by projecting interaction features into a scalar Survival Score and evolving that score through a deterministic decay law [2606.03463]. Other papers treat DPM as a conceptual label for deterministic fixed-point embedding memory substrates [2512.22280], deterministic projection pipelines for hyperdimensional in-memory classification [2605.24788], or projected phase-change readout paths that suppress drift [2105.13693]. This suggests that DPM is best understood as a unifying systems principle rather than a single canonical implementation.

## 1. Scope and terminological usage

The literature uses “projection” in several technically distinct senses. In enterprise agents, projection is a task-conditioned condensation of an immutable event log into a budget-bounded memory view [2604.20158]. In conversational memory, projection is the mapping of deterministic content, operational, and provenance signals into a scalar Survival Score $\Omega$ [2606.03463]. In deterministic vector memory, projection is the conversion of floating-point embedding outputs into a fixed-point numerical contract at the memory boundary [2512.22280]. In XL-HD, projection is a deterministic Sobol-based mapping from low-dimensional inputs into a high-dimensional representation for binary in-memory matching [2605.24788]. In projected mushroom-type phase-change memory, projection is the electrical routing of read current through a stable parallel element so that the readout is less sensitive to amorphous-phase drift [2105.13693].

| Line of work | What is projected | Deterministic outcome |
|---|---|---|
| Enterprise DPM | Event log $\to$ task-conditioned context | Replayable decision-time memory view |
| DMF | Feature vector $\to$ Survival Score $\Omega$ | Deterministic retention and pruning |
| Valori | Float embeddings $\to$ Q16.16 integers | Bit-identical states and search results |
| XL-HD | Inputs $\to$ Sobol HD vectors | Binary in-memory classification |
| Projected PCM | Phase state $\to$ stable read path | Drift-resilient readout |

A recurrent misconception is that DPM names a single standardized algorithm. The papers do not support that interpretation. The Valori paper states that it does not use “DPM” as a named term and instead presents a deterministic memory substrate [2512.22280]. The phase-change memory paper likewise does not use the exact term, but describes projected memory cells that implement the same principle of deterministic, drift-resilient readout [2105.13693]. The common denominator is not a shared interface, but a shared design commitment: memory behavior should be reproducible from input sequence, configuration, and hardware contract.

## 2. Projection operators and deterministic state evolution

In DMF, the core projection is explicitly scalar. Each conversational interaction is analyzed through deterministic content signals, conversational cues, and provenance, and the resulting pre-activation is passed through a logistic projection [2606.03463]:
$$
z_{\mathrm{total}} = z_{\mathrm{content}} + z_{\mathrm{op}} + z_{\mathrm{prov}},
$$
$$
\Omega = \sigma(z_{\mathrm{total}} - x_0)
= \frac{1}{1 + e^{-(z_{\mathrm{total}} - x_0)}}.
$$
The content channel is
$$
z_{\mathrm{content}} =
\alpha \cdot ID
+ \beta \cdot |S|
+ \gamma \cdot E_{\mathrm{norm}}
+ \delta \cdot D,
$$
with $\delta < 0$, where $ID(t)$ is information density, $|S|(t)$ is sentiment magnitude from VADER, $E_{\mathrm{norm}}(t)$ is saturated named-entity count, and $D(t)$ is cosine divergence from a moving centroid. Relevance then evolves on a discrete interaction-count axis rather than wall-clock time:
$$
\Delta n = i_{\max} - i,
$$
$$
\Omega_{\mathrm{eff}}(\Delta n) = \Omega \cdot \exp\!\bigl(-\lambda \cdot (1 - \eta \Omega) \cdot \Delta n\bigr).
$$
This design makes retention a pure function of conversation sequence and configuration.

In enterprise DPM, the projection operator is task-conditioned rather than scalar. Memory is instantiated only at decision time from an append-only immutable log
$$
E = \{(e_i, t_i, m_i)\}_{i=1}^n,
$$
using a single projection
$$
\phi_t(E, B, \theta) \to C_t,
$$
where $t$ is the task specification, $B$ is the memory budget, and $\theta$ denotes projection parameters [2604.20158]. The objective is conceptual rather than an explicit optimizer: maximize preservation of anchors such as verbatim numeric facts, dates, and identifiers; require citations to event indices; and emit “unknown” when an anchor is not derivable. The paper frames this as a pure projection over immutable events rather than as incremental state mutation.

Valori makes the projection numerical. A floating-point embedding value $x$ is projected at ingestion into a fixed-point integer representation
$$
X = \mathrm{round}(x \cdot 2^n), \qquad \hat{x} = X / 2^n,
$$
with the reference kernel using Q16.16, round-to-nearest-even, saturation, and integer-only arithmetic thereafter [2512.22280]. Memory then becomes a replayable state machine,
$$
S_{t+1} = F(S_t, C_t),
$$
whose transitions are defined over deterministic integer data structures.

XL-HD uses projection as a deterministic encoding from feature space to hyperdimensional space. A Sobol low-discrepancy matrix is generated,
$$
S := \Phi_{\mathrm{Sobol}}(D, F) \in \mathbb{R}^{D \times F},
$$
then thresholded,
$$
P := \mathrm{sign}(S - 0.5) \in \{-1,+1\}^{D \times F},
$$
and applied as
$$
h := P x \in \mathbb{R}^D.
$$
In the IMC-aligned binary pipeline, classification is performed by binary dot-product matching against binarized class prototypes [2605.24788].

Projected PCM uses an electrical rather than algorithmic projection. The phase configuration still stores the state, but the measured resistance is dominated by a stable parallel liner branch. The readout obeys the same drift and Arrhenius laws as conventional PCM,
$$
R(t) = R_0 (t/t_0)^{\nu}, \qquad R(T) = R_0 \exp(E/k_b T),
$$
but the projected device changes the effective conduction path so that the readout is less coupled to the drifting amorphous region [2105.13693].

## 3. DPM in conversational and enterprise agents

DMF is a CPU-first conversational memory architecture designed to remove LLM calls from the memory-management loop [2606.03463]. The paper identifies four drawbacks of LLM-based summarization at write time: non-determinism, token cost, semantic drift, and opacity. DMF replaces generative compression with classical NLP analysis, vector geometry, and mathematical scoring. The write loop computes $ID(t)$, $|S|(t)$, $E(t)$, $E_{\mathrm{norm}}(t)$, $\mathcal{G}(t)$, an embedding vector, a moving centroid, and divergence $D(t)$; projects these into $\Omega$; optionally applies a social floor for short phatic turns; appends a `MemoryEntry`; and then applies deterministic hard-kill and budget-pressure pruning. The pruning score is
$$
S_{\mathrm{prune},i} = \Omega_{\mathrm{eff},i} + B_{\mathrm{ret},i} - P_{\mathrm{sup},i},
$$
with ties resolved by interaction ID. Recall is likewise deterministic: query parsing, evidence substrate construction, multi-channel candidate generation, hard filters, answerability-aware reranking via
$$
A(e, Q) = \sum_m w_m f_m(e,Q) - \sum_\ell \pi_\ell p_\ell(e,Q),
$$
and source-linked evidence assembly are all specified as pure functions of conversation state and configuration.

The enterprise DPM architecture is stateless by construction [2604.20158]. It is motivated by four load-bearing systems properties in regulated deployment: deterministic replay, auditable rationale, multi-tenant isolation, and statelessness for horizontal scale. Instead of maintaining mutable memory across the trajectory, it appends immutable events and performs one task-conditioned projection at decision time, followed by one decision call. The logged artifacts are the authoritative event log, the projection prompt and completion, and the decision prompt and completion. The paper emphasizes the structural asymmetry between one nondeterministic call and $N$ compounding nondeterministic calls: DPM exposes one projection call per decision, whereas summarization-based stateful memory exposes one consolidation call per event.

The two systems instantiate different forms of DPM. DMF keeps an explicit active queue and long-term archive, but every update, decay, retrieval, and pruning step is deterministic for a fixed input sequence [2606.03463]. Enterprise DPM avoids runtime memory state entirely and reconstructs memory on demand from the log [2604.20158]. A plausible implication is that these represent two poles of the current design space: deterministic stateful memory with transparent scores, and deterministic stateless memory with replayable projection.

## 4. Deterministic numeric memory substrates

Valori addresses a different source of non-determinism: floating-point vector memory itself [2512.22280]. The paper argues that identical models, inputs, and code can yield different memory states and retrieval results across hardware architectures because IEEE 754 arithmetic admits multiple correct implementations. It identifies fused-multiply-add versus separate multiply and add, non-associativity of addition, and SIMD/auto-vectorization differences across AVX2/AVX-512 and NEON as concrete causes. The paper shows bit-level differences for the same embedding across x86 and ARM and gives a nearest-neighbor example in which near-tied cosine scores reverse ranking across architectures.

Valori enforces determinism “at the memory boundary.” Model inference is not forced to be deterministic; instead, floating-point outputs are converted immediately into a fixed-point Q-format, and all storage, indexing, and search thereafter use integer arithmetic with deterministic reduction order and tie-breaking. The reference implementation uses Q16.16 fixed-point integers with i64 accumulators, round-to-nearest-even, saturation on conversion, and integer-only dot products and cosine similarity. Stable top-$k$ ranking is defined by total order, with higher score first and then smaller id.

The architecture is framed as a replayable state machine with deterministic commands such as `Insert`, `Update`, `Delete`, `Search`, and `Link` [2512.22280]. Snapshots serialize full kernel state; command logs serialize the ordered operation sequence; replaying the same sequence yields bit-identical states on any platform under the same kernel version and configuration. The paper reports a snapshot transfer test in which an index built with 10,000 vectors on x86 yields the same internal hash when loaded on ARM, and identical $k$-NN result ordering after snapshot restore. It also reports semantic fidelity with Recall@10 overlap of 0.998 for Q16.16 HNSW versus a Float32 baseline built identically, latency below 500 microseconds for typical queries on Apple M3, and storage cost comparable to float32 because Q16.16 also uses 32 bits per component.

This line of work sharpens the meaning of determinism in DPM. Temperature-zero decoding alone is not sufficient. If the memory substrate itself is numerically unstable across hardware, replayability and auditability fail before retrieval policy or application logic is considered [2512.22280].

## 5. In-memory and physical realizations

In XL-HD, DPM refers to a deterministic projection-and-match pipeline optimized for hyperdimensional computing on in-memory accelerators [2605.24788]. Traditional HDC is described as relying on symbolic binding and pseudo-random hypervectors, which demand large dimensionality and logic-heavy updates. XL-HD replaces those components with a deterministic Sobol projection and binary in-memory similarity matching. Inputs are projected with a fixed low-discrepancy operator, class prototypes are trained in real-valued space with cosine similarity and cross-entropy, and the converged prototypes are binarized for deployment. Inference then reduces to in-situ encoding and binary dot-product classification:
$$
z_k = h_q^b \cdot c_k^b = \sum_{i=1}^D h_{q,i}^b c_{k,i}^b, \qquad \hat{y} = \arg\max_k z_k.
$$

The hardware mapping is explicit. Two 1R ReRAM crossbars implement $P^+$ and $P^-$ for bipolar projection, current comparators perform in-situ binarization without ADC/DAC, and a dedicated $1024 \times 32$ classifier array stores binarized class hypervectors [2605.24788]. The logical encoding array is $1024 \times 1024$ and is tiled into sixteen $64 \times 128$ subarrays. Reported component metrics include `XBar_P` area $189{,}213.64\ \mu\mathrm{m}^2$ and power $245\ \mathrm{mW}$, `XBar_C` area $13{,}290.18\ \mu\mathrm{m}^2$ and power $3.98\ \mathrm{mW}$, and end-to-end footprint of approximately $0.395\ \mathrm{mm}^2$. Single-cycle inference energy is approximately $0.40\ \mu\mathrm{J}$ at $D=1024$, with dataset-specific totals of $0.391\ \mu\mathrm{J}$ for MNIST, $0.279\ \mu\mathrm{J}$ for UCIHAR, and $0.319\ \mu\mathrm{J}$ for ISOLET. At $D=10\mathrm{K}$, the paper reports accuracies of $93.49\%$ on MNIST, $95.22\%$ on UCIHAR, and $94.87\%$ on ISOLET. It also reports that at $D=128$, XL-HD shows $+39.04\%$ and $+12.13\%$ higher accuracy than LeHDC at $D=1\mathrm{K}$ for ISOLET and UCIHAR, respectively.

Projected mushroom-type phase-change memory realizes DPM at the device level rather than at the algorithmic level [2105.13693]. The device uses 80 nm doped Ge\(_2\)Sb\(_2\)Te\(_5\) with a sub-10 nm MxNy projection liner between the bottom electrode and the phase-change material. Two liner thicknesses are studied: $7.5 \pm 1.0$ nm and $4.5 \pm 1.0$ nm. The liner provides a stable, drift-resilient parallel path so that, during read, most current bypasses the amorphous dome. A convenient total-resistance expression for projected mushroom PCM is
$$
R_{\mathrm{Total}} \approx [ (R_{\mathrm{liner}\perp} + (R_{\mathrm{Amor}} \parallel R_{\mathrm{Leak}})) \parallel R_{\mathrm{liner}\parallel} ] + R_{\mathrm{Crys}}.
$$
The paper reports up to $10\times$ reduction of drift coefficients in RESET states compared to unprojected devices, effective activation energy reduced from $0.21$ eV to approximately $0.15$ eV for the projected read path, and linear temperature sensitivity of the projected drift coefficient of approximately $0.6\%/^{\circ}\mathrm{C}$. It also reports distinct $u_a$-dependent regimes of drift, with better projection efficacy for the thicker $7.5$ nm liner and degraded performance for the thinner $4.5$ nm liner. Read operations were performed at $0.2$ V.

The hardware papers broaden DPM beyond software memory management. In both XL-HD and projected PCM, projection is used to stabilize or simplify the memory-compute interface itself: in one case by replacing pseudo-random symbolic encoding with a fixed low-discrepancy transform, and in the other by routing readout through a stable electrical element [2605.24788; 2105.13693].

## 6. Empirical properties, misconceptions, and open problems

Across the agent-memory literature, DPM is primarily associated with determinism, auditability, and reduced operational overhead. DMF reports that on LoCoMo it achieves overall Avg. Judge Score $0.7753$, Exact Match $0.1039$, and Token F1 $0.3720$, compared with Mem0 at $0.6883$, $0.0747$, and $0.3142$, respectively [2606.03463]. The paper states that DMF outperforms Mem0 across all metrics, including temporal reasoning at approximately $4\times$ better ($0.7072$ vs $0.1526$), while using zero memory LLM tokens and approximately $5\times$ fewer end-to-end tokens on LoCoMo. On LongMemEval-10, DMF reports overall Avg. Judge Score $0.717$ versus Mem0 at $0.767$, but still uses zero memory LLM tokens and approximately $242\times$ fewer end-to-end tokens.

Enterprise DPM shows a different advantage profile [2604.20158]. On ten regulated decisioning cases and three memory budgets, it matches summarization-based memory at generous budgets and substantially outperforms it when the budget binds. At a $20\times$ compression ratio, the reported deltas are factual precision $+0.52$ (exact table value $+0.515$, Cohen’s $h=1.17$, $p=0.0014$) and reasoning coherence $+0.53$ (exact table value $+0.533$, $h=1.13$, $p=0.0034$). It is additionally reported as $7$–$15\times$ faster at binding budgets, with measured wall-clock of $59.8$ s versus $440.3$ s at tight budget and $23.0$ s versus $342.6$ s at moderate budget. The audit surface is correspondingly smaller: DPM logs two LLM calls per decision, whereas the summarization baseline logs $83$–$97$ on LongHorizon-Bench.

Several misconceptions are directly contradicted by the papers. First, “temperature 0” does not eliminate all nondeterminism. The enterprise study reports residual API-level nondeterminism even under temperature zero, and frames its contribution as bounding the nondeterministic surface to one projection call rather than eliminating backend drift [2604.20158]. Second, deterministic memory is not only about application-layer prompts. Valori shows that non-determinism can arise before indexing or retrieval because the same model and code can produce hardware-dependent floating-point embeddings [2512.22280]. Third, projection is not synonymous with summarization or compression. In DMF it is logistic scoring, in Valori fixed-point conversion, in XL-HD a Sobol transform, and in projected PCM a stable read-current path.

The main limitations are equally heterogeneous. DMF reports English-first adapters for information density, social-floor detection, and signal parsing; embedding sensitivity; and the absence of ablation studies, with future work proposed on adaptive scoring calibration and embedding ablations [2606.03463]. Enterprise DPM reports residual nondeterminism under live APIs, a context-window ceiling that would require hierarchical projection for longer logs, and limited scope to two regulated domains and one model family [2604.20158]. Valori notes quantization error, possible performance overhead relative to hardware float, and the fact that determinism is enforced only at the memory boundary rather than in upstream inference [2512.22280]. XL-HD notes sensitivity to dimensionality, binarization thresholds, and hardware variability [2605.24788]. Projected PCM retains residual drift, reduced memory window due to shunting, and temperature sensitivity that may require compensation [2105.13693].

Taken together, the literature presents DPM as a cross-layer doctrine: deterministic memory requires a well-specified projection from raw state into a stable representational or electrical domain, explicit tie-breaking and reduction-order rules, and archival structures that permit replay and audit. The precise projection differs by domain, but the design objective is consistent: make memory behavior a reproducible consequence of inputs and configuration rather than of hidden stochastic updates, floating-point accidents, or unstable physical conduction.

Source: https://www.emergentmind.com/topics/deterministic-projection-memory-dpm