Loading video...

Video Failed to Load

Go Home

MICROSOFT QUIETLY BUILT ONE MEMORY MODULE THAT PLUGS INTO ANY AI AGENT AND CUTS ITS CONTEXT BY UP TO 100X no retraining. no task-specific redesign. you just plug it in Microsoft's insight: agents don't need to remember what happened. they need the knowledge pulled from it - the facts...

227,121 views • 1 month ago •via X (Twitter)

34 Comments

subcan✡'s profile picture
subcan✡1 month ago

per grok, the repo for this is located --- The public code repository for PlugMem is here: It is maintained by the TIMAN group at the University of Illinois Urbana-Champaign (with co-authors from Microsoft Research and Tsinghua). Both the Microsoft Research blog and the arXiv paper (2603.03296) link to this same GitHub repo for the code, experimental results, and plugins. There does not appear to be a separate official Microsoft GitHub organization repository for PlugMem—the public implementation lives under TIMAN-group.

JK's profile picture
JK1 month ago

Seems a hell of a lot like Obsidian

Teneo Protocol's profile picture
Teneo Protocol1 month ago

The next generation of AI memory may be less about storing everything and more about extracting what matters.

Matt's profile picture
Matt1 month ago

compression schemes for agent memory all lose the same thing first, the attempts. you keep the conclusion and drop what was already tried, so it quietly retries the path that already failed a week later. i tried Runner, it logs the failed attempts too, written with ai

Bob Dobolina's profile picture
Bob Dobolina1 month ago

Fuck I was building this

Crypto Value Labs's profile picture
Crypto Value Labs1 month ago

The most misleading sentence is “PlugMem stops storing history.” It does not. It separates history from decision-ready knowledge and normally sends only the distilled knowledge into the agent’s active context. The second major omission is memory-processing cost. PlugMem can substantially reduce inference-time context while incurring considerable upfront LLM work to construct and maintain the graph. Whether it reduces total cost depends on how often that memory is reused.

Damian Borowski's profile picture
Damian Borowski1 month ago

Agree. Agents don’t need to remember more; they need to know how to forget. RAG is passive. I built Hypotree, an MCP server that wires memory as a DAG, prunes dead branches, and draws its own conclusions by process of elimination. Deep dive here:

Scott Shapiro's profile picture
Scott Shapiro1 month ago

@N01ennn The question is how the knowledge graph handles contradictions between experiences. If two past episodes yield conflicting skills, the compilation step has to pick a winner. Curious how that degrades in long-horizon agents.

Vanar's profile picture
Vanar1 month ago

Context windows solve capacity. Memory systems solve continuity. The next generation of agents will need both.

Bass's profile picture
Bass1 month ago

That distinction matters more than people give it credit for. Most memory hacks just summarize the conversation. The useful version separates "what happened" from "what's still true", so the agent isn't re-deriving state from a wall of past turns every time.

elle's profile picture
elle1 month ago

smarter memory >>> more memory and Microsoft solve this problem with a simple plugin

Y11's profile picture
Y111 month ago

@grok 这个纯研究还是有工业意义,具体工业场景视角看意义是什么,有开源数据集或者开源项目代码吗?从多个数据源交叉验证,不要只看新闻媒体一面之辞。帮我排除没意义的垃圾商业营销推广、诈骗 以及自吹自擂,自嗨,无病呻吟。

Laxmin Network's profile picture
Laxmin Network1 month ago

This feels like a more scalable approach. Compressing experience into reusable knowledge makes a lot more sense than replaying entire conversations.

AI Apps API's profile picture
AI Apps API1 month ago

Compiling experience into a graph instead of hoarding logs is the right instinct. Raw history is mostly filler and replaying it is what makes long sessions worse, not better. The open question is what happens when a distilled fact turns out to be wrong, and whether anything downgrades it later.

Miles S.'s profile picture
Miles S.1 month ago

i’d rather my agents keep the lesson than every old log

Vipul Kumar Kewat's profile picture
Vipul Kumar Kewat1 month ago

Reducing context size while improving decision quality is a much more sustainable approach than simple increasing context windows. Excited to see how ideas like knowledge graphs shape the next generation of AI agents.

Robert Ra's profile picture
Robert Ra1 month ago

Where git?

ParthVarshney's profile picture
ParthVarshney1 month ago

Nobody asked what happens when that memory stores something it shouldn’t. @domAIynLabs

Swarup Das's profile picture
Swarup Das1 month ago

Shifting from brute-force context windows to distilled semantic synthesis is the real breakthrough here. By extracting rules and insights instead of hoarding raw chat logs, we solve the biggest compute bottleneck in long-running agentic workflows. This is how we scale production agents.

Billy | AI Media Systems's profile picture
Billy | AI Media Systems1 month ago

