Video yükleniyor...

Video Yüklenemedi

Ana Sayfaya Dön

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 görüntüleme • 1 ay önce •via X (Twitter)

34 Yorum

subcan✡ profil fotoğrafı
subcan✡1 ay önce

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 profil fotoğrafı
JK1 ay önce

Seems a hell of a lot like Obsidian

Teneo Protocol profil fotoğrafı
Teneo Protocol1 ay önce

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

Matt profil fotoğrafı
Matt1 ay önce

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 profil fotoğrafı
Bob Dobolina1 ay önce

Fuck I was building this

Crypto Value Labs profil fotoğrafı
Crypto Value Labs1 ay önce

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 profil fotoğrafı
Damian Borowski1 ay önce

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 profil fotoğrafı
Scott Shapiro1 ay önce

@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 profil fotoğrafı
Vanar1 ay önce

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

Bass profil fotoğrafı
Bass1 ay önce

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 profil fotoğrafı
elle1 ay önce

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

Y11 profil fotoğrafı
Y111 ay önce

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

Laxmin Network profil fotoğrafı
Laxmin Network1 ay önce

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

AI Apps API profil fotoğrafı
AI Apps API1 ay önce

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. profil fotoğrafı
Miles S.1 ay önce

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

Vipul Kumar Kewat profil fotoğrafı
Vipul Kumar Kewat1 ay önce

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 profil fotoğrafı
Robert Ra1 ay önce

Where git?

ParthVarshney profil fotoğrafı
ParthVarshney1 ay önce

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

Swarup Das profil fotoğrafı
Swarup Das1 ay önce

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 profil fotoğrafı
Billy | AI Media Systems1 ay önce

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 profil fotoğrafı
neuralforge1 ay önce

Will the memory somehow be editable?

Luís Rodrigues profil fotoğrafı
Luís Rodrigues1 ay önce

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

Jordan Lee profil fotoğrafı
Jordan Lee1 ay önce

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 🇮🇱🇺🇸 profil fotoğrafı
Dementor 🇮🇱🇺🇸1 ay önce

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

Emma Rodriguez profil fotoğrafı
Emma Rodriguez1 ay önce

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 profil fotoğrafı
ALEXYZ1 ay önce

Clever shift from logs to usable knowledge.

Camaleón Raro profil fotoğrafı
Camaleón Raro1 ay önce

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 profil fotoğrafı
Guy Hachmon1 ay önce

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

Vermis🔳 profil fotoğrafı
Vermis🔳1 ay önce

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

Carolyn profil fotoğrafı
Carolyn1 ay önce

Does this process introduce bias?

Ankur Misra profil fotoğrafı
Ankur Misra1 ay önce

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 🦅 profil fotoğrafı
Gipp 🦅1 ay önce

reusable skills beat raw logs for agent memory

Özgür AYDIN profil fotoğrafı
Özgür AYDIN1 ay önce

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

Origin profil fotoğrafı
Origin1 ay önce

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

Benzer Videolar

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 görüntüleme • 3 ay önce

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 görüntüleme • 1 yıl önce

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 görüntüleme • 2 ay önce