Portable Agent Memory

• Portable agent memory is a family of techniques that externalize agent state (episodic, semantic, procedural, working, identity) for persistence, transfer, and rehydration.
• It employs human-auditable artifact schemas alongside compact machine-native representations to support diverse applications from GUI control to latent context reuse.
• Designs focus on ensuring integrity through cryptographic verification, provenance tracking, and adaptive context management to maintain usability after state movement.

Portable agent memory denotes a family of techniques for externalizing agent-relevant state so that it can be persisted, transferred, reloaded, or moved across runtimes, storage tiers, execution phases, or heterogeneous agent stacks, rather than remaining trapped in transient context windows or model parameters. In current work, this includes cryptographically verifiable persistent memory artifacts for cross-model transfer (Ravindran, 10 May 2026), compact latent buffers or KV state that can be reused by a frozen model (Li et al., 31 Jan 2026), structured execution-state memory for long-horizon GUI control (Liu et al., 30 Jun 2026), and tiered movement of serving-time agent state such as LoRA adapters and prefix caches across CPU/GPU memory (Pan et al., 29 Jan 2026). A central theme across these strands is that portability is not a single representation, but a systems property: memory must remain usable after movement, not merely storable.

1. Conceptual scope and major interpretations

Recent literature uses “portable agent memory” in several technically distinct senses. The common denominator is that memory is treated as an externalized artifact or runtime object with an explicit lifecycle, rather than as an implicit by-product of prompt replay or parameter adaptation.

Portability target	Memory unit	Representative paper
Heterogeneous agent transfer	Five-component memory artifact $M=(E,S,P,W,I)$	(Ravindran, 10 May 2026)
Same-model latent context reuse	Buffer tokens or their KV cache	(Li et al., 31 Jan 2026)
Long-horizon GUI execution state	$m_t=(\phi_t,E_t)$ with item statuses	(Liu et al., 30 Jun 2026)
Inter-tier serving mobility	Private models, LoRA adapters, prefix caches, and other agent-specific runtime state	(Pan et al., 29 Jan 2026)
Local-first multi-agent memory	SQLite-backed persistent memories with provenance and trust	(Bhardwaj, 17 Feb 2026)
On-device conversational carryover	Context State Object with $CSO_t = CSO_{t-1} \oplus \Delta_t$	(Vijayvargiya et al., 24 Sep 2025)

The protocol-oriented formulation is most explicit in "Portable Agent Memory" (Ravindran, 10 May 2026). There, agent memory is an interoperability problem: persistent memory state should move across heterogeneous runtimes without being reduced to “an unverified blob of conversation text.” The paper defines portability around episodic, semantic, procedural, working, and identity memory, selective disclosure, cryptographic verification, and injection-resistant rehydration.

A second line of work treats portability as the movement of machine-native state rather than human-readable records. "Latent Context Compilation" (Li et al., 31 Jan 2026) compiles long context into compact buffer tokens, discards the temporary LoRA “compiler,” and keeps only the buffer tokens or their KV cache as a portable memory artifact compatible with the original frozen model. "Mem-W" similarly represents memory as latent tokens woven directly into the policy’s embedding sequence, unifying working and experiential memory in one latent format (Zhang et al., 10 May 2026).

A third interpretation concerns execution-state portability for agents acting over long horizons. "What Memory Do GUI Agents Really Need?" argues that passive records are insufficient because values must remain bound to workflow role and current status; its Active Task-Driving Memory stores a maintained execution state rather than a trace archive (Liu et al., 30 Jun 2026). "Efficient On-Device Agents via Adaptive Context Management" makes a comparable move for compact conversational state by replacing growing history with an append-only Context State Object (Vijayvargiya et al., 24 Sep 2025).

A fourth interpretation is systems-level portability of inference-time state. "ScaleSim" is explicit that its contribution is not persistent semantic memory “in the cognitive sense”; instead it makes each agent’s private serving-time state movable across constrained hardware tiers so that very large multi-agent simulations remain efficient (Pan et al., 29 Jan 2026). In this setting, portability means coordinated CPU↔GPU movement of models, adapters, prefix caches, and related runtime objects.

This suggests that the modern literature treats portable agent memory as a layered concept. At the highest layer are explicit, transferable user- or task-facing memory artifacts; below that are execution-state memories for acting agents; and below the prompt are portable latent buffers, KV caches, and serving-time runtime state. The term therefore spans semantics, systems, and deployment.

