MemTensor MemT-1.0: Open Models With Native Memory, 66x Smaller Than a KV Cache

MemTensor has released MemT-1.0, a family of open-weight language models that carry memory inside the model instead of replaying a long conversation each time. The persistent state stays the same size however long the history grows, which the model card says cuts storage by roughly 66 times compared with a full-context KV cache at 128K tokens of history.

There are two models: MemT-1.0-Nano (36B total, 3B active, built on Qwen3.6-35B-A3B, Apache 2.0) and MemT-1.0-Flash (288B total, 17B active, built on DeepSeek-V4-Flash, MIT). The card is candid about the limits: strong text-based memory systems still score higher overall. Sources: the MemT-1.0-Nano card and the MemT-1.0-Flash card, with a technical report cited on the cards.

TL;DR: MemT-1.0 at a glance

What problem does native memory solve?

Chat assistants and coding agents normally remember by re-reading. The history sits in the prompt and in the key-value (KV) cache, so cost grows with every turn, and when the window fills something has to be dropped or summarized. External memory tools fix this by writing facts to a database and retrieving snippets, which keeps context small but adds retrieval error and an extra system to run. We covered that approach in Beacon's cross-harness agent memory, Tencent's open memory-writer model, and the argument that agents need documentation more than memory.

MemT-1.0 takes a third route: put the memory in the model's computation. After a turn, the model writes what matters into a latent state and the original text can be cleared.

How does MemT-1.0 work?

According to the card, a Native Memory Block runs alongside the backbone's attention and has two parts.

• Local Memory Block: a dynamic, multi-channel memory matrix that evolves across interaction steps.
• Hyper Memory Block: trainable memory query, key and value projections, plus erase, write and forget gates and an output gate.

During generation, memory attention reads from the current memory state, normalizes and gates the readout, and adds it to the backbone attention output. At the end of each turn or segment, a "stable GDN-2" updates the memory token by token. The card also mentions a Mixture-of-Storage design for scaling memory capacity and describes backbone preparation and a two-stage training recipe supported by 34B tokens of data.

The key property: the persistent state has a fixed size. That is what yields the roughly 66x storage reduction at 128K history relative to a full KV cache, and it means the memory cost of a conversation does not grow with its length.

What do the results actually show?

The card reports evaluation across 11 memory benchmarks. MemT-1.0-Flash and MemT-1.0-Nano rank first and second among the evaluated parametric-memory methods. Then comes the sentence that matters: "Strong textual-memory systems remain ahead overall, particularly on long histories that require detailed evidence retrieval."

In plain terms:

• Among approaches that store memory inside model parameters or state, MemT-1.0 leads the comparison set.
• Systems that keep the actual text and retrieve it still do better overall, especially when the question depends on a specific detail from far back.
• The trade is storage and speed against exact recall. A latent summary cannot reproduce a verbatim passage as reliably as a lookup can.

A summary of the paper posted on X also claims a 1.86x inference speedup at 128K history. We did not find that figure on the card, so treat it as the authors' claim from outside the card until you check the report.

Experience-guided coding agents

The card describes a second application: an agentic framework for reusing procedural experience in long-horizon coding tasks. Retrieved experience is stored in native memory and read through memory attention during execution, which the authors say improves task performance without adding experience text to the task context. No numbers for this are on the card text we read, so it is a design direction, not a measured result. For context on how teams are handling agent context today, see our guide to context handoff between Claude Code and Codex.

Questions people will ask

Is this the same as a longer context window? No. A longer window lets the model read more raw text at once, and cost grows with it. MemT-1.0 compresses history into a state that does not grow. The cost is lossy recall.

Is it the same as RAG or a vector database? No. Retrieval keeps your text outside the model and fetches pieces on demand. MemT-1.0 keeps a learned summary inside the model's state. The two can be combined, and the card's own comparison shows textual-memory systems ahead overall, which is an argument for combining them rather than replacing retrieval.

How big is the hardware ask? Nano is 36B total with 3B active, so memory for the weights is the main cost, as with other mixture-of-experts models; Flash at 288B total is a multi-GPU deployment. The memory state itself is small by comparison: the card lists a dynamic memory state of 10M parameters for Nano and 336M for Flash, on top of 451M and 3.61B trainable memory parameters respectively.

Does it matter that the code is custom? Yes for security reviews. The models need trust_remote_code, which executes repository Python at load time. Pin a commit, audit the modeling files and run it in a sandbox first.

What should you benchmark? Test it on your own long-session tasks: ask for details from early in a long conversation, compare against a retrieval baseline, and measure answer accuracy and latency at 32K, 64K and 128K of history. The headline storage figure says nothing about accuracy on your data.

A broom sweeping a cache clock, illustrating how MemT-1.0 clears plaintext history once it is stored in latent memory

One more practical point on cost: because the plaintext conversation can be cleared after each memory write, a long-running assistant can keep prompts short and its serving footprint flat. That is attractive for always-on agents and for devices with limited memory, provided the recall trade-off described above is acceptable for the task.

How to try it

The card's quick start:

1. Use Python 3.11 or newer and a CUDA 13 build of PyTorch 2.11.0.
2. Install Transformers 5.12.1, Accelerate 1.15.0 and Safetensors 0.8.0.
3. Load MemTensor/MemT-1.0-Nano with trust_remote_code=True, bfloat16 and the sdpa attention implementation.
4. Create a session with model.create_session(tokenizer) and call session.chat(...) with enable_memory=True to save the turn into latent memory and clear the plaintext conversation context.
5. Ask a follow-up in the same session; the model answers from latent memory. In the card's example, a user mentions a three-month-old kitten named Memmy who likes small shrimp, and a later question about the kitten's name, age, food and trait is answered correctly.
6. Persist memory with session.save_state(path) as a safetensors file, then restore it later with create_session(tokenizer, state=path). The restored session has zero plaintext messages but still answers correctly.

Standard chat without memory also works through the normal Transformers pipeline.

Because the model uses custom code, trust_remote_code=True is required. Read the repository's modeling files before running it on a machine with sensitive data, as with any custom-code model.

Privacy and control questions

Latent memory changes what "forgetting" means. With text memory you can delete a row. With a latent state, the information is entangled in a fixed-size vector, so selectively removing one fact is harder. The architecture does include erase and forget gates, but whether a user can reliably delete a specific item is not documented on the card. If you build products on it, treat saved state files as personal data, secure them accordingly, and test deletion behavior before promising it. For how agent memory raises privacy questions more broadly, see Perplexity's local Mac agent.

Who should try it

• Researchers studying parametric and state-space style memory, who now have open weights at two sizes.
• Agent builders with very long sessions where KV cache cost dominates and approximate recall is acceptable.
• Not yet for applications needing verbatim recall or auditable memory, where a retrieval system over stored text remains the safer design.

The base model choice is also notable: the Nano model builds on Alibaba's Qwen3.6, and the Flash variant on DeepSeek-V4-Flash, covered in our DeepSeek V4.1 Flash release post. Both inherit their backbone's strengths and licensing terms.

Related reading

• Beacon cross-harness agent memory
• Tencent HY-Memory open memory-writer model
• Agents don't need memory, they need documentation
• Shared memory handoff between Claude Code and Codex
• DeepSeek V4.1 Flash open weights
• Sage-A1.5 open agent model
• Official: MemT-1.0-Nano on Hugging Face and MemT-1.0-Flash

Details are accurate as of October 22, 2026 and come from the Hugging Face model cards and related posts. Benchmarks are the authors' own.