REMORY: Learning Residual Memory for Context Compression

Meta description: Remory adds learned soft memory tokens to compacted summaries, improving Qwen3.8-27B and GLM-5.3-Flash long-horizon benchmark performance and tool reliability.

Tags: Remory, Qwen3.8-27B, GLM-5.3-Flash, long-horizon agents, memory tokens

Featured image: Abstract technology style visual with memory tokens flowing into a compacted summary, no real people, no company logos, no text.

Remory improves long-horizon benchmark performance on Qwen3.8-27B and GLM-5.3-Flash by appending learned soft memory tokens to a compacted summary while reducing repeated tool outputs and tool errors. This matters because agentic systems often lose state across many tool calls. A model may search, read, edit, or query an API over dozens of steps, and if the earlier actions are compressed too aggressively, it can repeat the same call or choose an action that no longer fits the task. Remory's reported approach gives the model a compacted history plus a learned memory signal, which can help it understand what has already happened without flooding the context window with raw text.

Background: The Memory Bottleneck in Long-Horizon Tool Use

Long-horizon tasks are the natural stress test for language models used as agents. A short chat may only need one response, but a multi-step workflow requires memory: which files were inspected, which tool returned which result, which constraints were already applied, and which actions are still pending. The challenge is not simply that context windows are finite. It is that raw history can become noisy. A long log of tool outputs may contain useful facts, stale facts, and repetitive boilerplate. When a model is given that history directly, it may spend attention on the wrong details. When the history is replaced by a summary, some of the state can disappear.

The phrase repeated tool outputs describes a common failure mode: the agent calls the same tool because it does not realize it already called it. Tool errors can follow from the same confusion, especially when the next action depends on a result that was not correctly tracked. Compaction is therefore a trade-off. It saves context space, but it can also erase the exact cues an agent needs to continue cleanly.

Development: Remory Inserts Learned Memory Tokens Into Summaries

Remory addresses that trade-off by adding learned soft memory tokens to a compacted summary. In machine learning, a soft token is generally a learned vector representation rather than a literal word in a vocabulary. That distinction is important because the memory signal is not necessarily ordinary text. It can encode patterns that are hard to express in a natural-language summary, such as whether a prior action succeeded, what kind of information was collected, or which state should be treated as current. The compacted summary still provides readable context, while the appended tokens provide a learned layer that can influence how the model interprets that context.

The described mechanism keeps the compacted summary as the readable context and adds tokens afterward. For an agent loop, this creates a middle path between two extremes: carrying every tool output forward, or replacing the history with a plain summary that may lose subtle state. The goal is to preserve enough operational memory to reduce redundant actions and incorrect tool choices.

Latest Progress: Results on Qwen3.8-27B and GLM-5.3-Flash

The reported results focus on two model variants: Qwen3.8-27B and GLM-5.3-Flash. On both, Remory is described as improving long-horizon benchmark performance while reducing repeated tool outputs and tool errors. The two model names are central here because they show the approach is associated with more than one model variant.

The more important signal is the paired improvement. Higher long-horizon benchmark performance suggests better task completion across extended sequences. Fewer repeated tool outputs suggests the model is tracking prior actions more reliably. Fewer tool errors suggests the model is selecting actions that fit the current state more often. Those effects are connected. If a model can remember that it already searched a page, read a file, or computed a value, it is less likely to call the same tool again. If it can remember which tool result mattered, it is less likely to act on stale or incomplete information.

The current evidence is narrow in the sense that only two model names and one behavioral pattern are specified. No benchmark score, dataset, or exact task suite is provided in the material, so the precise margin of improvement remains outside the available facts. Still, the combination of better long-horizon performance, less repetition, and fewer tool errors points to a practical memory improvement rather than a generic summarization trick.

Current Stage: A Compaction-First Memory Layer

At this stage, Remory looks like a memory-layer technique for agentic models, not a new model family or a replacement for tool APIs. Its value proposition is compact: keep the context small, but make the compressed context more useful. The core mechanism—appending learned soft memory tokens to a compacted summary—fits a broader industry movement toward state-aware memory for agents.

What to watch next is how far the gains generalize beyond Qwen3.8-27B and GLM-5.3-Flash. The next useful questions are which long-horizon benchmarks were tested, whether the soft tokens add measurable latency, how the method behaves when tool outputs are malformed, and whether the improvement survives when the agent must handle conflicting states. If Remory can reduce repeated tool outputs and tool errors across more model sizes and task types, it may become a practical building block for compacted agent memory. If it only helps on the two reported variants, its role remains narrower: a useful state-tracking layer for specific long-horizon workflows.