2. Artifact models and representation schemes

The most fully specified artifact model appears in Portable Agent Memory, which formalizes memory as

$M = (E, S, P, W, I)$

where $E$ is episodic memory, $S$ semantic memory, $P$ procedural memory, $W$ working memory, and $I$ identity memory (Ravindran, 10 May 2026). Every entry shares a common base schema with id, parent_ids, created_at, and version, and entries are linked by a provenance DAG. Episodic entries may include fields such as timestamp, actor, observation, salience, and tags; semantic memory stores subject-predicate-object triples plus confidence and provenance. The representation is explicitly content-addressed and signed, so memory is not merely structured but tamper-evident.

Other work adopts more task-specific schemas. Active Task-Driving Memory represents memory state as

$m_t = (\phi_t, E_t),$

where $m_t=(\phi_t,E_t)$0 summarizes workflow-level progress and constraints, and $m_t=(\phi_t,E_t)$1 is a dynamic set of task-relevant item entries with execution status

$m_t=(\phi_t,E_t)$2

Its JSON serialization includes phase, context, schema, and items, and the execution prompt requires rules such as “Store only structured values in memory; do not store raw text dumps” and “Update an item status to finished in the same step after a successful operation” (Liu et al., 30 Jun 2026). The paper’s emphasis on “minimal actionable data unit” makes portability a matter of preserving executable state, not just observation history.

BeliefMem adopts a different representation because its target is partial observability. Rather than storing one deterministic conclusion per attribute, it stores multiple candidate conclusions as separate entries of the form

$m_t=(\phi_t,E_t)$3

with semantic slots such as subject, predicate, object, participants, entities, qualifiers, dialog_ids, time_text, relative_time, and prob (Liao et al., 7 May 2026). The stored values are explicitly “confidence scores used for ranking and updating, not calibrated probabilities.” Portability here is epistemic: what moves across sessions is not only content, but unresolved alternatives.

On-device adaptive context management introduces a lighter-weight textual state object. The Context State Object is a “compressed, structured text log” and “append-only log” carrying fields such as user_goal, agent_refusals, completed_steps, tool_error, ticket_id, and agent_limitation, with update rule

$m_t=(\phi_t,E_t)$4

The State-Tracker emits only new lines or # NO_UPDATE, and the initial CSO is literally # This is the start of the conversation. (Vijayvargiya et al., 24 Sep 2025). This makes the persistent artifact compact, inspectable, and naturally serializable, while remaining co-adapted to the Executor that consumes it.

Local-first systems emphasize infrastructure-facing schemas. SuperLocalMemory stores memories in SQLite with FTS5 indexing and per-memory provenance fields such as created_by, source_protocol, trust_score, and provenance_chain; behavioral learning is isolated into a separate learning.db (Bhardwaj, 17 Feb 2026). MedMemoryBench, যদিও not a portability protocol, implicitly rewards similar choices: session summaries store topic, time, and event information; noise sessions are marked is_noise:true; and source knowledge points are tracked for traceability (Wang et al., 12 May 2026).

Taken together, these designs reveal two dominant representation strategies. One strategy favors explicit, typed, inspectable artifacts that can be signed, filtered, audited, or edited. The other favors latent or compressed machine-native forms that remain closer to the model’s computational substrate. A plausible implication is that portable memory systems increasingly separate representation by function: human-auditable artifacts for transfer and governance, and machine-native artifacts for fast reuse.

3. Transport, rehydration, and runtime movement

Portable memory becomes operational only when it can be moved back into use. The literature therefore pays substantial attention to rehydration, restoration, prefetching, and prompt or attention reinjection.

In Portable Agent Memory, rehydration is a seven-stage pipeline: $m_t=(\phi_t,E_t)$5 Verification checks entry hashes, DAG integrity, and the Ed25519 signature on

$m_t=(\phi_t,E_t)$6

Capability tokens are then validated and used for filtering; relevance is scored by

$m_t=(\phi_t,E_t)$7

with default weights

$m_t=(\phi_t,E_t)$8

Entries with relevance $m_t=(\phi_t,E_t)$9 are included verbatim, entries in $CSO_t = CSO_{t-1} \oplus \Delta_t$0–$CSO_t = CSO_{t-1} \oplus \Delta_t$1 are summarized, and lower-relevance entries are dropped with count annotations. Recalled memory is then wrapped in explicit framing such as [PAM:SYSTEM_DIRECTIVE] and [PAM:DATA:<type>] blocks to mitigate memory-mediated prompt injection (Ravindran, 10 May 2026).

