LCM: Syntax-Free, Memory-Enhanced LLM Methods

• The paper introduces LCM, a deterministic agent architecture that leverages lossless, syntax-free memory management to ensure full state retrievability and termination-guaranteed computation.
• The methodology employs a hierarchical summary DAG for recursive context compression and an engine-managed llm_map operator for deterministic task partitioning, achieving linear scalability.
• Empirical benchmarks on OOLONG demonstrate LCM’s superior performance over conventional approaches, with marked improvements in long-context evaluation and memory integrity.

Lossless Context Management (LCM) represents a deterministic, memory-augmented agent architecture that extends beyond syntax-driven recursion and empowers LLMs with tractable, lossless, and scalable access to long session histories. By formalizing both context compression and recursive task partitioning as engine-managed, syntax-free operators, LCM eliminates reliance on model-authored scripts for memory or parallelization. The resulting paradigm preserves full retrievability of all prior state and provides deterministic, termination-guaranteed primitives for memory and computation (Ehrlich et al., 14 Feb 2026).

1. Recursive Context Compression: Hierarchical Summary DAG

LCM’s core innovation is its context management mechanism, anchoring session state in two co-equal views:

• Immutable Store ($\mathcal{D}$): A log of every message and tool result, maintained verbatim.
• Active Context ($C$): The token window provided to the LLM, consisting of pointers into $\mathcal{D}$ and a set of summary nodes.

Session history is structured as a directed acyclic graph $G = (V, E)$:

• $V = M \cup S$, where $M$ denotes leaf nodes (raw messages $m_1, \dots, m_T$), each with token length $\tau(m_i)$, and $S$ denotes summary nodes, themselves strings of tokens $s_1, \dots, s_K$.
• $C$0 encodes the “summarizes” relation: $C$1 indicates that summary node $C$2 covers $C$3 ($C$4).

Every summary node $C$5 enforces $C$6 and carries a lossless pointer list $C$7. This allows exact, indexable retrieval of all predecessors.

The token budget for active context is managed by soft ($C$8) and hard ($C$9) thresholds. Context compaction can be fully passive (no summarization), asynchronous (background compaction), or blocking (forcing compaction before further input) depending on $\mathcal{D}$0 relative to these thresholds.

The compression ratio $\mathcal{D}$1 quantifies summary efficiency. Substantial reduction in $\mathcal{D}$2 indicates high compaction with lossless retrieval guarantees.

2. Deterministic Recursive Task Partitioning: LLM-Map

Addressing limitations of Recursive LLMs (RLMs), LCM replaces model-authored loops with the llm_map operator—an engine-provided, deterministic primitive for recursive task partitioning:

• Inputs: $\mathcal{D}$3 (dataset in JSONL), $\mathcal{D}$4, schema $\mathcal{D}$5, and worker count $\mathcal{D}$6.
• Procedure: Each item $\mathcal{D}$7 is processed in parallel via the LLM, validated against $\mathcal{D}$8. On validation failure, bounded retries ($\mathcal{D}$9) are triggered; outputs are saved to disk.
• Guarantees: Deterministic control flow, exact-once processing, bounded retries, termination assurance, and no exposure of underlying iteration/concurrency/retry logic to the LLM.

Zero-cost continuity is preserved for small datasets, as the engine automatically inlines short tasks; for large datasets, operations scale to disk without context bloat.

3. Computational Complexity and Scaling Properties

Both context compression and task partitioning in LCM introduce only linear or near-linear overheads:

• Context Compression: Compaction operates in $G = (V, E)$0 time per summary block of size up to $G = (V, E)$1 tokens. The number of such blocks is $G = (V, E)$2 for a history of $G = (V, E)$3 tokens, yielding total time $G = (V, E)$4, where $G = (V, E)$5 is the cost per summary.
• Memory Overhead: $G = (V, E)$6 for the immutable store and $G = (V, E)$7 for the summary graph.
• Task Partitioning: For $G = (V, E)$8 dataset items, $G = (V, E)$9 for $V = M \cup S$0 workers, with disk storage scaling as $V = M \cup S$1. Memory per worker is tightly bounded by single-prompt context size.

This guarantees scalability for histories and datasets comprising millions of tokens, up to the practical limits of model inference cost and block size.

4. Benchmark Results on OOLONG Long-Context Evaluation

LCM’s efficacy is empirically validated on the OOLONG benchmark (TREC-coarse split, 8K–1M tokens), comparing Volt (an LCM-augmented agent) against Claude Code v2.1.4, each running Opus 4.6 for core reasoning:

Context Length	Volt ($V = M \cup S$2 vs Opus 4.6)	Claude Code ($V = M \cup S$3 vs Opus 4.6)
8K	+11.2	+13.1
16K	+25.0	+26.3
32K	+29.2	+24.7
256K	+18.5	+8.5
512K	+42.4	+29.8
1M	+51.3	+47.0

• Absolute Score Average: Volt: 74.8; Claude Code: 70.3 (a +4.5 point edge for Volt).
• Below 32K tokens, performance is nearly identical (as the entire context fits natively).
• Above 32K, Volt's margin over Claude Code widens, notably at 256K and 512K, attributable to LCM’s avoidance of context saturation via engine-managed map-reduce.
• Raw Opus 4.6 deteriorates dramatically beyond 64K, scoring below 20 points at 1M tokens.

5. Design Trade-Offs: Deterministic Structure Versus Model Flexibility

LCM’s architecture reflects an architecture-centric perspective, deliberately constraining agent expressivity in exchange for deterministic guarantees:

• Flexibility vs. Determinism: RLM approaches permit arbitrary symbolic recursion and looping, enabling extensive expressivity but incurring rollout variance and short-context penalties. LCM’s deterministic, engine-managed operators—compaction, llm_map, agentic_map—are less flexible but provide guaranteed convergence and zero-cost continuity on short tasks.
• Retrievability Guarantees: The lossless pointer mechanism guarantees every primitive message $V = M \cup S$4 remains accessible via summary IDs $V = M \cup S$5, even after many compaction rounds. In contrast, model-authored chunking scripts in pure RLMs risk silent omission or data loss.
• Paradigm Analogy: As structured programming replaced GOTO with well-founded control constructs, LCM substitutes stochastic, model-generated scripts with architectured deterministic primitives. This narrows the agent’s internal “search space,” improving reliability and latency.

A plausible implication is that such structured determinism, combined with retrieval guarantees, aligns LCM with production needs for reliability and state integrity at the cost of reducing the upper bound of agentic memory management strategies.

6. Syntactic Independence and Engine-Managed Memory Enhancement

LCM operates independently of model-authored memory or syntax-level constructs, exemplifying a syntax-free approach. Both context compression and task partitioning are accomplished entirely via deterministic, engine-managed primitives, eliminating ambiguity, rollout variance, and the potential for silent data corruption inherent to model-authored memory scripts.

By constraining memory management and parallel execution to architectured operators, LCM confers predictable resilience, state recoverability, and operational tractability in long-context scenarios.

---

LCM's integration of architectural rigor, deterministic control, and lossless state management substantiates the viability of memory-enhanced, syntax-free approaches in LLM agent ecosystems, outperforming established symbolic and fully agentic alternatives in rigorous, long-context evaluation (Ehrlich et al., 14 Feb 2026).