Latest Object Memory Management (LOMM)

• LOMM is a memory management approach that treats each memory entry as an explicit object updated with its latest valid state rather than an accumulation of past observations.
• It integrates lifecycle operations—creation, update, retention, and deletion—with validation and association mechanisms to ensure precise state tracking in diverse contexts.
• Empirical studies in video segmentation, navigation, and dialogue demonstrate that object-centric, usage-aware updates in LOMM outperform traditional recency-based memory methods.

Latest Object Memory Management (LOMM) refers to memory-management schemes in which remembered entities are handled as explicit objects whose stored state should reflect the latest reliable information rather than a monotone accumulation of past observations. The phrase appears explicitly in temporally consistent video instance segmentation, where “Latest Object Memory” stores the latest state of each object slot and is paired with “Decoupled Object Association” for identity-consistent tracking [2507.19754]. A closely related interpretation is used in lifelong open-vocabulary navigation, where OVAL makes memory object-centric and descriptor-driven rather than raw-label-centric, storing semantic label, image evidence, position, scene context, and confidence for each object instance [2604.12872]. Adjacent literatures on dialogue, LLM-agent memory, and object-level tiered memory use different terminology, but they converge on the same technical problem: memory must be created, updated, validated, invalidated, demoted, or evicted, not merely accumulated [2210.08750][2603.04443].

1. Conceptual scope and memory-object abstractions

The current literature suggests that LOMM is less a single standardized architecture than a recurring design pattern: memory is organized around explicit objects or object-like units, and those units carry state needed for later retrieval, update, or lifecycle control. In some domains the “object” is a tracked visual instance, in others an embodied scene entity, a dialogue fact, a key-value memory entry, or a managed runtime object.

Setting	Memory object	Representative paper
Video instance segmentation	Slot-wise feature memory (\mathcal{M}_t \in \mathbb{R}^{N \times C}) with occupancy state	[2507.19754]
Lifelong ObjectNav	Descriptor tuple ({S_i,\mathcal{I}_i,X_i,H_i,C_i})	[2604.12872]
Long-term dialogue	Memory sentence (m_i) in (M={m_1,\ldots,m_n})	[2210.08750]
Long-running LLM serving	Memory item with payload, embedding, utility (V(m)), tier, and timestamps	[2603.04443]
Self-evolving agent memory	Key-value entry ((k_i,v_i)) plus an ADD/UPDATE decision	[2602.10652]

Two distinctions are especially important. First, these systems do not treat memory as raw history; they distill, structure, or gate what is retained. Second, they attach management metadata to the memory object itself. In OVAL, the memory descriptor is a tuple rather than a single embedding; in AMV-L, each item carries a scalar utility and lifecycle tier; in conversational memory management, each sentence becomes an explicit target of retention, replacement, or deletion. This suggests that LOMM is fundamentally about object identity plus object state, not just storage.

2. Lifecycle semantics: create, update, retain, and forget

OVAL provides one of the clearest object-lifecycle formulations. It stores object-level memories as
[
\mathcal{C}={S_i,\mathcal{I}i,X_i,H_i,C_i}{i=1}^{n(\mathcal{C})},
]
where (S_i) is a processed object label, (\mathcal{I}_i) is an image buffer capped at (N) images, (X_i) is a positional descriptor, (H_i\in\mathbb{R}^{H\times S\times V}) is a scene descriptor implemented as an HSV color histogram, and (C_i) is a confidence probability. Its lifecycle operations are explicitly described as create, merge/update, retrieve, invalidate/remove, bound image evidence, and avoid repeated exploration; at the same time, the published formulation omits timestamps, visitation frequency, decay variables, explicit forgetting schedules, and graph edges between memories [2604.12872].

The dialogue literature makes lifecycle control even more explicit. Memory is a set of natural-language sentences,
[
M={m_1,m_2,\cdots,m_n},
]
and update is defined over sentence pairs ((m_i,s_j)) with four operations:
[
O(m_i,s_j)\rightarrow{\text{PASS},\text{REPLACE},\text{APPEND},\text{DELETE}}.
]
PASS retains only the older sentence when the new one is redundant; REPLACE keeps the new sentence when it contradicts or strictly refines the old one; APPEND keeps both when they are unrelated; DELETE removes both when an old transient state and its completion note should not persist. The target memory state is described as lossless, consistent, and not redundant [2210.08750].

AMV-L generalizes lifecycle semantics into systems form. Each memory item has a continuously updated value, is assigned to hot, warm, or cold tiers, and can be promoted, demoted, retained, or evicted. Warm and cold tiers are retained but excluded from the default request path, which separates total retained memory from retrieval eligibility [2603.04443]. UMEM, by contrast, couples extraction and management in a learned policy: the memory bank is
[
\mathcal{B}={(k_i,v_i)}_{i=1}^{|\mathcal{B}|},
]
and the optimizer emits both memory content and an operation such as ADD or UPDATE, but it does not present an explicit deletion or compaction subsystem [2602.10652].