Latent Context Compilation replaces textual rehydration with latent reuse. It defines a compiler mapping

$CSO_t = CSO_{t-1} \oplus \Delta_t$2

that turns a long source context $CSO_t = CSO_{t-1} \oplus \Delta_t$3 into compact buffer tokens $CSO_t = CSO_{t-1} \oplus \Delta_t$4. A disposable LoRA $CSO_t = CSO_{t-1} \oplus \Delta_t$5 is used only during compilation and then discarded. The training objective combines reconstruction and self-aligned regularization so that the buffer tokens remain inside the frozen model’s instruction-following manifold. At inference, the compiled memory is the optimized buffer tokens or their KV cache, making the memory artifact “plug-and-play compatible with frozen base models” of the same checkpoint family (Li et al., 31 Jan 2026).

Mem-W generalizes this machine-native pathway for GUI agents. A trajectory-to-latent compressor

$CSO_t = CSO_{t-1} \oplus \Delta_t$6

maps event sequences into latent memory blocks, which are then concatenated into the policy input

$CSO_t = CSO_{t-1} \oplus \Delta_t$7

The frozen GUI policy consumes this woven sequence directly (Zhang et al., 10 May 2026). This suggests a portability regime in which memory moves not through prompt serialization but through embedding-space insertion.

At the systems level, persistent Q4 KV cache extends the same idea below the prompt. Agent memory is the model’s attention state: layer-wise keys and values, quantized into Q4 blocks of 256 tokens and stored in safetensors. Cache restoration places previously computed KV tensors directly back into the attention path, eliminating redundant prefill. The system supports cross-phase context injection, where each new phase extends a prior prefix rather than rebuilding it; reuse is classified as EXACT, EXTEND, or DIVERGE using character-level prefix matching with a 50% common-prefix threshold (Shkolnikov, 17 Feb 2026).

ScaleSim addresses runtime movement in a different way. It introduces invocation distance as a comparative urgency signal for deciding which agent-specific runtime objects should stay on GPU, which should be evicted to CPU, and which should be prefetched back before demand. The modular interface exposes HandleReq, Evict, DispatchLoadTasks, and Load, and shared objects take effective distance

$CSO_t = CSO_{t-1} \oplus \Delta_t$8

over their referencing agents (Pan et al., 29 Jan 2026). This is portability as tier mobility: the memory is not transferred across heterogeneous agents, but across residency tiers under prediction and preemption.

Across these strands, transport is no longer a trivial deserialization step. Portable memory must be ranked, validated, framed, or directly reattached to the model’s computation. This suggests that portability is inseparable from a re-entry protocol.

4. Multi-agent, long-horizon, and on-device memory organization

Portable agent memory becomes especially consequential in systems with many agents, long horizons, or limited hardware. Several papers therefore treat portability as a mechanism for preserving specialization and continuity without re-training.

DecentMem proposes decentralized memory in which each agent $CSO_t = CSO_{t-1} \oplus \Delta_t$9 owns its own memory $M = (E, S, P, W, I)$0, partitioned into an exploitation pool and an exploration pool: $M = (E, S, P, W, I)$1 Persistent experience is stored as

$M = (E, S, P, W, I)$2

and routing between exploitation and exploration is controlled by agent-local weights: $M = (E, S, P, W, I)$3 The paper proves global reachability under persistent exploration and shows expected cumulative regret

$M = (E, S, P, W, I)$4

matching the stochastic bandit lower bound up to constants (Hao et al., 21 May 2026). Here portability means that memory remains agent-local and role-specific rather than collapsing into a centralized shared store.

LatentMem uses a related but more compressed design. It stores raw trajectories in a lightweight experience bank

$M = (E, S, P, W, I)$5

and composes role-conditioned latent memory for the active agent: $M = (E, S, P, W, I)$6 This avoids “memory homogenization” by ensuring that the same raw experience can be projected into different agent-specific memories according to role profile $M = (E, S, P, W, I)$7 (Fu et al., 3 Feb 2026). A portable memory layer in this sense is framework-agnostic because it is injected at hidden-state level rather than encoded in one orchestration stack’s prompt conventions.