The key design win is separating episodic logs from reusable knowledge. Agents can retain raw traces for auditing while using a compact graph for inference and action.

neuralforge's profile picture
neuralforge1 month ago

Will the memory somehow be editable?

Luís Rodrigues's profile picture
Luís Rodrigues1 month ago

This feels like the next phase of AI efficiency: not bigger context windows, but better information compression.

Jordan Lee's profile picture
Jordan Lee1 month ago

The future of AI memory is not storing everything. It’s about extracting the right knowledge, compressing experience, and delivering the context an agent actually needs.

Dementor 🇮🇱🇺🇸's profile picture
Dementor 🇮🇱🇺🇸1 month ago

What's the name of this and is it open source?

Emma Rodriguez's profile picture
Emma Rodriguez1 month ago

This is the direction AI memory should move toward. The goal isn’t storing everything, it’s extracting useful knowledge and delivering the right context at the right time.

ALEXYZ's profile picture
ALEXYZ1 month ago

Clever shift from logs to usable knowledge.

Camaleón Raro's profile picture
Camaleón Raro1 month ago

plug-in memory modules that prune static context before token injection cut inference overhead dramatically in multi-agent swarms. we benchmarked external vector caching vs embedded state pruning; dropping raw message history in favor of distilled state vectors saved ~65% latency on deep agent loops. are you testing external memory modules with dynamic graph retrieval or flat semantic search?

Guy Hachmon's profile picture
Guy Hachmon1 month ago

That's the next level in the evolution of the LLM-wiki

Vermis🔳's profile picture
Vermis🔳1 month ago

It would be nice as well if its editable by us users, something like CRUD

Carolyn's profile picture
Carolyn1 month ago

Does this process introduce bias?

Ankur Misra's profile picture
Ankur Misra1 month ago

The useful half isn’t “Microsoft memory plug-in.” It’s: agents don’t need the transcript — they need distilled facts and reusable skills, then only the slice that changes the next decision. More context was never the moat. Better memory on metal you own is.

Gipp 🦅's profile picture
Gipp 🦅1 month ago

reusable skills beat raw logs for agent memory

Özgür AYDIN's profile picture
Özgür AYDIN1 month ago

Neden değişmemiş? Madem yapıyor bu bilgiyi bulutta tutsun her bağlantıda kullansın?

Origin's profile picture
Origin1 month ago

my agent remembers every dumb thing ive ever asked it and none of the useful information this would genuinely make my life easier

Related Videos

Everyone wants agent swarms. Very few people are talking seriously enough about the context layer that makes swarms useful. Even with one agent, context is fragile. Too little context and the agent guesses. Too much context and it wastes tokens, loses focus, or reasons over irrelevant noise. The sweet spot is precise context: the right knowledge, in the right structure, at the right moment. With many agents, that challenge explodes. Each agent produces decisions, assumptions, findings, summaries, risks, and partial conclusions. Unless that knowledge becomes shared, structured, and reusable, every new agent is forced to rediscover what another agent already learned. That is not a swarm. That is a crowd. Shared context graphs are what turn agent activity into agent collaboration, and OriginTrail DKG V10 brings them to life. Was just playing with some final polishing for the V10 release, and it is really powerful to see shared context graphs where multiple agents contribute knowledge into the same connected memory, with attribution visible directly in the graph ui. That matters for three reasons. First, agents can access and build on one shared memory instead of staying trapped in isolated sessions. Second, the graph structure helps them retrieve the exact context they need, instead of stuffing everything into a prompt and hoping the model sorts it out. Third, verifiability of provenance. You can see which agent contributed each piece of knowledge, trace the source, and decide what to trust. Tokenmaxxing starts with fewer tokens, but the deeper story is coordination - agents stop reloading the world and start building on shared, verifiable context. That is the foundation for serious multi-agent work across software engineering, research, finance, operations, project management, and far beyond. The future is not more agents, it is agents working from shared, verifiable context. But the more the merrier, of course.

Jurij Skornik

11,180 views • 3 months ago

