用 AI 最让人崩溃的瞬间,莫过于你花半天纠正它把任务做对,换个新会话,它转头又踩进同一个坑里。模型做过了事,却没变成它的成长。跑通单次任务之外,它真正缺的是把反馈转化为经验,并在之后主动调用。
这种割裂在 Meta Muse、OpenAI Dots 与 xAI Grok Bot 掀起的私人助理热潮中格外显著:主流的外挂检索最多算翻查静态备忘录,没法把调教过程沉淀为行事默契,而这恰恰是长期助理最核心的门槛。

今天,记忆张量正式发布并开源 MemT 1.0 记忆原生大模型。
它和外挂思路最大的不同,不只是让记忆脱离了外挂模块,内化进底层架构,更在于模型借助训练,自己学会了如何读写、更新和调用记忆,让经验积累本身成为模型能力的一部分。
把记忆,写进模型的骨子里
市面上多数思路喜欢把存聊天记录当成记忆,但存下流水账,应付不了真实世界的动态交互,离真正的助理也还差得远。
MemT 1.0 的工艺报告中就提到一场硬核的测试:使用者先给出展览原定时间,随后敲定周日正式改期,中间还顺嘴提了一条未被采纳的周一备选思路。此后双方东拉西扯聊了五百多轮、攒下约 6.6 万 token 的聊天记录,期间再未提过展览半个字。
如果靠传统外挂检索,面对跨度这么长的多版本信息,极易把闲聊当定论;但 MemT 1.0 在完全脱离原始文本的「闭卷」状态下,仍旧准确报出了原定与改期时间,明确指出场地、票价和联系人未变,将周日定论与周一备选分得清清楚楚。
之所以能做到这一点,是因为 MemT 1.0 走了一条「记忆原生」的工艺路线。

Model:https://huggingface.co/collections/MemTensor/memt-1
在架构外观上,MemT 1.0 将模型的脑力拆分为两块:
- 主干网络(通用能力): 就像 AI 的出厂设置,装载着它对这个世界的通用认知。
- 动态记忆状态(独立记忆): 相当于模型在具体交互轨迹中实时演进的「专属工作状态」,不同使用者或任务之间彼此独立,在持续交互中动态吸收新信息与经验,并直接参与后续每一轮生成计算。
面对不断涌入的交互信息,MemT-1.0 无需重新训练整个大模型,在每轮对话结束时,直接借助 token 级别的更新机制刷新记忆状态。至于哪些该留、哪些该改,则交由模型在训练中学出的一套门控机制自主决断。
这就解释了前文那场五百多轮的测试里,模型为什么能自动滤掉闲聊噪音,在日程变更时覆盖过时状态、锁定周日定论。到了后续对话与任务执行中,并行记忆注意力机制又会随时提取这些沉淀下来的状态,直接参与当前计算并引导模型的下一步决策。

当然,这种精准的取舍能力没法天生自带,全靠后天硬练。
团队喂了 340 亿 token 数据,分两步打磨这套机制:先用 200 亿 token 做继续预训练,让模型试着用过去片段预测将来;再用 140 亿 token 做后训练,请来「学霸」教师模型给记忆提取打分,用误差倒逼它改进。


取舍之外,还得装得下。MemT 的记忆状态使用固定体积,持续交互只更新已有矩阵;为了在这个固定体积里装下更多细节,团队引入了 Mixture-of-Storage(MoS)架构:基座 MoE 管计算,MoS 让多位「记忆专家」分头掌管存储空间的读写分配。
这套架构+训练的组合拳,在 11 项平台记忆基准测试(覆盖长期保留、动态更新、个性化理解等维度,历史跨度从 16K 直至百万 token)中交出了一份亮眼的成绩单:

全程闭卷作答的 MemT-1.0-Flash 和 MemT-1.0-Nano 均分分别达到 50.6 和 47.0,分别领先同组最强参数化记忆基线 12.5 分和 8.9 分。

消融实验也直接印证了训练与架构的含金量。如果拿掉后训练这一步,Nano 的均分会从 47.0 直接掉到 36.3;将 MoS 记忆专家从 2 个扩充至 4 个,测试均分则最高提高了 2.7 分。

