Short answer: use it for memory research, keep retrieval for exact evidence
Our sandbox installed MemT-1.0 in 19 seconds and completed the build in 1 second, but the separate deployment attempt stopped at a missing Compose file. Use it if you research persistent agent memory and can operate its specialized NVIDIA serving stack. Skip it if you need a commercially usable official software stack under the supplied license, or your application must retrieve exact historical evidence.
MemTensor's own README says Flash and Nano lead the evaluated parametric-memory methods while strong textual-memory systems remain ahead overall. That distinction decides the recommendation. MemT compresses historical information into a state the model can consult without reading the old transcript. For a research team studying how agents reuse procedures, that is interesting. For a support system that needs the original sentence behind an answer, I would start with retrieval. MemTensor's evaluation summary
What people use MemT-1.0 for
MemTensor researchers used native memory to carry retrieved coding procedures into later actions without adding experience text to task context. The useful evidence is experimental rather than a list of companies running the models.
| Who used it | What they did | Reported outcome |
|---|---|---|
| MemTensor researchers | Retrieved a coding procedure from an external experience bank and wrote it into Nano's memory | The alphaXiv analysis reports 69.73% average success on SWE-bench Verified, versus 69.13% with textual experience and 66.07% without experience. Coding experiment |
| MemTensor researchers | Wrote chronological history into memory, then removed historical text from the query context | Flash averaged 50.6 and Nano 47.0 across 11 memory benchmarks, leading the evaluated parametric methods. Memory evaluation |
| MemTensor researchers | Compared Nano's persistent state and total inference latency with full-context inference at 128K history | Reported approximately 1.86× faster inference and 66× lower persistent storage, with the experimental scope explained below. Efficiency analysis |
| The reporter of issue #11 | Compared Flash prefill CUDA Graphs enabled and disabled on a reported 4× B300 host | The graph-enabled configuration made requests 6.4% slower. Workload and logs |
The coding result deserves a careful reading. The experience came from an externally constructed bank. An agent received a relevant procedure, and the experiment compared carrying it as text with carrying it as native memory. This measures whether a supplied lesson can guide execution. Autonomous discovery and accumulation of useful lessons is a different job. Experience selection
The same analysis distinguishes solving a task once from solving it consistently. Average success and success on every repeated run improved over no experience, while the count solved at least once did not consistently rise. If your agent already occasionally gets a repository task right, consistency matters. It should not become a claim that native memory unlocks a new class of solvable problems. Repeated-run interpretation
What happened when we ran it
Our November 16, 2026 sandbox run at commit 9ce3ec6 installed the Python project in 19 seconds and completed its build in 1 second. The project lives in ./inference/. These are repository setup measurements, separate from the researchers' inference experiments.
| Our recorded check | Result |
|---|---|
| Install | Succeeded in 19 seconds |
| Dependencies | 36 recorded; 39 MB on disk |
| Build | Succeeded in 1 second |
| Tests | Skipped: no tests script or target |
| Dependency audit | pip-audit reported 0 known vulnerabilities |
| Repository scan | 137 files, approximately 15,481 source lines, 12 MB checked out |
| Delivery signals | 0 CI workflow files, no Dockerfile, no tests directory |
The recorded sandbox configuration was 3 CPUs, 8 GB RAM and image ghcr.io/astral-sh/uv:python3.12-bookworm. The image label identifies the configured image. Actual runtime and operating-system versions require the raw toolchain logs. A 39 MB dependency footprint also says nothing about the checkpoint weights needed to serve Nano or Flash.
The separate hands-on safety step failed because none of the accepted Compose filenames existed: compose.yaml, compose.yml, docker-compose.yaml or docker-compose.yml. The runner required a Compose file. That is a failure of this deployment path, not an inference failure returned by MemT.
There is a conflict in the records: the run-setup entry says the software was deployed with its own Docker Compose, while the actual safety step records the missing-file failure. We treat the attempted deployment as blocked. The teardown entry says cleanup completed successfully. There are no model answers to score from this attempt.
Where people get stuck: runtime modes and graph settings
The official server requires Linux, NVIDIA CUDA, Python 3.11 or newer, and a complete local BF16 checkpoint with matching configuration and tokenizer assets. Its custom memt-sglang integration targets SGLang 0.5.16. The example configurations use two GPUs for Nano and eight for Flash. The guide calls these starting configurations, so treat them as examples rather than minimum hardware requirements. Official inference guide
| Where the friction appears | Documented response | Status in the supplied evidence |
|---|---|---|
| Flash memory decode graph needs ownership support inside SGLang | Apply the hash-checked decode-owners patch to the pinned source checkout | Current delivery uses patches; the maintained pinned-fork replacement is unfinished |
| Stable top-k or strict Flash numerics need dependency changes | Apply the corresponding documented patches | Installing the wheel alone leaves those capabilities unavailable |
| Flash prefill graphs slow the workload in issue #11 | Leave prefill graphs disabled for that workload | Open issue, no maintainer response in the supplied thread |
| Community GGUF files fail in upstream llama.cpp | Use the conversion author's custom native-memory branch | Community runtime route, separate from official BF16 serving |
The patch details come from the inference guide; the graph result comes from issue #11; the GGUF requirement comes from the conversion author.
Issue #11 is especially useful because graph capture actually worked. The reporter describes a 4096-token prompt, one concurrent request and the same workload with the graph switch changed. Mean request time increased from 2001 ms to 2129 ms. The guide recommends enabling prefill graphs, yet this measured configuration went backwards. I would keep the default-off setting until an equivalent workload comparison on the intended machine supports changing it. The report's explanation of graph breaks is the reporter's diagnosis, not ours. Reported experiment
The memory decode graph has another wrinkle: enabling it can also select stable C4 top-k ordering unless explicitly overridden. That changes expert-selection policy. Record the resolved companion switches with performance results, rather than writing only “graph on.” Otherwise, two apparently matching runs can use different execution policies. Graph coupling
The storage saving excludes shared model weights
The reported 66× reduction at 128K history concerns persistent state per trajectory and excludes shared weights and other shared components. The accompanying Nano latency experiment used two GPUs, one request, and a forced 128-token response, including history preparation in total latency. Those conditions make the result useful for comparing history handling, rather than sizing an entire service. Experimental scope
Short histories change the choice. The analysis says full context was generally faster there, with the approaches about even at 32K history. Writing memory has a cost, and the authors attribute much of the long-history advantage to preparation. An application with mostly brief conversations should compare total request time before adopting a stateful memory system for efficiency. History-length comparison
Fixed state per conversation also leaves the number of conversations in your capacity plan. Saving a state for each project can make storage predictable per project, but the total still grows with projects. Mixture-of-Storage increases configured capacity through multiple memory experts. It does not remove the finite-capacity tradeoff between absorbing new information and retaining old details. State-capacity analysis
Security and licenses: client credentials do not configure the server
The inference guide says MEMT_API_KEY supplies a Bearer token to clients and examples, and explicitly says it does not configure the server's API key. The example scripts bind to 127.0.0.1:30000. Keep that distinction in your deployment checklist: setting a client variable should never be your evidence that a network service requires authentication. Credential and bind settings
The launcher rejects remote checkpoint code, configuration merging and request-header overrides. These are useful documented restrictions for a research server loading local assets. They are specific controls, rather than a security rating for the whole application. The project also keeps memory snapshots in a server-owned directory, so include that directory when deciding who can access retained project information. Launcher restrictions and snapshot directory
The repository software uses PolyForm Noncommercial, Nano's model weights use Apache 2.0, and Flash's model card specifies MIT. Those are separate artifacts with separate terms. A permissive weight license does not turn the official SGLang integration into commercially permitted software. For a commercial product, resolve the repository-code terms with the authors before choosing that serving route. Repository terms, Nano terms, Flash terms
MemT-1.0 vs MemOS, RAG and full-context inference
Strong textual-memory systems lead the overall comparison in MemTensor's README, so choose native memory for the stateful research question rather than a blanket recall advantage. The practical alternatives include keeping source text, compressing selected passages, and carrying the full history. Official comparison boundary
| Approach | Why choose it | What the evidence supports |
|---|---|---|
| MemT-1.0 | Study compact state that guides later generation without historical text in the query | Leads the evaluated parametric methods; textual memory remains stronger overall |
| MemOS or a RAG system | Keep retrieval central when detailed historical evidence matters | The paper comparison includes textual-memory systems; this is not a MemT win over every memory approach |
| Full-context inference | Retain history in the active context, especially for shorter workloads | The reported Nano setup was generally slower on short histories and about even at 32K |
| Temp-LoRA | Compare another evaluated parametric-memory method | The alphaXiv analysis gives it 38.1 mean score, below Flash's 50.6 and Nano's 47.0 |
| Chopper's exact-text approach | Evaluate selected source quotes instead of recurrent memory state | Its author proposes a shared-protocol comparison in issue #13 |
The benchmark rows come from the evaluation analysis and README. Chopper's author describes an encoder that selects exact quotes from retrieved snippets in issue #13. Their MuSiQue result is their own experiment, not a direct MemT comparison. The thread is open without a supplied reply or completed joint evaluation. This makes Chopper a candidate baseline, not a demonstrated winner over MemT.
Nano and Flash also need different budgets. Nano has 36B total parameters and Flash 288B, according to the model-family table. Flash's higher reported mean memory score comes alongside a much larger model and different backbone preparation. I would start with Nano when the question is whether native memory helps at all, then justify Flash with a workload that needs the extra capacity. Model family, preparation discussion
What the other reviews get wrong
AI Weekly's blanket MIT description misses Nano's Apache 2.0 weight license and the repository software's noncommercial terms. Its deployment summary also overreaches: the official guide documents a custom SGLang integration with restricted execution modes. Generic vLLM and Docker launch snippets are not evidence of native-memory compatibility. AI Weekly's summary, official serving guide, license distinctions
AIModeling says genuine RAG solutions were absent from the same leaderboard. The paper comparison and README include textual-memory systems. The category label narrows the parametric ranking; it does not mean retrieval was omitted. Readers choosing between native state and RAG need the wider comparison, because the authors themselves say strong textual memory stays ahead overall. AIModeling's account, MemTensor's comparison
The GGUF page contains generic instructions for ordinary local applications alongside a specific warning that upstream llama.cpp refuses these memory tensors. Follow the specific requirement for Brishen's memt-native-memory branch. In an X post, Mr_Buzzoni also describes memory slots in every Transformer block and context living in weights. The architecture instead adds memory to selected blocks and separates changing local state from hyper-memory parameters fixed during online interaction. GGUF requirements, X account, architecture
Prompt Engineer 48's video explicitly says the real model could not run on the creator's laptop and presents simplified simulations of memory approaches. That can explain the idea. It cannot corroborate recall or latency of the released MemT checkpoint. The video's title says it tested the idea, and that is the right boundary to preserve. Video transcript
Questions people ask
MemT-1.0 carries information across interactions in a changing local memory state, allowing later generation without the original historical text. “Towards Memory-Native Evolution” describes that architectural goal. It should not be read as a claim of complete recall or autonomous learning. Architecture and experiments
What is MemT-1.0, and what does “Towards Memory-Native Evolution” mean?
MemT-1.0 is a family of models with memory inside their computation. Selected Transformer blocks read a local state alongside ordinary attention, and token-level updates write information for later turns. The phrase names the effort to make memory an intrinsic model capability. Technical report
Can MemT-1.0 retain information from past interactions and reuse it in the next task?
Yes, the reported experiments use carried memory after the historical text has been removed. In the coding experiment, the reused material is an externally retrieved procedure. The X announcement by MemOS_dev asks this same question; the experimental protocol gives the narrower, useful answer. Announcement, protocol
How accurately does Nano remember a one-million-token chat log?
A fixed-size memory file gives no recall score for a million-token conversation. On r/LocalLLaMA, BenjiWithTheGoodHair specifically asks for that experiment after discussing the 40 MiB storage chart. Their comment is a request for a test, rather than the result of one. Reader's question
How does MemT-1.0's recall compare with plain RAG?
Strong textual-memory systems remain ahead overall in the official comparison, especially when long histories require detailed evidence retrieval. MemT's first and second places apply to the evaluated parametric-memory category. Choose the comparison for your actual retrieval task rather than treating a category lead as a universal ranking. Evaluation summary
Can I save a small memory file for each project and resume it between sessions?
Yes, the official README documents saving a session state and restoring it without the previous transcript. The snapshot path identifies a file in the server's configured state directory. Treat a saved state as compressed memory for the matching model setup, rather than an archive from which every original message can be recovered. Save and resume
How do the 36B Nano and 288B Flash variants handle long interactions without full historical context?
Both use local memory readouts during generation and token-level state updates after turns. Their total model sizes differ from the dynamic state they retain. The trained hyper-memory parameters define how storage and reads work, while the local state changes during interaction. Model architecture
Why did Flash receive additional backbone preparation while Nano did not?
The team attributes the difference to time and staffing in issue #5. Its reply says the additional Flash post-training aimed to improve working and coding agent use, while the Qwen backbone had not received the same further optimization. Future work depends on resources. Maintainer reply, translated
Does backbone preparation help native-memory training, or mainly improve agent benchmark performance?
The maintainer describes the goal as improving working and coding agent experience. That reply does not isolate the effect on later native-memory training. Use the stated motivation when interpreting Flash's preparation, and keep causal claims about the memory-training stage for an experiment that separates the two. Issue #5
Can MemT retain information needed for unknown future questions when the goal is already known?
Issue #2 proposes GACC-Bench for exactly that question, and the team expresses interest in the evaluation. The supplied discussion is a proposal and response, with no completed MemT scores. It is a useful next experiment for a project assistant expected to remember information before knowing what you will ask. GACC-Bench discussion
How should GACC-Bench be adapted to evaluate native memory using saved states?
The benchmark author proposes building memory from context plus goal before revealing questions, then answering each question independently from the same saved state without original context. They ask for the memory configuration and results to be reported separately from existing text-token-budget comparisons. Proposed protocol
Have the Papers with Code results and benchmark protocols been verified by the MemT team?
The supplied issue records a request from Hugging Face's Niels and a team commitment to review scores, names, protocols and openness metadata. It contains no completed confirmation or corrections. The thread remains open in the research record. Issue #3 and team reply
Does enabling Flash prefill CUDA Graphs actually improve end-to-end performance?
The issue #11 reporter measured a 6.4% slowdown with successful graph capture on their configuration. That result supports leaving the feature disabled for that workload. The official recommendation and the issue's measured outcome should both inform a fresh comparison on different hardware. Graph experiment
What we have not tested yet
Our evidence covers repository setup and a blocked deployment attempt, not a successful native-memory inference session. We did not load the real weights, measure recall, run a coding task, or reproduce the researchers' GPU results. The pack contains no model-answer records or screenshots from our attempt, so there is no known-answer score or visual walkthrough to present.
We have not tested million-token recall, concurrent user isolation, crash recovery, snapshot confidentiality, total GPU memory, throughput or operating cost. The reported storage ratios exclude shared weights. Our zero-known-vulnerability pip-audit result is a dependency observation, not an application security review. Generic Ollama, LM Studio, vLLM and Docker instructions have no supplied independent native-memory validation; the community GGUF fork also needs its own end-to-end evaluation.
The README and inference guide have English and Simplified Chinese editions. Issue #5's reply is in Chinese and is translated above. We have not evaluated multilingual recall or compared support quality by language. GitHub's public repository facts show a last push on November 8, 2026; the sampled issues include maintainer replies alongside unresolved requests. Neither those replies nor repository attention establish a commercial deployment history.
For the next run, I would save one project state, restore it into a fresh session, and ask questions whose answers are known in advance, including a corrected fact and a detail buried early in the history. Run the same questions with retrieved source text. Record total latency and full serving memory alongside answer accuracy. That comparison would decide whether the smaller state is worth what this application forgets.


