我观察到一件有意思的事:过去半年,很多高度专业的用户从垂直AI产品退回了Codex、Claude这样的通用工作产品。
本质原因是没能跑赢"基模 + harness"这条基线,大量垂类AI产品被这条基线碾压,包括我们做过的一些尝试。基模能力快速上涨,harness 把上下文管理、工具调用、记忆这些工程层封装得很干净,两层叠加,垂类赖以立足的"领域加成"被迅速摊薄。
对专业用户来说,工具灵活度和覆盖度比"看起来更专业"更重要。通用产品一旦覆盖 80% 场景、切换成本几乎为零,垂类就被反向降维了。
但这只是阶段性现象。用户最终要的是真实工作流的真实改善或托管,处理更快、交付更稳、理解更透。加上模型迭代变慢,这种权宜之计带来的热情已经在见顶。
我们的判断是:下一阶段的关键不是再做一个面向垂类的UI或产品体验,而是两件事:把面向垂直领域的全栈能力做厚(数据、上下文、环境、模型的闭环),以及构建真实可迭代的Eval循环,特别是托管真实问题效果还很弱的领域,让"更好地完成了工作"这件事可被验证,而不是靠体感宣传。
这条路我们自己走通了,全栈能力做厚了,Eval循环也跑起来了。
要么补齐全栈和Eval,要么被通用产品反向吃掉。
OpenLoomi v0.6.3 is out.
Guest login works. CLI one-shot runs native. Memory revision diagnostics are visible.
Not flashy, but this is how an AI Mate moves from demo to daily use.
Thanks @zhangxh1023, @hrw991009, @77652189, @Peefy.
OpenLoomi v0.6.1 is out.
Not a flashy release, but a very real one.
We added memory consolidation diagnostics, independent Kokoro and Whisper voice plugins, safer tool-call handling in text messages, better email fallback, and support for generate-reply.
Small things, but they matter when you're building an AI mate that has to survive real work instead of just demos.
Grateful to Nan for the memory diagnostics work, Krish Shah for the voice plugin contribution, and Peefy for keeping the release moving.
Open source gets real when people start touching the boring edges.
github.com/melandlabs/openlo…
I used to think the hard part of agents was getting the loop to run.
Perceive, reason, act, feedback, repeat.
That part is getting easier.
The harder part is making the next loop smarter than the last one.
If the decision from yesterday does not become part of today's reasoning, the system is not really collaborating with you. It is just restarting politely.
That is why memory should not feel like a hard drive.
It should feel like a context: decisions, failed paths, timelines, tool habits, project state, and why the last run changed the next one.
A good loop does not repeat.
It moves the work forward.
openloomi.ai/blogs/loop-engi…
"Own your learning loop" is the right thing.
A learning loop doesn't own much if every run starts from a blank state.
The decisions, dead ends, preferences, and context that made the next run faster than the last should not live in someone's memory or a buried log.
The loop is real with the memory layer.
MIT's insight is exactly why we built OpenLoomi the way we did.
Instead of stuffing more tokens into a finite window, giving AI the tools to navigate, search, and retrieve. like a real expert in a library, not a memorizer.
The future of AI memory isn't bigger brains. It teaches AI how to read intelligently.
That's the bet we're on.
MIT just made every AI company's billion dollar bet look embarrassing.
They solved AI memory. Not by building a bigger brain. By teaching it how to read.
The paper dropped on December 31, 2025. Three MIT CSAIL researchers. One idea so obvious it hurts. And a result that makes five years of context window arms racing look like the wrong war entirely.
Here is the problem nobody solved.
Every AI model on the planet has a hard ceiling. A context window. The maximum amount of text it can hold in working memory at once. Cross that line and something ugly happens — something researchers have a clinical name for.
Context rot.
The more you pack into an AI's context, the worse it performs on everything already inside it. Facts blur. Information buried in the middle vanishes. The model does not become more capable as you feed it more. It becomes more confused. You give it your entire codebase and it forgets what it read three files ago. You hand it a 500-page legal document and it loses the clause from page 12 by the time it reaches page 400.
So the industry built a workaround. RAG. Retrieval Augmented Generation. Chop the document into chunks. Store them in a database. Retrieve the relevant ones when needed.
It was always a compromise dressed up as a solution.
The retriever guesses which chunks matter before the AI has read anything. If it guesses wrong — and it does, constantly — the AI never sees the information it needed. The act of chunking destroys every relationship between distant paragraphs. The full picture gets shredded into fragments that the AI then tries to reassemble blindfolded.
Two bad options. One broken industry. Three MIT researchers and a deadline of December 31st.
Here is what they built.
Stop putting the document in the AI's memory at all.
That is the entire idea. That is the breakthrough. Store the document as a Python variable outside the AI's context window entirely. Tell the AI the variable exists and how big it is. Then get out of the way.
When you ask a question, the AI does not try to remember anything. It behaves like a human expert dropped into a library with a computer. It writes code. It searches the document with regular expressions. It slices to the exact section it needs. It scans the structure. It navigates. It finds precisely what is relevant and pulls only that into its active window.
Then it does something that makes this recursive.
When the AI finds relevant material, it spawns smaller sub-AI instances to read and analyze those sections in parallel. Each one focused. Each one fast. Each one reporting back. The root AI synthesizes everything and produces an answer.
No summarization. No deletion. No information loss. No decay. Every byte of the original document remains intact, accessible, and queryable for as long as you need it.
Now here are the numbers.
Standard frontier models on the hardest long-context reasoning benchmarks: scores near zero. Complete collapse. GPT-5 on a benchmark requiring it to track complex code history beyond 75,000 tokens — could not solve even 10% of problems.
RLMs on the same benchmarks: solved them. Dramatically. Double-digit percentage gains over every alternative approach. Successfully handling inputs up to 10 million tokens — 100 times beyond a model's native context window.
Cost per query: comparable to or cheaper than standard massive context calls.
Read that again. One hundred times the context. Better answers. Same price.
The timeline of the arms race makes this sting harder. GPT-3 in 2020: 4,000 tokens. GPT-4: 32,000. Claude 3: 200,000. Gemini: 1 million. Gemini 2: 2 million. Every generation, every company, billions of dollars spent, all betting on the same assumption.
More context equals better performance.
MIT just proved that assumption was wrong the entire time.
Not slightly wrong. Fundamentally wrong. The entire premise of the last five years of context window research — that the solution to AI memory was a bigger window — was the wrong answer to the wrong question.
The right question was never how much can you force an AI to hold in its head.
It was whether you could teach an AI to know where to look.
A human expert handed a 10,000-page archive does not read all 10,000 pages before answering your question. They navigate. They search. They find the relevant section, read it deeply, and synthesize the answer.
RLMs are the first AI architecture that works the same way.
The code is open source. On GitHub right now. Free. No license fees. No API costs. Drop it in as a replacement for your existing LLM API calls and your application does not even notice the difference — except that it suddenly works on inputs it used to fail on entirely.
Prime Intellect — one of the leading AI research labs in the space — has already called RLMs a major research focus and described what comes next: teaching models to manage their own context through reinforcement learning, enabling agents to solve tasks spanning not hours, but weeks and months.
The context window wars are over.
MIT won them by walking away from the battlefield.
Source: Zhang, Kraska, Khattab · MIT CSAIL · arXiv:2512.24601
Paper: arxiv.org/abs/2512.24601
GitHub: github.com/alexzhang13/rlm
Every 'AI workspace' demo starts with the user opening the app.
The real workspace is where you already are.
We just shipped one-click installs for OpenLoomi so you can get back to work instead of debugging npm.
github.com/melandlabs/openlo…