跑分之外,测试里的两个小细节更能直观说明什么才叫高质量的记忆。
约 16K token 的历史里,使用者问起自己的生日,由于从没给出过,模型老实回答不知道,没有瞎编。在一段 3.3 万 token 的对话里,模型需要依据很早之前定下的规矩,来判断两个人谁有资格领工具箱。它准确核对了徽章与登记状态,判定一人合规、一人未登记。
知之为知之,记规则不漏细节,这才是可用 AI 助理的及格线。
自我持续进化,从经验闭环开始
如果把要求拔高一步:过去的踩坑教训,真能改变模型在后续新任务里的做事方式吗?
为了跑通「任务产生反馈、提炼沉淀经验、再改善后续任务」的连续自我改进闭环,工艺团队在真实编程情形里搭建了一套完整训练与执行链路。
第一步,先教会模型怎么把别人的经验「听进去」。
工艺团队先从数万条成功轨迹中提炼出上千条可复用经验;再让基座模型去跑任务,一旦遇上命令报错、空返回或重复无效操作的「卡壳点」,就在卡壳处注入匹配经验重跑。
团队从中严格筛出 4.2 万余条「没经验时做错、补上经验后成功跑通」的样本,专门训练 MemT-1.0 Nano 的记忆原生模块:先把经验写入内部记忆状态,过了卡壳点再启动读取,让模型学会调用记忆里的经验去修正后续动作。
在 SWE-bench Verified 的 500 项任务实测中,提前写入经验的 MemT-1.0 Nano 平均成功率从无经验的 66.07% 升至 69.33%,同一道题独立跑三次全成的比例从 54.00% 提到 61.60%,与直接在上下文里塞入「文本经验」的对照组表现相当(成功率 68.87%,三次全成率 61.60%)。

这说明,哪怕对话框里干干净净,模型单靠脑子里的记忆状态,也完全能消化复杂的排错指南。
第二步,放到实战里边干边学,真正拉开差距。
提前塞经验终归是静态的,真正干活时哪能未卜先知?所以在实战模式下,模型先两手空空独立做题;只有当平台发现它报错、空返回,或者连续三次原地打转时,才当场把匹配的排错经验写进它的内部记忆状态里。
这就好比一个程序员自己先写代码,撞了南墙的那一刻,脑子里突然调出了之前踩坑的教训,当场改写思路把 bug 修好;等这单活干完,这次踩坑和修 bug 的过程又会被提炼成新经验存起来,留着以后救场。
结果表明,这种按实时反馈更新记忆状态的打法,把平均成功率推高到了 69.73%,三次全成率提到 62.80%,双双跑赢文本经验组(69.13% 与 61.80%)。
换到覆盖九种编程语言、包含 300 项任务的 SWE-bench Multilingual,同样在执行中按报错反馈动态触发记忆原生机制,Nano 的平均成功率从无经验的 60.00% 提高至 63.56%,三次全成率从 45.33% 跃升至 55.33%(同样优于文本经验组的 63.00% 与 53.67%)。

可以看到,外部平台负责从实战反馈中提炼经验、捕捉卡壳信号,模型则依靠训练出的记忆原生读写能力将经验内化为下一步的行动修正。这套协同机制,也为智能体走向自主持续演进搭起了底层的模型支点。

从外挂补丁到记忆原生,养成系 AI 被 MemT 1.0 拿捏了
要让这套边干边学的经验闭环在真实业务里长年累月转下去,显然绕不开工程成本的账单。
几轮以内的短对话,拉长上下文或挂个向量数据库确实够用;可一旦进入长周期伴随,传统思路越跑越重,推理延迟和显存开销会持续膨胀。而 MemT 1.0 的动态记忆状态体积固定,持续交互只刷新已有矩阵,边际成本几乎拉平。

工艺报告表明,双 GPU、单并发、batch size 为 1 的测试条件下,处理 64K token 历史,Nano 相对完整上下文思路有约 1.20 倍的端到端推理速度;历史增加到 128K 和 256K token 时,分别达到约 1.86 倍和 3.99 倍。