Across these systems, “latest” does not mean simple recency. It means that memory objects are revised according to validity, relevance, and utility under future reuse.

3. Latestness signals, association, and post-hoc validation

In perceptual settings, the hardest LOMM problem is deciding whether a new observation updates an existing object, instantiates a new one, or should be rejected as stale or spurious. OVAL addresses this with a descriptor-level similarity score
[
S_m=\lambda_H \,\mathrm{Sim}(H_i,H_j)-\lambda_X \,\mathrm{Sigmoid}(k|X_i-X_j|),
]
followed, in ambiguous cases (\tau_l \le S_m \le \tau_u), by a SuperGlue feature-matching stage. Confidence is modeled as
[
C_i=\exp!\left(-\sigma \frac{|\bar p_c-p_c|\, D_{t,\bar p_c}}{A_b}\right),
]
and once a same-instance match is confirmed, higher-confidence observations overwrite stored state when (C_i \le C_j). The stored memory is therefore a “best current view,” not an averaged trajectory or Bayesian belief state. Retrieval is open-vocabulary via synonym generation and KMP substring matching; failed candidates are removed after a panoramic LLM-based check using
[
S=\omega \,\phi({V_k}_{k=1}^{K})+(1-\omega)C_i
]
and thresholded STOP verification [2604.12872].

In video instance segmentation, latestness is encoded even more directly. For each slot, the foreground probability
[
p_t=\sum_{k=1}^{K}P_t^k
]
gates memory update:
[
\mathcal{M}{t}=(1-p_t)\mathcal{M}{t-1}+p_t\dot{Q}t.
]
If the model believes an object is present, memory moves toward the latest aligned feature; if the object is absent or predicted as no-object, memory largely preserves the prior state. This is combined with occupancy-guided association:
[
\mathcal{O}_t=\mathcal{O}{t-1}\lor O_t,
]
so existing and newly appearing objects are handled separately rather than being forced into one undifferentiated matching problem [2507.19754].

The dialogue formulation offers a semantic analogue. REPLACE is the textual counterpart of latest-state revision, while DELETE captures the case in which the latest valid state is “no persistent memory should remain.” That distinction is crucial: a latest-memory system need not preserve every terminal status, and in some domains the correct update is to forget both the old state and its completion note [2210.08750].

4. Working-set control, placement, and the systems interpretation of object memory

At the systems level, LOMM broadens from semantic correctness to computational footprint. AMV-L is explicit that age-based retention such as TTL does not control request-path cost. Each item carries a utility value updated by
[
V(m)\leftarrow \min\left{V(m)e^{-\lambda \Delta t}+\alpha I_{access}+\beta I_{contrib},\,V_{max}\right},
]
is placed into hot, warm, or cold tiers by threshold, and retrieval is restricted to
[
R=T_H\cup \mathrm{Sample}_k(T_W),\qquad |R|\le |T_H|+k.
]
The key design principle is that request-path cost should depend on the bounded retrieval-eligible set rather than on total retained memory [2603.04443].

Clove applies object-level management to CXL-tiered memory inside a managed runtime. It stores object hotness in the upper 16 bits of the object header, uses PEBS to identify delinquent loads, inserts selective instrumentation through the C2 JIT, and compacts hot objects into designated hot-object regions so that an underlying page-tiering system can promote those pages. The policy is capacity-aware and relocation-cost-aware rather than uniformly object-centric: large objects spanning multiple pages are left to the page-based backend [2605.20370].

KLOC moves tiered-memory logic into the kernel by grouping filesystem and networking structures into kernel-level object contexts keyed by files or sockets. Active-context objects are placed in fast memory, inactive contexts are demoted rapidly, and prefetched I/O pages are directed to fast memory. The object of management is therefore neither an application page nor a user-space semantic record, but a kernel-resident context of inodes, dentries, page-cache pages, journal blocks, or socket buffers [2004.04760].

ALASKA provides a different systems substrate: handles give unmanaged languages a stable logical identity for heap objects while allowing physical relocation. The handle remains stable, the backing memory may move, and relocation is (O(1)) because only the handle-table entry changes. This work is not framed as LOMM in the semantic-memory sense, but it extends object memory management into fragmentation control and compacting movement for unmodified C/C++ programs [2405.00038].

A broader reading is therefore warranted. LOMM can denote latest-state management for semantic objects, but it also points toward a wider object-centric doctrine in which retrieval eligibility, placement, compaction, and lifecycle state are managed at object granularity rather than through undifferentiated heaps or page-only policies.

5. Representative realizations and empirical evidence

The empirical record consistently favors selective, object-aware memory management over naive accumulation or purely recency-based baselines.