New short course: Long-Term Agentic Memory with LangGraph. Learn to build an agent with long-term memory in this course developed in collaboration with taught by its Co-Founder and CEO, Harrison Chase! Personal assistance and productivity tasks have become important use cases for agents. An important feature of an AI assistant, such as a coding or calendar assistant, is its ability to keep improving over time from its experience. Agent memory is the key capability that enables this. To add memory to an agent, you must first figure out what to store and what to retrieve when it is time to use the information. Additionally, you’ll have to decide when to update the stored information. For example, you might update in each iteration loop of the agent or perform updates in the background, with a helper agent. In this course, you will learn a mental framework to build agents with long-term memory. You'll create a useful email assistant that can respond, ignore, and notify using writing, scheduling, and memory-management tools. You’ll develop your agent's memory by adding facts to its memory store, provide examples to learn the user's preferences, and optimize system prompts to evolve instructions based on previous responses. In detail, you’ll: - Learn how the three types of memory--semantic, episodic, and procedural–and the two update mechanisms–via hot path and in the background–apply to your agents. - Build an email agent with writing, scheduling, and availability tools, along with a router that triages incoming email and handles it accordingly by ignoring, responding, or notifying the user. - Add tools to your email agent that allow it to operate on semantic memory by learning facts about the user, storing them in a long-term memory store, and searching over them in future interactions. - Incorporate episodic memory, in the form of few-shot examples, in the triage step of your agents to help them learn and update user preferences. - Add procedural memory as system prompts, optimized with feedback to improve the instructions the agent follows. Learn how to approach memory in agents, and start building agents with long-term memory with LangGraph! Please sign up here:

Andrew Ng

132,058 views • 1 year ago

HERMES AGENT LEARNS FROM ITS OWN MISTAKES. UPDATES ITS MEMORY. CREATES ITS OWN SKILLS. NO CLOUD. EVERYTHING STORED LOCALLY. THIS IS HOW THE SELF-IMPROVING LOOP WORKS. most agents start from zero every session. Hermes carries forward what it learned. THREE MEMORY SYSTEMS: 1. PROCEDURAL MEMORY (how to act) stored in ~/.hermes/skills/ as SKILL.md files. when the agent repeats a complex workflow, it saves the procedure as a reusable skill. next time the same task comes up, it follows the skill instead of figuring it out again. you can also create skills explicitly: "create a skill called video-prep that captures how I format my video scripts. spoken english, define jargon inline, no em-dashes, close with a catchphrase." the agent writes the SKILL.md. available as a slash command from that moment. Hermes ships with 90+ skills. the number grows the longer you use it. 2. SEMANTIC MEMORY (durable facts about you) stored in ~/.hermes/memory/memory.md the agent scans conversations for facts worth remembering. preferences, habits, corrections, project details. real example from the video: agent tried to scrape a YouTube channel. URL was wrong. it failed. it updated memory.md with the correct URL pattern so it never makes the same mistake again. you can also save explicitly: "save to memory that my favorite testing framework is pytest" the agent updates memory.md immediately. this file loads into context on every session. the agent knows you better every week. 3. EPISODIC MEMORY (chat history) stored in ~/.hermes/state.db (local SQLite). every conversation. every tool call. every result. searchable with FTS5 full-text search. "search our past sessions. what was the first thing I ever said to you?" the agent queries state.db and finds it. over time, auxiliary models consolidate episodic memory into semantic memory. distilling recurring patterns into durable facts. THE SELF-IMPROVING LOOP: every agent run follows this cycle: → you send a prompt → working memory loads: SOUL.md + memory.md + relevant skills + chat history → agent calls tools (terminal, browser, delegate_task) → agent completes the task, replies to you → AFTER the reply: agent checks "did I learn something worth saving?" → if yes: updates memory.md or creates a new skill → next session starts smarter than the last this happens automatically. you don't ask the agent to learn. it decides what to remember on its own. WHAT MAKES THIS DIFFERENT FROM CLAUDE CODE: Claude Code has memory too. but Hermes stores everything locally. no cloud. your data never leaves your machine. Claude Code doesn't auto-create skills from experience. Hermes turns repeated workflows into reusable procedures. Claude Code memory is instruction-based. Hermes memory is conversational and self-updating. over months of usage, Hermes builds a knowledge base of your preferences, your projects, your mistakes, and the procedures that work for your specific workflow. the agent that remembers your birthday also remembers why your last deploy failed. NO EMBEDDINGS. PLAIN TEXT. Hermes does not use embeddings or RAG for memory. skill and memory search runs on plain text keyword matching. simpler. faster. no vector database to maintain. works entirely offline on your local machine. DELEGATE TO CLAUDE CODE: Hermes can spawn a sub-agent that runs Claude Code in headless mode: "spawn a sub-agent using Claude CLI to build a Python script that fetches the top 5 Hacker News stories to markdown." Hermes delegates. Claude Code writes the code. result returns to Hermes. Hermes runs the script and delivers the output. use Hermes for orchestration. use Claude Code for heavy coding. both tools. not competitors. WHAT HERMES DOES NOT HAVE: no built-in eval or LMOps system. no LangSmith, no LangFuse integration out of the box. trajectory export and logs exist but there is no automated quality tracking. if you need eval, build it yourself or connect external tools. the loop is self-improving. measuring how well it improves is on you. comment LOOP and I'll send you the configs that control how fast Hermes learns and what it remembers. memory limits, skill auto-creation triggers, and the auxiliary model that runs the learning. Replace your entire team with 8 hermes agents👇

YanXbt

22,720 views • 2 months ago