在 128K token 历史长度下,恢复单条交互历史所需的持久状态存储,大约是完整上下文 KV cache 的六十六分之一,不计共享模型权重。
把单次调用的算力与存储负担打下来,高频、跨周期的记忆读写才真正具备了大规模工程落地的条件。
拿企业内部的研发情形来说,它首先应对的是团队经验的复用难题。
眼下大多数团队用 AI 写代码,最头疼的是天天带新兵:项目规范和排错套路,工程师每次开新会话都得重教一遍,企业等于在为重复的开销持续买单。
在 MemT 1.0 的体系里,真实的业务反馈会持续刷新外部经验库,模型则把这些团队规范逐步内化成直觉。老手少操心,AI 少踩老坑,工艺投入才能沉淀为带复利的团队资产。
往更长远的应用情形看,无论是 7×24 小时在线的个人数字分身、跨月度跟进慢病管理的医疗顾问,还是伴随孩子数年成长的个性化私教,这些强依赖时间厚度的将来应用,都必须建立在记忆原生的底座之上。
过去三年,大模型圈都在卷各种横向指标,人们拼谁的参数大、跑分高、霸榜多。想要保持领先就只能不断换代搞新模型。而从 Memory³ 的分层研究,到 MemOS 的平台探索,再到今天 MemT 1.0 的底层架构重塑,记忆张量切入了时间这条纵向轴:
怎么让模型在陪伴使用者的过程里,越用越聪明。
更妙的是,这是一个养成系 AI:你纠正的每一次错误、给出的每一次反馈,都会借助记忆更新沉淀为它的能力,让下一次的它永远比上一次更顺手、更懂你。
当模型开始在时间里攒下经验,人与 AI 的关系也正在发生变化。出厂参数再强的通用基座,随时可能被更强的模型替代;但一个陪你踩过坑、摸透你所有做事习惯与业务规则的记忆原生模型,却在一天天的磨合里长出了独属于你的壁垒。
这才是笔者在 2026 年,真正愿意为之买单的将来。
本文来源:https://www.ifanr.com/1684997
若有版权问题,请来信告知:13951431913#139.com 或在右方提交评论。
The most crashing moment with AI is when you spend half a day correcting it to get the task right, switching to a new conversation, and it turns around and steps into the same pit. The model did something, but it didn't grow into it. In addition to running through a single task, what it really lacks is turning feedback into experience and calling it proactively afterwards.
This division is particularly prominent in the boom of personal assistants sparked by Meta Muse, OpenAI Dots and xAI Grok Bot: the mainstream plug-in retrieval is mostly a static memo, and it is impossible to precipitate the training process as a tacit understanding, which is the core threshold of long-term assistants.
Today, the Memory Tensor is officially released and the MemT 1.0 Memory Native Large Model is open sourced.
The biggest difference between it and the plug-in thinking is not only that the memory is separated from the plug-in module and internalized into the underlying architecture, but also that the model has learned how to read and write, update and call the memory with the help of training, so that the accumulation of experience itself becomes part of the model's ability.

Most ideas on the market like to store chat records as a memory, but they can't handle the dynamic interaction of the real world and are far from the real assistant.
A hardcore test was mentioned in the process report of MemT 1.0: the user first gave the original time of the exhibition, then confirmed the official rescheduling on Sunday, and also mentioned an unaccepted Monday alternative idea in the middle. Since then, the two sides have chatted about more than 500 rounds and saved about 66,000 tokens of chat records, during which half a word of the exhibition was never mentioned again.
If you rely on traditional plug-in retrieval, it is easy to take small talk as a conclusion in the face of multiple versions of information with such a long span. However, MemT 1.0 still accurately reports the original and rescheduled time in the "closed volume" state that is completely out of the original text, clearly indicating that the venue, fare and contact person have not changed, and clearly distinguishing Sunday's conclusion from Monday's alternatives.
This is possible because MemT 1.0 takes a “memory native” route.
On architectural appearance, MemT 1.0 splits the brainpower of the model into two pieces:

