mrkeyoor.comAsk

MemTensor/MemT-1.0tested 16 Nov 2026commit 9ce3ec6

MemT-1.0 review

Our MemT-1.0 sandbox install took 19 seconds and its build took 1 second; the separate deployment attempt stopped because the runner required a missing Compose file.

  • Safety failed
  • Build 1 s
19 sto install
  • 36 packages
LLM Toolsevaluationupdated 16 Nov 2026
+4stars / 7d

MemT-1.0 is a family of models that stores information from earlier interactions in a changing internal memory state. It aims to let an assistant reuse history without putting the old transcript into every new question.

Verdict

Our MemT-1.0 sandbox install took 19 seconds and its build took 1 second; the separate deployment attempt stopped because the runner required 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 commercial permission for the official software under the supplied license or exact historical evidence retrieval, where the authors say strong textual-memory systems remain ahead.

MemT-1.0 infographic: reuse history without the old transcript, plus its uses, our test result, pitfalls and who it suits
Tested 16 November 2026: the source install took 19 s and the build 1 s.

We ran it

Lab card: what happened when we ran MemT-1.0
Lab card from our sandbox run
Screenshot of MemT-1.0 (github.com/MemTensor/MemT-1.0)
github.com/MemTensor/MemT-1.0
Install✓ · 19s36 packages · 39 MB
Build✓ · 1s
Testsn/ano test script
Known vulns0(pip-audit)
Repo137 files~15,481 lines of source · 12 MB · 0 CI workflows

Answers from our run

Does MemT-1.0 build from source?

Dependencies installed in 19 seconds (36 packages), and the build succeeded in 1 seconds. We cloned commit 9ce3ec6 into a clean Debian container with 3 CPUs and no project-specific setup.

Does MemT-1.0 have tests you can run?

Not through a standard command: the project exposes no test script or target that our harness could run.

Does MemT-1.0 have known vulnerabilities in its dependencies?

pip-audit found none in the dependency tree at the time of our run.

Who should not use MemT-1.0?

Commercial products relying on the official repository software under its supplied PolyForm Noncommercial terms.

What are the alternatives to MemT-1.0?

MemOS, Chopper. Our MemT-1.

Setup4/5Our source checkout installed in 19 s and built in 1 s with 36 dependencies, but we did not run a README task.Editor’s note: Repository install and build succeeded, but the separate deployment attempt stopped before a supported model-serving workload could run.
Docs4/5The README has an install section (“Quick Start”) and usage in the same section; we did not run its quickstart ourselves.Editor’s note: English inference documentation describes dependencies, patches and execution restrictions; the documented serving paths were not exercised in our setup run.
Community3/5Last push on 2026-11-08, 540 stars and maintainers answered or closed 3 of the 5 most-discussed issues we sampled.Editor’s note: Sampled issues contain maintainer replies and open evaluation requests, which do not provide enough evidence to rate support capacity or adoption.
Maturity1/5No tagged GitHub release and repository created 2026-10-19.Editor’s note: The recorded scan found no CI workflows or tests directory; no completed inference or production workload supports a maturity rating.

How we score

Who it’s for

Researchers comparing native model memory with textual retrieval.
Agent developers studying reuse of externally retrieved coding procedures.
Noncommercial teams able to operate the documented Linux and NVIDIA serving stack.

Who it’s NOT for

Commercial products relying on the official repository software under its supplied PolyForm Noncommercial terms.
Applications that prioritize exact historical evidence: the README says strong textual-memory systems remain ahead overall.
Developers expecting ordinary upstream llama.cpp to load the community GGUF files: their author requires a custom branch.

Setup reality

Our November 16, 2026 sandbox run at 9ce3ec6 installed the project in 19 seconds and built it in 1 second. It recorded 36 dependencies and 39 MB on disk. Tests were skipped because there was no test script or target; pip-audit reported 0 known vulnerabilities. The configured sandbox had 3 CPUs, 8 GB RAM and image ghcr.io/astral-sh/uv:python3.12-bookworm; actual runtime versions require raw logs.

Serving requires Linux, NVIDIA CUDA, Python 3.11 or newer and a complete local BF16 checkpoint with matching tokenizer assets. The official custom SGLang integration has example configurations using two GPUs for Nano and eight for Flash. The separate hands-on deployment path failed its Compose-file requirement.

Selected Flash features need hash-checked patches to pinned SGLang source. MEMT_API_KEY supplies a client credential and does not configure server authentication. The repository software is noncommercial; model-weight terms differ between Nano and Flash.

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.

Alternatives

ProjectWhat it isPick it when
MemOS gh↗A memory system that stores, retrieves and manages information for models and agents.Choose it for a retrieval-centered evaluation when detailed historical evidence matters; the official MemT comparison puts strong textual-memory systems ahead overall.
ChopperAn encoder approach that selects exact source quotes from retrieved text.Evaluate it when you want a compact text baseline. Its author proposed a shared-protocol MemT comparison in issue #13; that thread supplies no completed comparison.

What people are saying

  1. [velocity-scout] MemTensor/MemT-1.0

Sources

  1. MemT-1.0 official repository
  2. Official inference guide
  3. MemT technical report
  4. Evaluation analysis
  5. Flash prefill graph experiment
  6. Nano model card
  7. Flash model card
  8. Community GGUF requirements

More llm tools reviews