MemMachine: Memory-Driven Computing & AI

Updated 5 July 2026

MemMachine is a dual-concept framework where memory is an active computational substrate, driving both memcomputing architectures and LLM memory services.
It leverages intrinsic parallelism and exponential information overhead, enabling collective dynamics to tackle NP-complete problems efficiently.
The AI-focused MemMachine preserves raw conversational episodes using layered memory (short-term, long-term, and profile) for optimized retrieval.

MemMachine is a term used in two distinct research lineages. In memcomputing, a MemMachine or MemComputing machine is a proposed new kind of computer that uses the intrinsic memory of physical systems—time‑nonlocal, non‑equilibrium behavior—to perform computation in a collective, brain‑like way; its digital, scalable form maps a finite string of symbols into a finite string of symbols (Ventra, 2023). In large‑language‑model systems, “MemMachine” also denotes an open-source memory system for personalized AI agents that integrates short-term, long-term episodic, and profile memory within a ground-truth-preserving architecture that stores entire conversational episodes and reduces lossy LLM-based extraction (Wang et al., 6 Apr 2026). This suggests two distinct, but conceptually related, uses in which memory is treated as an active computational substrate rather than a passive store.

1. Terminology and scope

A MemMachine in the memcomputing sense is a computing device that uses memory—time non‑local physical behavior—as an active part of computation. In this literature, memory is not a static storage location; it is a non‑equilibrium response function of the system, and processing and storage happen in the same physical substrate. Computation is the emergent, collective dynamics of a network of such units as it relaxes toward special states that encode problem solutions (Ventra, 2023).

A distinct 2026 usage applies the name “MemMachine” to a memory service layer for LLM agents. That system is built around one core idea: keep the ground truth intact and optimize retrieval, instead of letting an LLM continuously compress and rewrite history. Ground truth means the exact, raw conversational episodes as they happened: full text of each user and assistant message, original timestamps and session IDs, and original metadata. The primary design claim is that one should not replace these with LLM-generated summaries or facts as the main source of truth, but instead store the raw episodes indefinitely, build lightweight indices, and use LLMs only for additional layers like summaries or profiles, anchored in those raw episodes (Wang et al., 6 Apr 2026).

2. Formal models of memcomputing

A Universal MemComputing Machine is defined as an eight‑tuple

$\text{UMM} = (M,\Delta, P, S, E, p_0, s_0, F),$

where $M$ is the set of possible states of a single memprocessor, $P$ is the set of arrays of pointers, $S$ is the set of indices labeling transition functions, $E$ is the set of initial states written by the input device on the computational memory, $p_0 \in P$ is the initial array of pointers, $s_0$ is the initial index, and $F \subset M$ is the set of final states. The transition functions are