Faced with the constant influx of interactive information, MemT-1.0 does not need to retrain the entire large model. At the end of each round of dialog, the memory state is refreshed directly through the update mechanism of the token level. As for what should be retained and what should be changed, it is up to the model to learn a set of gating mechanisms in training to make their own decisions.
This explains why in the above more than 500 rounds of testing, the model can automatically filter out the gossip noise, overwrite the outdated state when the schedule changes, and lock the Sunday conclusion. In the follow-up dialog and task execution, the parallel memory attention mechanism will extract these precipitated states at any time, directly participate in the current calculation and guide the next decision of the model.
Of course, this precise trade-off ability can not be born with, all relying on the hardness of the day after tomorrow.
The team fed 34 billion tokens of data and polished the mechanism in two steps: first, use 20 billion tokens to continue pre-training, let the model try to predict the future with past fragments; then use 14 billion tokens for post-training, please come to the "Xueba" teacher model to score memory extraction, and force it to improve with errors.
In addition to trade-offs, you have to be able to fit in. MemT's memory state uses a fixed volume, and continuous interaction only updates the existing matrix. In order to load more details in this fixed volume, the team introduced the Mixture-of-Storage (MoS) architecture: the base MoE tube calculation, MoS allows multiple "memory experts" to control the read and write allocation of storage space.

This architecture + training combination boxing handed out a brilliant transcript in 11 platform memory benchmarks (covering long-term retention, dynamic updates, personalized understanding, etc., with a history spanning from 16K to millions of tokens):
The MemT-1.0-Flash and MemT-1.0-Nano scores reached 50.6 and 47.0, respectively, which were ahead of the strongest parametric memory baseline of the same group by 12.5 and 8.9 points, respectively.
The ablation experiment also directly confirmed the gold content of training and architecture. If the training step is removed, the average score of the Nano drops directly from 47.0 to 36.3; the MoS memory specialist is expanded from 2 to 4, and the test average score is improved by up to 2.7 points.
In addition to running, the two small details in the test can visually explain what is a high-quality memory.
In the history of about 16K tokens, users asked about their birthday. Since they never gave it, the model honestly answered that they did not know and did not make it up. In a conversation of 33,000 tokens, the model needs to judge who is eligible for the toolbox based on the rules set a long time ago. It accurately checks the status of the badge and registration, and determines that one person is compliant and one person is not registered.
Knowing that, remembering the rules does not miss the details, this is the pass line for the AI assistant.

If the requirements are raised one step higher: Can the lessons of the past really change the way the model does things in the follow-up new tasks?
In order to run through the continuous self-improvement closed loop of "generating feedback on tasks, refining precipitation experience, and improving follow-up tasks", the process team built a complete training and execution link in the real programming situation.
The first step is to teach the model how to “listen” to the experiences of others.
The process team first extracted thousands of reusable experiences from tens of thousands of successful trajectories; then let the pedestal model run the task. Once the "jam shell point" of the command error, empty return or repeated invalid operation is encountered, the matching experience is injected at the jam shell to run again.
The team strictly sifted out more than 42,000 samples of "making mistakes when inexperienced, successfully running through after replacing the experience", and specially trained the memory native module of MemT-1.0 Nano: first write the experience into the internal memory state, then start reading after the jamming point, so that the model can learn to call the experience in the memory to correct the subsequent actions.
In the 500 tasks tested by SWE-bench Verified, the average success rate of MemT-1.0 Nano with early writing experience increased from 66.07% inexperienced to 69.33%, and the proportion of three full runs of the same question increased from 54.00% to 61.60%, which was equivalent to that of the control group that directly plugged "text experience" into the context (success rate 68.87%, three full completion rate 61.60%).
This shows that even if the dialog box is clean, the model can completely digest complex error troubleshooting guidelines by relying on the memory state in the brain alone.
The second step is to put it into actual combat and learn while doing it, really opening the gap.