Domain	Representative result	Paper
Video instance segmentation	(54.0) AP on YouTube-VIS 2022	[2507.19754]
Lifelong ObjectNav	HM3D: SR (68.1), SPL (33.8); MP3D: SR (44.1), SPL (18.6)	[2604.12872]
Long-term dialogue	Memory update shows a memorability advantage over Memory accumulate with (p<0.05)	[2210.08750]
Long-running LLM serving	Throughput improves by (3.1\times); (>2s) requests drop from (13.813\%) to (0.007\%)	[2603.04443]
Managed-runtime CXL tiering	Application slowdown reduced by (22\%-84\%) versus page-based systems	[2605.20370]

In the explicit VIS formulation, the ablation is especially direct: a baseline tracker reports (33.9) AP on YouTube-VIS 2022 with ResNet-50, adding DOA alone gives (36.2), adding LOM alone gives (39.2), and the full LOMM system reaches (41.1). The same study reports that LOM outperforms similarity memory and momentum memory on both MinVIS and DVIS backbones, supporting the claim that preserving the latest valid state is more effective than stale or mixed long-term aggregation [2507.19754].

OVAL provides similarly sharp evidence for object-centric memory in embodied navigation. In lifelong ObjectNav on HM3D, removing the memory model drops performance from SR (68.1), SPL (33.8) to SR (56.1), SPL (26.0); removing STOP verification yields SR (61.3), SPL (31.2); removing the probability map yields SR (66.8), SPL (32.3). The strongest degradation comes from removing the memory model itself [2604.12872].

The dialogue setting shows a different but related pattern: selective elimination of invalidated or redundant memory helps more as sessions accumulate. Pairwise operation classification reaches (84.10\%) accuracy with NLI transfer (fine-tune), set-level reconstruction reaches (88.69\%) sentence-level F1, and the gap between Memory update and Memory accumulate widens in later sessions, especially on memory turns [2210.08750].

A precursor from video object segmentation reaches a similar conclusion about latest-only retention. A fixed-size adaptive memory bank based on
[
LFU=\frac{index}{age}
]
outperforms first-and-latest memory on DAVIS 2016, DAVIS 2017, and Youtube-VOS, while increasing inference speed by up to (80\%) over every-(k) and (35\%) over first-and-latest. This is not the same method as VIS LOMM, but it shows that bounded memory is strongest when it is usage-aware rather than purely recency-driven [2204.06626].

6. Limitations, misconceptions, and open problems

A common misconception is that LOMM is equivalent to keeping the most recent observation. The literature does not support that simplification. OVAL uses latest-confidence overwrite only after descriptor association and, when necessary, SuperGlue verification; conversational memory requires PASS, REPLACE, APPEND, and DELETE rather than recency alone; adaptive VOS shows that first-and-latest can underperform usage-aware fixed memory, yet it can also help under complete occlusion when a long-term anchor is needed [2604.12872][2210.08750][2204.06626].

Another limitation is incomplete lifecycle bookkeeping. OVAL explicitly lacks timestamps, counters, recency scores, explicit forgetting schedules, and cross-episode semantic graph structures; dynamic environment handling is limited, and the authors note that recognition accuracy is affected in dynamic, complex, and fast-moving scenarios [2604.12872]. UMEM is strong on utility-driven extraction and revision, but its practical action space is mainly ADD and UPDATE; it does not provide an explicit delete, merge, split, or compression mechanism, nor a principled long-term forgetting theory [2602.10652].

Expressiveness remains an open problem even in textual latest-memory systems. The dialogue paper identifies a “FUSION” case, occurring in about (1.09\%) of collected pairs, where neither keeping the old sentence, nor replacing it, nor appending both is satisfactory; instead, old and new should be synthesized into a new memory sentence. The same work also notes that sentence-independent updating does not model dependencies between memories well, and its pairwise update cost is (\mathbf{O}(|M||S|)), with roughly (80) ms on 1 NVIDIA V100 for a single inference [2210.08750].

Systems-oriented LOMM also has unresolved bounds. AMV-L achieves bounded retrieval eligibility, but it does not impose a strict hard cap on hot-tier size, relying instead on value dynamics and thresholds; it also introduces tuning burden and the possibility that useful but infrequently accessed items decay into lower tiers [2603.04443]. Clove is deliberately selective, but it targets workloads whose hot sets evolve over minutes or hours rather than every few seconds, and it leaves large objects and off-heap memory to the page-tiering backend [2605.20370].

A plausible implication is that mature LOMM systems will need to combine several ideas that are still fragmented across the literature: latest-state preservation, explicit invalidation, bounded working sets, richer temporal bookkeeping, hybrid anchor memories for occlusion and reappearance, and synthesis operators beyond simple replacement or deletion. The existing work shows that object-centric memory management is already effective across perception, dialogue, agent memory, and memory systems; the unresolved question is how to unify these mechanisms without losing the compactness and explicitness that make LOMM useful in the first place.