MOBIMEM externalizes post-deployment adaptation into three specialized memories: Profile Memory, Experience Memory, and Action Memory. Profile Memory uses a DisGraph of concept and entity nodes with semantic-free edges and embedding retrieval plus BFS; Experience Memory stores multi-level templates that instantiate reusable control logic and can organize cross-app workflows as DAGs; Action Memory uses ActTree and ActChain structures plus AgentRR record-and-replay to reuse validated interaction sequences (Liu et al., 15 Dec 2025). The paper’s distinctions are portable-memory distinctions: profile facts are broadly portable, experience templates are task-family portable, and action traces are efficient but environment-sensitive.

On-device adaptive context management makes a similar decomposition at much smaller scale. It keeps a compact CSO as permanent context while discarding ephemeral turns, using separate LoRA adapters for execution and state tracking (Vijayvargiya et al., 24 Sep 2025). This suggests that portability on edge devices depends less on perfect semantic generality than on maintaining a compact, explicit state that survives constrained context windows.

U-Mem extends the idea from storage to acquisition. It formalizes the agent state as

$M = (E, S, P, W, I)$8

with fixed backbone $M = (E, S, P, W, I)$9 and evolving memory $E$0, and adds a cost-aware acquisition cascade plus semantic-aware Thompson sampling to learn which memories are actually useful (Wu et al., 25 Feb 2026). In this view, portability is reinforced by external memory because improvement happens through memory evolution rather than weight updates.

A recurring implication across these systems is that portable memory in multi-agent settings must preserve heterogeneity. Memory that is too centralized or too homogeneous undermines specialization, while memory that is too low-level becomes brittle across environments.

5. Integrity, security, and auditability

Portability exposes memory to transfer, inspection, and re-use, but also to tampering, poisoning, and silent drift. A substantial subliterature therefore treats integrity and auditability as part of memory portability rather than as add-on concerns.

Portable Agent Memory provides the strongest cryptographic account. Entries are content-addressed by BLAKE3 over canonical JSON excluding the id field, child IDs commit to parent_ids, the component root is signed with an operator Ed25519 key, and capability tokens provide scoped permissions such as read, write, derive, redact, export, and rehydrate (Ravindran, 10 May 2026). This yields integrity, provenance traceability, and selective disclosure. Its injection-resistance layer is empirical rather than formal, but the paper reports zero successful executions over 200 attack patterns by combining structural framing, escaping, and content-type enforcement.

SuperLocalMemory addresses a different threat model: persistent poisoning in local-first multi-agent memory. It stores provenance fields per memory and applies trust-gated writes. Operational trust updates follow

$E$1

while the evaluation also reports posterior trust means under a $E$2 prior. Agents with

$E$3

are blocked from write and delete operations. In synthetic poisoning experiments, benign trust converges to $E$4; a direct poisoner drops to $E$5; the single-poisoner trust separation gap is $E$6; and sleeper attacks show a 72.4% trust degradation from $E$7 to $E$8 (Bhardwaj, 17 Feb 2026). Portability here is local-first and protocol-accessible, but guarded by provenance and trust.

MEMPROBE shifts the discussion from defense to audit. It argues that long-term memory should be evaluated “as a post-interaction artifact that can be directly audited,” not only through downstream task success. Each user has a hidden user-state vector

$E$9

and the benchmark measures what can be reconstructed from the final memory store under full-store and top-$S$0 access. The formal pipeline is

$S$1

This makes auditability a first-class property of portable memory: if a memory artifact cannot be reconstructed or inspected outside the original interaction, it is only weakly portable (Ma et al., 23 Jun 2026).

MedMemoryBench extends the auditability theme to streaming and saturation. Its “evaluate-while-constructing” protocol evaluates memory during accumulation: $S$2 with $S$3, and defines a temporal validity constraint so that no query depends on future sessions (Wang et al., 12 May 2026). The paper’s concept of memory saturation—where more memory leads to worse performance under sustained influx and noise—shows that portable memory requires curation, not just retention.

A common misconception is that portability concerns only interchange formats. These papers suggest otherwise. Without provenance, cryptographic integrity, trust controls, or artifact-level audit, a portable memory store becomes a transport mechanism for errors and attacks.

6. Empirical findings, constraints, and open problems

The empirical literature shows that portable memory can produce large gains, but also that portability is sharply constrained by representation choice, retrieval quality, and model dependence.

Portable Agent Memory reports cross-model transfer continuity over 50 tasks across Claude $S$4 GPT-4, GPT-4 $S$5 Gemini, and Gemini $S$6 Claude. Transfer Continuity Score is

$S$7