After all, experience in advance is static. When you really work, how can you not know the prophet? Therefore, in the actual combat mode, the model first does the problem with both hands empty and independently; only when the platform finds that it reports an error, returns empty, or rotates in place three times in a row, it writes the matching error troubleshooting experience into its internal memory state on the spot.
This is like a programmer writing his own code first. The moment he hit the south wall, his mind suddenly called out the lessons of the previous step on the pit, and rewrote the idea on the spot to fix the bug. When this single task is done, the process of stepping on the pit and fixing the bug will be refined into new experience and saved for later rescue.
The results show that this method of updating the memory state according to real-time feedback pushes the average success rate to 69.73%, the three full success rates are 62.80%, and both win the text experience group (69.13% and 61.80%).
Switching to SWE-bench Multilingual, which covers nine programming languages and contains 300 tasks, and also triggers the memory native mechanism dynamically according to error feedback during execution, the average success rate of Nano increased from 60.00% to 63.56% inexperienced, and the three-times overall success rate jumped from 45.33% to 55.33% (also better than 63.00% and 53.67% in the text experience group).
It can be seen that the external platform is responsible for extracting experience from the actual battle feedback and capturing the jamming signal, while the model relies on the trained memory native reading and writing ability to internalize the experience into the next action correction. This set of synergy mechanisms also sets up the underlying model pivot point for the agent to move towards self-hosted continuous evolution.
To let this set of learning-by-doing experience go on in the real business for many years, it is obviously impossible to bypass the bill of engineering costs.
For short conversations within a few rounds, it is indeed sufficient to lengthen the context or hang a vector database; but once it enters a long period, the traditional thinking becomes more and more serious, and the reasoning delay and graphic memory overhead will continue to expand. The dynamic memory state volume of MemT 1.0 is fixed. Continuous interaction only refreshes the existing matrix, and the marginal cost is almost flattened.
The process report shows that under the test conditions of dual GPUs, single concurrency, and batch size of 1, when processing 64K token history, Nano has an end-to-end inference speed of about 1.20 times compared to the full context; when the history increases to 128K and 256K tokens, it reaches about 1.86 times and 3.99 times, respectively.
At 128K token history length, the persistent state storage required to restore a single interaction history is approximately one-sixteenth of the full context KV cache, regardless of shared model weights.

The computing power and storage burden of a single call are beaten down, and high-frequency, cross-cycle memory reading and writing really has the conditions for large-scale engineering landing.
Taking the R&D situation inside the company, it should first deal with the difficult problem of reusing the team's experience.
At present, most teams use AI to write code, and the most troublesome thing is to bring new recruits every day: project specifications and troubleshooting routines. Engineers have to reteach every time they open a new session. Enterprises are constantly paying for repetitive expenses.
In the MemT 1.0 system, real business feedback continuously refreshes the external experience base, and the model gradually internalizes these team specifications into intuition. Old hands worry less, AI steps less into old pits, and process investment can only precipitate into team assets with compound interest.
Looking at the longer-term applications, whether it is a 7 × 24-hour online personal digital doppelganger, a medical consultant who follows up on chronic disease management across the month, or a personalized private education that accompanies children's years of growth, these future applications that rely strongly on the thickness of time must be built on the original base of memory.
In the past three years, the large model circle has been rolling various horizontal indicators, and people have spelled out whose parameters are big, run high, and dominate the list. If you want to stay ahead of the curve, you have to keep replacing it with new models. From the layered study of Memory ³, to the platform exploration of MemOS, to the underlying architecture reshaping of MemT 1.0 today, the memory tensor cuts into the longitudinal axis of time:
How to make the model smarter and smarter in the process of accompanying the user.
Even better, this is a nurturing AI: every mistake you correct, every feedback you give, will be precipitated by the ability of memory update, so that the next time it will always be more handy and understand you than the last time.
As models begin to gain experience over time, the relationship between people and AI is also changing. The general pedestal with stronger factory parameters may be replaced by a stronger model at any time; but a native memory model that accompanies you through the pit and understands all your habits and business rules grows your own barriers in the day-to-day running-in.
This is the future that I am really willing to pay for in 2026.
This article is from: https://www.ifanr.com/1684997 For copyright issues, please write to: 13951431913#139.com or submit a review on the right.