$\delta_a : M^{m_a} \times P \to M^{m_a'} \times P \times S,$

so each transition can act on many memprocessors simultaneously and write to many of them. The memprocessor states $M$ can be finite, countably infinite, continuous, or mixed. Unlike a Turing machine, each transition function can act on many memory units at once; this is the formal basis of intrinsic parallelism (Ventra, 2023).

The 2014 formalization presents a closely related eight‑tuple,

$M$ 0

and emphasizes four properties: Turing-completeness, intrinsic parallelism, functional polymorphism, and information overhead. Information overhead means that collective states can support exponential data compression directly in memory; functional polymorphism means that the same physical network can implement different functions by changing inputs or control signals, without rewiring (Traversa et al., 2014).

Within this literature, it was shown that the formal UMM model is Turing-complete and that artificial neural networks are a special case of UMMs (Ventra, 2023). The 2014 paper also states that a UMM has the same computational power as a non-deterministic Turing machine, namely it can solve NP-complete problems in polynomial time, while also stressing that these results do not prove the statement $M$ 1 within the Turing paradigm (Traversa et al., 2014). A recurring clarification is that, for some topologies, a UMM with exponential information overhead can solve NP‑complete problems with polynomial resources, but this does not imply $M$ 2, because UMMs are not constrained to the Turing machine model (Ventra, 2023).

3. Dynamics, brain-like features, and phase-space engineering

The memcomputing literature explicitly draws analogies between MemComputing machines and the biological brain, while also stating that these are not claims that MemMachines are brains. The analogies include intrinsic parallelism, combined processing and storage, asynchronous computation, information overhead in topology, functional polymorphism, short‑ and long‑term memory, and avalanche dynamics. Memprocessors both store their state and participate in computation; there is no sharp separation between memory and processor. UMMs and DMMs are inherently asynchronous: they do not require a global clock, and different memprocessors update and exchange information according to continuous-time dynamics. The topology of the memprocessor network is an integral part of the machine, and this built‑in structure is called information overhead (Ventra, 2023).

A central dynamical object in DMMs is the instanton. The system’s state $M$ 3 moves in phase space according to $M$ 4, critical points are points where $M$ 5, and instantons are families of trajectories that connect one critical point to a more stable one. Computation proceeds as a sequence of instantons: the system sits near a critical point, a sudden instanton fires, moving it sharply to another, more stable region, and this is repeated until a solution equilibrium is reached. The same paper compares these trajectories to action potentials and nodes of Ranvier, and further notes that DMMs exhibit variable avalanches with a critical Borel distribution for avalanche sizes with exponent $M$ 6, the same as in neuronal avalanches (Ventra, 2023).

Later work reformulates this picture as phase-space engineering. In a prototypical DMM, the ordinary differential equations depend on a few hyper-parameters that define both the system’s relevant time scales and its phase-space geometry. Numerical simulations show that the DMM explores its phase space efficiently for a wide range of parameters, aided by the long-range correlations in their fast degrees of freedom that emerge dynamically due to coupling with the slow memory degrees of freedom. In this regime, the time it takes for the system to find a solution scales well as the number of variables increases. When these hyper-parameters are chosen poorly, the system navigates its phase space far less efficiently. However, dynamical long-range order persists in many cases even when the phase-space exploration process is inefficient, and it only disappears if the memories are made to evolve as quickly as the fast degrees of freedom (Sipling et al., 11 Jun 2025).

4. Hardware realizations and optimization-oriented architectures

Several papers attempt direct physical realizations of memcomputing ideas. “A Memcomputing Pascaline” describes an electronic version of Pascal’s mechanical calculator using memristive emulators and presents the first experimental demonstration of multi-digit arithmetics with multi-level memory devices. Each digit is stored in one memristor, arithmetic operations are implemented by pulses that change the memristor’s resistance in discrete increments, and a reset-and-carry circuit resets it and generates a carry pulse to the next higher digit (Pershin et al., 2015).

“A Compact CMOS Memristor Emulator Circuit and its Applications” introduces a compact CMOS circuit that emulates idealized memristor characteristics and applies it to a memcomputing application of maze solving using analog parallelism. The circuit realizes a two-terminal variable resistor whose resistance is controlled by the voltage applied across its terminals, with the memristor state held in a capacitor that controls the resistor value. The maze-solving demonstration is a network-level example in which paths with higher current become more conductive and the solution is read out from the evolved conductance pattern (Saxena, 2017).

“Implementation of digital MemComputing using standard electronic components” moves from device proposals to a DMM realization using readily available electronic components. The design uses operational amplifiers, resistors, capacitors, diodes, MOSFETs, BJT transistors, a commercial analog multiplier, and a logarithmic amplifier to implement the continuous-time ODEs of a 3-SAT DMM. The study argues that such hardware circumvents the limitations imposed by numerical noise and exhibits remarkable robustness against additive noise, thereby avoiding issues that arise when DMM dynamics are simulated only through time discretization (Zhang et al., 2023).

“Memcomputing for Accelerated Optimization” specializes the architecture to Integer Linear Programming. It introduces Self‑Organizing Algebraic Gates, which are terminal‑agnostic and are assembled into a Self‑Organizing Algebraic Circuit whose equilibria express ILP solutions. The paper reports that, for the Club2 instance from MIPLIB 2017, the best solution found using a world renowned commercial solver took 23 hours, whereas MemCPU XPC brought the time to solution down to less than 2 minutes, reaching the same global optimum $M$ 7 (Aiken et al., 2020).

5. MemMachine as an episodic memory architecture for AI agents

The 2026 MemMachine system is a memory service for LLM agents built around one core idea: preserve episodes and optimize retrieval over them. Its high-level architecture includes client interfaces through a REST API, Python SDK, and MCP server; internal memory types consisting of short-term memory, long-term episodic memory, and profile memory; and storage backends based on PostgreSQL or SQLite, pgvector, and optional Neo4j. Each incoming message is wrapped as an Episode with producer, timestamp, session_id, optional user_id, agent_id, org_id, project_id, arbitrary metadata, and full message text, and this is persisted to the central database (Wang et al., 6 Apr 2026).

During ingestion, each episode becomes part of the current session’s short-term memory, and for long-term memory the episode text is split into sentences with the Punkt tokenizer; each sentence is given a unique ID and inherits metadata, sentence–episode relational links are stored, and a semantic embedding is computed for each sentence. Profile memory is an optional layer in which batches of episodes are sent to an LLM to extract or refresh user profile facts, but these facts remain anchored to episode IDs for traceability. The system’s retrieval path is explicitly structured: STM search, LTM vector search, contextualization, deduplicate and rerank, chronological sort, then return episodes plus STM summary and profile snippets to the answer model. Contextualization uses nucleus matches and nucleus expansion. After embedding the user query into $M$ 8, the system searches sentence embeddings $M$ 9 by

$P$ 0

takes top- $P$ 1 sentences as nucleus sentences, then expands each hit into surrounding episodes so that the answer model sees coherent conversational segments rather than disjoint sentences (Wang et al., 6 Apr 2026).

The same paper adds an opt‑in Retrieval Agent for multi-hop and complex queries. Its tool tree contains a ToolSelectAgent router, strategy nodes called ChainOfQueryAgent, SplitQueryAgent, and MemMachineAgent, and a DeclarativeMemory leaf search. Direct retrieval is used for single-hop questions, SplitQueryAgent decomposes multi-entity but independent questions into 2–6 sub-queries executed in parallel, and ChainOfQueryAgent performs iterative multi-hop reasoning with a maximum of 3 iterations, evidence-only sufficiency judgment, entity grounding, and bounded cost. Multi-query reranking then reranks candidate episodes against the concatenation of the original query and all intermediate rewrites (Wang et al., 6 Apr 2026).

6. Benchmarks, neighboring frameworks, and open issues

The 2026 MemMachine paper reports results on long-horizon conversational memory and multi-hop retrieval tasks. On LoCoMo, with gpt-4.1-mini in agent mode, MemMachine reaches an overall LLM-judge score of 0.9169; on LongMemEval $P$ 2, a six-dimension ablation yields 93.0 percent accuracy with GPT-5-mini, sentence chunking enabled, a user-query prefix, structured formatting, the “Edwin3” search prompt, and retrieval depth $P$ 3; on HotpotQA-hard, the Retrieval Agent reaches 93.2 percent accuracy and 95.5 percent recall of gold supporting facts; on WikiMultiHop under randomized-noise conditions, the Retrieval Agent reaches 92.6 percent accuracy; and compared with Mem0, MemMachine uses roughly 78–80 percent fewer input tokens under matched conditions (Wang et al., 6 Apr 2026).

Benchmark or setting	Reported result	Note
LoCoMo, gpt-4.1-mini, agent mode	0.9169	Overall LLM-judge score
LongMemEval $P$ 4	93.0%	Best configuration with GPT-5-mini
HotpotQA-hard, Retrieval Agent	93.2% accuracy	95.5% recall
WikiMultiHop with randomized noise	92.6% accuracy	Retrieval Agent
Matched comparison with Mem0	78–80% fewer input tokens	Memory mode efficiency

The same evaluation emphasizes that retrieval-stage design dominates ingestion-stage tweaks: retrieval depth tuning gives +4.2 percent, context formatting +2.0 percent, search prompt design +1.8 percent, and user-query bias correction +1.4 percent, whereas sentence chunking gives +0.8 percent. A further result is that GPT-5-mini exceeds GPT-5 by 2.6 percent when paired with optimized prompts, making it the most cost-efficient setup. The reported limitations include extremely long histories, multi-session aggregation, temporal reasoning, lack of procedural memory, recall drop under heavy noise, and model and prompt sensitivity; planned directions include procedural memory, enhanced temporal indexing, adaptive retrieval depth, multimodal memory, learned routing policies, and stronger privacy and on-prem support (Wang et al., 6 Apr 2026).

Neighboring work places MemMachine in a broader memory-systems landscape. Neuromem treats external memory as a streaming, stateful component under an interleaved insertion-and-retrieval protocol and reports that the memory data structure largely determines the attainable quality frontier, that performance typically degrades as memory grows across rounds, and that time-related queries remain the most challenging category (Zhang et al., 15 Feb 2026). MemMA frames a “memory machine” for LLM agents as a coordinated multi-agent controller over the memory cycle, with a Meta-Thinker guiding construction and retrieval and an in-situ self-evolving backward path that converts failed probes into repairs; on LoCoMo it improves multiple backends in a plug-and-play manner (Lin et al., 19 Mar 2026). “Memory as Metabolism” explicitly names MemMachine as a close neighbor and reads its critique of probabilistic extraction and compounding error over time as the same fragility-under-drift problem addressed there at the governance layer, rather than at the mechanism layer (Miteski, 13 Apr 2026).