with mean TCS values of 0.88, 0.84, and 0.86 for the three directions, versus a no-memory baseline mean of 0.35. Re-Hydration Fidelity under Claude $S$8 GPT-4 falls from 0.91 to 0.71 as compression budget shrinks from 8192 to 2048 tokens. The implementation reports 54 tests, 89 KB JSON artifacts versus 284 KB raw conversation, 61 KB CBOR, and mean JSON latencies of 2.3 ms serialize, 1.9 ms deserialize, 4.1 ms verify all hashes, and 12.7 ms for the full rehydration pipeline on an Apple M2 (Ravindran, 10 May 2026).

Latent Context Compilation shows that portable latent memory can preserve much of full-context behavior even at aggressive compression. Its main operating point is $S$9 compression, i.e.

$P$0

and LCC remains close to the full-context upper bound on SQuAD, Fictional Story, CoQA, BookSum, and XSum. The paper emphasizes that this is portability across instances of the same frozen model, not across arbitrary model families (Li et al., 31 Jan 2026).

Mem-W reports large gains from latent memory-native design, including +27.00 to +30.00 on the MMINA web benchmark depending on backbone, and substantial improvements on Multimodal-Mind2Web, AndroidControl-v2, and GUI-Odyssey (Zhang et al., 10 May 2026). ATMem-UI-8B reaches 76.6% success on AndroidWorld and 23.3% on MobileWorld, while STR-GRPO reduces memory invocation from 48.2% to 31.9% on AndroidWorld and from 49.6% to 30.1% on MobileWorld relative to SFT (Liu et al., 30 Jun 2026). These results support the claim that portability is helped by storing actionable state rather than passive logs.

ScaleSim reports up to $P$1 speedup in AgentSociety, up to $P$2 in an interaction-involved benchmark, and up to $P$3 in information diffusion, while reducing TTFT by 48%–68% versus HiCache under high concurrency (Pan et al., 29 Jan 2026). Persistent Q4 KV cache reports TTFT reductions up to 136× for Gemma, 76× for DeepSeek, and 111× for Llama, plus Q4 memory savings that fit about four times more agent contexts than FP16 within fixed device memory (Shkolnikov, 17 Feb 2026). These are systems-level portability results: moving already-computed state matters as much as representing semantic memory.

Local-first memory systems also show meaningful practical performance. SuperLocalMemory reports 10.6 ms median search latency at 100 memories, zero concurrency errors under 10 simultaneous agents, and the 104% NDCG@5 improvement after adaptive reranking (Bhardwaj, 17 Feb 2026). On-device adaptive context management reports more than a 6-fold reduction in initial system prompt context and 10- to 25-fold reduction in context growth rate, while preserving or exceeding a conventional baseline on complex user tasks (Vijayvargiya et al., 24 Sep 2025).

At the same time, the literature converges on several hard limits. First, many artifacts are model- or runtime-specific. LCC is portable across instances of the same frozen model, not across arbitrary checkpoints (Li et al., 31 Jan 2026). Persistent KV caches are tied to the exact model that produced them; even a different quantization of the same model invalidates them (Shkolnikov, 17 Feb 2026). Second, some memory types are less portable than others. Portable Agent Memory explicitly notes that semantic memory transfers most cleanly, while working memory is the least portable because it is more entangled with originating reasoning state (Ravindran, 10 May 2026). Third, low-level replay memories are brittle: MOBIMEM’s Action Memory depends on UI hierarchy stability and must validate before replay (Liu et al., 15 Dec 2025). Fourth, more memory can hurt. MedMemoryBench shows that long-term retention without adequate filtering often harms performance and formalizes memory saturation through degradation under streaming accumulation and noise (Wang et al., 12 May 2026). Fifth, behavioral success and recoverable memory are distinct capabilities: MEMPROBE finds task completion nearly saturates even for a memoryless baseline, while category-balanced recovery remains only moderate and drops further under top-$P$4 access (Ma et al., 23 Jun 2026).

These results imply that portable agent memory is unlikely to converge on a single universal format. The strongest supported direction is a layered one: explicit and auditable artifacts for transfer and governance; execution-state memories for long-horizon acting; and model-specific latent or KV artifacts for fast same-model reuse. The open problems are correspondingly layered: cross-model portability of latent memory, memory editing and schema evolution, replay resistance and provenance at scale, retrieval under saturation, and evaluation protocols that measure not only whether an agent behaves as if it remembers, but what state actually survives movement.