The Future of AI Memory: Meet #AtomMem’s Learnable CRUD System

Key Takeaways

Hello and welcome back to the deep dive. We have a stack of research on the desk today that uh it really forces us to look in the mirror a little bit. >> Usually when we talk about artificial intelligence, we're obsessed with processing power, >> right? Or or speed. We talk about how many tokens per second a model can spit out. >> Right. The horsepower. >> Exactly. The horsepower. But today we are tackling something I think much more fundamental. something that every single one of us struggles with, but we rarely think about it as an engineering problem. We were talking about memory. >> It's the ghost in the machine, isn't it? I mean, memory is the fundamental building block of intelligence, whether you're biological or artificial, right? Without it, you're just processing the immediate moment over and over again. You have no continuity, no learning. >> Exactly. And to kick this off, I want to try a little experiment with you. Just picture your daily commute. Maybe you drive, maybe you take the train, you do this trip twice a day, 5 days a week. It's pure routine. >> Okay, got it. >> Now, if I asked you to describe every single car you passed, every billboard, every pothole, every single cloud formation from this morning's drive, >> yeah, >> could you do it? >> Uh, absolutely not. No chance. And frankly, if my brain even tried to retain all of that, I don't think I'd be able to function at work. I'd be paralyzed by the sheer volume of data, >> right? You'd just be completely overwhelmed. So, what do you do? You filter. You remember the detour sign because that affects your route. That's actionable information. >> You might remember the guy who cut you off because that emotional spike, that little bit of anger, helps lock in the memory. >> But the rest of it, >> it's noise. Total noise. You just discard it to focus on the mission, which is getting home. >> You got it. And that filtering process, that act of deciding what matters and what doesn't is actually highly sophisticated decision-making process. It's what we call cognitive resource management. You're constantly, you know, making these little micro decisions about what to store and what to ignore. >> But here is the kicker, and this is where we get right into today's topic. Up until very recently, that is not how our smartest AI models handled memory. >> Not at all. >> Not even close. If you gave an AI a book to read, it wasn't filtering. It was essentially trying to memorize every pothole, every car, every cloud in the sky. >> That is a great analogy. In the industry, we call this the context window limitation or, you know, the problem of rigid static memory systems. Traditional agents really, really struggle with what we call long horizon tasks. >> And long horizon just means tasks that take a long time and involve a ton of data. Right. >> Time and volume. Yes. Exactly. Imagine asking an AI to read a novel and then answer a question about a character's motivation back in chapter 1, but based on something they did in chapter 20, okay? >> Or asking it to analyze a month's worth of financial reports to find one subtle market trend. The AI gets completely overwhelmed because its memory system is static. It follows a a manual hard-coded rulebook that was written by an engineer. >> So, it's like trying to get home from work, but you're forced to memorize every single license plate you see. >> Every single one. Yeah. because a rule book says memorize all numbers >> and that leads to a crash metaphorically, you know, in terms of getting the answer wrong because the important info got pushed out by the useless info and sometimes literally in terms of system performance. The computational cost just explodes. >> Wow. >> But that brings us to the paper we are diving into today. It's titled atom learnable dynamic agentic memory with atomic memory operations. Atom. It sounds a bit like a comic book superhero from the atomic age. Here comes Atom M to save the database. >> He's here to save the day. >> But the atom part is actually a technical term here, isn't it? >> It is. Yeah. It refers to atomic operations. >> Yeah. >> The authors are proposing a pretty radical shift here. They want to stop treating memory as just a storage bin. Like a passive bucket where you just dump data and start treating it as a set of fundamental actions. building blocks >> and the dynamic part of the title. I'm guessing that's the key. >> That's the key. That refers to the fact that the system isn't following a rigid script. It uses reinforcement learning or RL to teach the AI how and when to use those building blocks. >> So instead of a hard-coded rule book that says memorize everything, the AI actually learns its own strategy. >> Precisely. The mission here really is to explore how treating memory as a decision-making process allows an AI to outperform humans and other models in these really complex reasoning tasks. It's about moving from the mindset of I store everything to I decide what is worth keeping. >> I love that framing. It's almost like uh Marie Condo for AI. Does this piece of data spark joy? Does it help solve the puzzle? No. Thank you. Next. Delete it. >> In a way, yes. It's all about optimal resource management. You just don't have infinite space. So you have to be picky. >> Okay, before we get into the nuts and bolts of how ADMM actually works, because there's some really cool engineering here, let's unpack the status quo a bit more. We need to understand why the current methods are failing so we can appreciate the solution. You mentioned static memory. What does that look like in practice for an AI agent today? >> So typically we see two main approaches in the field. The first is what we call imitationbased. Basically we try to mimic how we think human memory works or maybe how computer file systems are structured. Okay. >> The second is prior based, which is just a fancy way of saying engineers sat down and wrote a very specific workflow. >> Workflow like uh if you see text, summarize it immediately. >> Exactly that. Read a chunk of text, summarize it. Put the summary in a buffer. Oh, and if the summary buffer is full, delete the oldest sentence. >> That feels incredibly clunky. Just so rigid. >> It is clunky. And this oneizefits-all approach fails because it doesn't adapt to the content. The paper highlights two big failures here. One is something called continuous memory fusion. >> Continuous memory fusion. That sounds like a sci-fi reactor leak. >> It's almost as messy. This is where the AI just keeps mashing new information into its old summaries. Imagine you have a ball of Play-Doh. You've got a red piece of facts, a blue piece of facts, and a yellow piece. All distinct, clear information. But if the rule says combine everything, you just keep smashing them together. And eventually you don't have distinct colors anymore. You just have a brown sludge. >> You lose all the detail. It just becomes a blur. So if I ask, "What was that red fact from earlier?" The AI says, "Uh, I don't know, but everything's kind of brownish now." >> Exactly. The compression completely destroys the fidelity. And the other failure they identify is rigid forgetting schedules. This one's even worse. Imagine a librarian who is forced by a very strict rule to throw away a book every single Tuesday. >> Even if it's a first edition Great Gatsby, >> doesn't matter. Even if it's the most important book in the entire library, if the rule says first in, first out, or delete after 24 hours and the buffer is full, that information is gone. Poof. >> Wow. >> It doesn't matter if it's a crucial clue for a mystery you're trying to solve or just an expired coupon. [snorts] The system can't understand the value of the information. It only understands the cue. That is a terrifying thought if we're trusting these things with like medical records or legal analysis. Sorry, I deleted the patient's critical allergy info because it was Tuesday and my buffer was full. >> It's a huge problem. So, this is how AdamM flips the script. >> How does it do it? >> They reframe the entire problem. They stop looking at memory as just a storage issue and start viewing it as a partially observable Markoff decision process or POMDP. >> Okay, hold on. partially observable Markov decision process. [sighs] That is a mouthful. We have to translate that for everyone listening before we move on. >> Fair enough. Fair enough. Think of it like a strategy game. Imagine you're playing a really complex RPG or maybe a board game like Battleship or Civilization. Got it. >> You can't see the whole map. That's the partially observable part. You don't know what's coming next in the book or the data stream. It's hidden from you. >> So, I'm basically operating in a fog of war. I only know what I've seen so far. >> Right? And you have to make moves based on what you can see right now and what you remember from previous turns. Attome treats memory management as that game. The AI isn't just following a checklist anymore. It's playing a game where the goal is to solve a puzzle. >> And the moves in this game aren't attack or defend. >> No, the moves are remember this, update that, or forget this. It learns a policy, a strategy to maximize its score. >> And the score is just getting the right answer at the very end. >> Yes. And this is what really distinguishes it from previous attempts. The paper mentions the specific trap that earlier models fell into. They were content optimized but workflow constrained. >> That sounds like a corporate buzzword nightmare. Workflow constrained. What does that mean in plain English? >> It's like a manager who lets you choose your own font for a report but forces you to write a report every single hour whether you have news or not. Oh, >> some previous models like one called me agent, they allowed the AI to choose what to write in its memory and that was a step forward for sure. But the workflow forced them to write something at every single step. >> So even if the text was just, you know, the quick brown fox jumps over the lazy dog, it had nothing to do with the mission. The AI had to process it. It had to do something. >> It had to perform an update. It had to burn energy and use up storage space. It's incredibly inefficient and it just clutters the memory with noise. Yeah. >> Atom removes that mandatory aspect. It gives the AI the power of silence. The power to do nothing. >> The power to do nothing. >> That's surprisingly powerful, isn't it? For an agent that's processing thousands of documents, being able to just say, "This is irrelevant. I'm skipping it." Must save a ton of processing power. >> It's a complete gamecher for efficiency. It allows the agent to essentially fast forward through the boring parts of the data. >> Okay, let's get into the nuts and bolts then. The atoms in Atomam. The paper borrows a concept from database engineering called C R E O C R U D. >> Mhm. >> I remember this from my very brief, very failed attempt at learning SQL. >> Ah, >> create, read, update, delete. >> That's it. Those are the four fundamental operations. The atomic building blocks of memory. >> Let's break them down as they apply to this AI. Create seems straightforward enough, >> right? Create is simply adding a new entry to the vector database. The agent sees something important. It decides it's important, writes it down, and files it away. It's the equivalent of taking a fresh index card and writing a new fact on it. >> And read, is that just as simple? >> Read is retrieving information. But here's the nuance. The agent has to choose to read. It's an active process. It has to formulate a query. It thinks to itself, hm, I need to know Dracula's birthday. So, it sends a read command to its own memory to go and fetch that specific piece of data. >> It's active, not passive. It's not just having the info pop up in its head. It's choosing to walk over the filing cabinet and open a specific drawer. >> You got it. >> Now, update. This seems like a big one, especially given what you said about that brown sludge problem earlier. >> Update is absolutely critical. This is modifying an existing entry. This is where the AI corrects itself or adds nuance. If it previously thought the car is red and then later it reads the car is actually a dark maroon, it doesn't create a second conflicting note. It updates the original note. >> Ah, so that prevents duplicates and contradictions from piling up. And finally, delete. >> Taking out the trash, just removing the clutter. If information is contradicted or becomes irrelevant or it's just duplicative, the agent can wipe it to keep its search space clean. So we have these four tools, >> but where is all this actually happening? What does the brain of this system even look like? >> So the architecture has three main parts. First, you have the vector database. That's the long-term storage, right? The filing cabinet in the basement where you can store thousands of files. >> Okay, deep storage. >> Then you have the input stream, which is just the document being read. And it's broken into manageable chunks, usually about 4,000 tokens at a time. >> And the third part, the paper talks about a scratch pad. That sounds important. Yes, the scratchpad. This is my favorite part of the whole design. It's a special always visible memory block. Think of it this way. If the vector database is the library basement, the scratch pad is the sticky note you put right on your computer monitor. >> Ah, so it's the stuff you need to remember right now. >> Exactly. It holds the global task state or what you could call the mission statement. The paper really emphasizes that while the atomic operations, create, read, all that stuff are optional, the scratch pad is mandatory. It's always there. >> Why is it mandator? >> It prevents the AI from getting lost in the weeds. >> It's the anchor. It's the note that says, "Remember you were looking for the killer, not reading recipes you find along the way." >> Right? At every single step, the AI looks at the new chunk of text coming in. It looks at its scratch pad, and then it decides, okay, based on my mission, do I need to create a new memory? Do I need to update an old one? Should I delete something? Or maybe I need to read to check a fact. >> And crucially, as we said, it has that fifth option. None of the above. >> Yes. If the input is just noise, it does nothing. It preserves its energy and it keeps its memory absolutely pristine. >> So, we have a robot that's equipped with CRUD tools and a sticky note. >> Mhm. >> But how do we actually teach it to use them? You can't just hand it a hammer and expect them to build a house. You have to train them. And the training process for Adam is fascinating because it sort of mimics human education in a way. It's a two-phase process. >> Phase one is like primary school, right? Just learning the absolute basics. >> Exactly. They call it SFT or supervised fine-tuning. For this, they used a model called Deepseek V33.1 to generate a bunch of training data. And in this phase, they are just teaching the model the grammar of the memory commands. >> Like this is how you write an XML tag if you want to ask for a memory update. >> Correct. They teach it the format. If you want to save this fact, you have to wrap it in these create memory tags. It's just rote learning. It ensures the model knows how to swing the hammer, but it doesn't know how to build the house yet. >> So, it knows what the buttons do, but has no strategy. That comes in phase two. >> Phase two is the university level. This is where reinforcement learning or RL comes in. Specifically, they use an algorithm called GRPO, which stands for group relative policy optimization. Okay, don't lose us in the acronym soup here. >> How does the reinforcement learning teach its strategy? >> It's all about the reward system. And this is where the paper gets really, really clever. They don't give the model a cookie for storing data. They don't give it a reward for having a nice full database. >> No participation trophies, >> none. Zero. The model only gets a reward if it answers the user's question correctly at the very end of the entire task. >> Wow. So, it can do whatever it wants in the middle. It can write a thousand notes. It can write zero notes. But if it gets that final answer wrong, it gets nothing. >> Exactly. And this forces the model to figure out the most efficient memory strategy all on its own. It has to connect the dots. It has to learn, oh wait, when I wrote that note down back in step five, that actually helped me answer the question correctly in step 50. I should probably do that again. >> That's incredible. >> It effectively works backwards from the success to figure out which memory operations actually contributed to the win. It's learning cause and effect over a really long horizon. And the paper mentions some emergent behavior that came out of this. They tracked the graphs of what operations the model used during training. And it's pretty wild. What did they see? >> This is figure three in the source and it tells a wonderful story about learning. In the early stages of training, the model exhibits what I call panic reading. >> Panic reading. I think I did that in college before every single exam. >> We all did. The usage of the read operation is through the roof. It's constantly querying the database. It's insecure. It's like a student who didn't study and is just checking the textbook every 5 seconds. It doesn't trust what it knows. So, it keeps running back to the library. >> Is the answer A? Is it B? Let me check again and again. >> But as training progresses, you see this dramatic crossover in the graph. The read usage plummets and then stabilizes at a very low level. And at the same time, the create, update, and delete operations all go up. So it stops constantly checking the library and starts taking better notes for itself. >> Precisely. It shifts from being searchheavy to being maintenanceheavy. It learns that if it keeps a clean, organized house by creating good notes, updating them when facts change, and deleting the junk, it doesn't need to run to the library when the question finally comes. It already has the answer in its working memory. >> That is essentially the definition of becoming an expert at something. You don't have to look everything up anymore. You've synthesized it. You just know. It creates a task aligned policy. It learns to treat memory as a garden that needs constant weeding and pruning, not just a dumping ground for data. >> I want to see this in action. The paper has this one case study that really clarified the whole thing for me. It involves two movies, Dracula and a film called Blind Shaft. >> Yes, that's figure five in the paper. It's a great concrete example of this logic in action. The user asks a very specific question. Which film came first, Dracula or Blind Shaft? >> Okay, simple comparison question. All it needs are two dates. How does ETAM go about handling it? >> Well, the documents are fed to it in chunks. So, step one, the agent sees some documents about a British director named Peter Kazminsky. >> And does Peter Kuzinsky have anything to do with Dracula or Blind Shaft? >> Nope, nothing at all. He directed a movie called White Oleander. Totally irrelevant to the question at hand. So the old school static memory model would probably summarize this paragraph just because it's text, right? It would feel obligated, >> right? It might clutter the memory with a useless fact like Peter Cosminsky as a director. But Hasmaram, it looks at its scratch pad, sees the mission is about Dracula and Blind Shaft, and it writes in the scratch pad. No relevant info found. >> It doesn't put anything at all in the long-term vector database. >> Nothing. It keeps the long-term storage pristine. It exercise the power of doing nothing. Okay, step two. What's next? >> Step two, the agent sees a document about Dracula's daughter, which was released in 1936. >> Ah, close, but not quite the cigar. That's a sequel. >> Exactly. It's a hint, but not the answer. So, the agent performs a create memory action. It stores the hint about the franchise. But then, and this is the really cool part, it proactively triggers a readmemory action. It queries its own memory for Dracula release date. Wow. It knows what it doesn't know. >> Yeah. >> It sees Dracula's daughter and thinks, "Wait a minute. If there's a daughter, there must have been a father. Where is the original movie?" >> It's investigating. It's not just passively receiving data. It's actively hunting for the missing piece because its scratch pad says the main puzzle piece is still missing. >> Amazing. Okay. Step three. >> Step three. It finally finds the documents with the answers. Blind Shaft came out in 2003 and Dracula was released in 1932. Now it has the answer, but it doesn't just output the answer immediately. It performs an update memory action first. >> What does it update? What's left to update? >> It goes back to those partial notes, those hints it stored earlier about Dracula's daughter, and it overwrites them. It replaces all the working out with the final clean conclusion. Dracula came out before Blind Shaft. >> It cleans up after itself. It doesn't leave the rough draft in the final report. >> Exactly. Imagine if you were solving a math problem. You do a bunch of scribbling on the page, but once you have the final answer, you draw a nice box around it and maybe you erase the scribbles so the page is clean and readable. That is what Adam does with the update and delete functions. It presents a coherent final thought, not a messy stream of consciousness. >> That is so satisfying. It really highlights why that update function is so important. And speaking of importance, let's talk numbers. Section five of our dive covers the performance benchmarks. Did this thing actually work or is it just a cool theory? Oh, it worked. They tested it on major data sets like hot pot QA, two wiki, multihop, QA, and music. And they also did what's called a needle in a haststack test. >> Right. That's where you hide one tiny little fact, the needle in a massive pile of irrelevant documents, the haystack. >> Yes, they had these facts in sets of 200, 400, and even 800 documents. >> And the results, how did it do? >> Atame consistently outperformed the baselines. It beat Arag Retrieval augmented generation, which is the industry standard right now. And it beat the static agents like mem agent. But the most telling stat for me was the scalability. >> Scalability. What do you mean? >> As the number of documents increased, as the haststack got bigger, all the way up to 800 documents, the performance gap between ATOM and the other models got wider. >> So the harder the task got, the better ADM looked compared to the competition. >> Exactly. Because static agents just drown in noise. If you have 800 documents and your rule book forces you to summarize all of them, your memory becomes a useless swamp. Admin just ignored the 798 irrelevant documents and kept its focus on the two that actually mattered. It maintained high precision even when the data load was insane. >> Efficiency wins. Now, you mentioned earlier that update is king. The paper did an ablation study, which is basically where they break the model on purpose to see what parts matter most. Yes, it's a great way to figure out what's really driving performance. They turned off the atomic operations one by one to see what would happen. >> What happened when they turned off delete? >> Performance dropped a little bit, about 1.3%. So, cleaning up is good, but in the current text sizes, having a slightly messy room isn't fatal. >> Okay, but what happened when they turned off update? >> Performance plummeted. A 6.4% drop on hot pot QA. That is huge in AI benchmarks. a massive drop. >> Why? Why is update so much more important than delete? What's the logic there? >> Because memory isn't just about storage. It's about revision. Think about how you learn anything. You don't just stack new facts on top of old ones. You refine them. You think, "I used to believe X, but now I know it's actually why." Being able to say, "I was wrong. Here is the new better fact." is critical for intelligence. >> Yeah, that makes sense. Without update, the AI is just stuck with its first impression, which is often wrong or incomplete. >> That is a profound life lesson. Honestly, the ability to update your beliefs is more important than the ability to just delete old ones. >> Absolutely. It's the difference between being stubborn and being smart. If you can't update, you can't learn from your mistakes. >> They also tested the scratch pad versus the storage. >> And they found that they are symbiotic. They need each other. If you remove the scratch pad, performance drops significantly. The agent needs that short-term working memory to bridge the gaps between its atomic operations. It's the glue that holds the entire strategy together. >> So, you need the sticky note and the filing cabinet. You can't run an office with just one of them. >> You got it. >> Okay, let's zoom out a bit. We've covered the what and the how. Let's talk about the so what section six broader implications. What does a system like atomm signal for the future of AI? >> Well, the first big implication is efficiency. Despitem being, you know, conceptually complex, it has to make a decision at every single step. It's actually faster than some of the static baselines. >> How can it possibly be faster if it's doing more thinking? >> Because it acts less. By choosing to do nothing on all those irrelevant steps, it skips the expensive process of writing to memory or querying the database. It invokes the core LLM less frequently for memory tasks when the input is just noise. It works smarter, not harder. >> It's the lazy genius approach. Yeah, I like it. The second is generalization. They used a base model Quen 38B. The policy it learned this kind of memory manager personality. It worked across different data sets. It wasn't just good at hotpot QA, it was good at music, too. >> So, this memory management skill is transferable. It's like learning how to study. Once you figure out how to study history, you can probably apply those same skills to study biology. >> Exactly. It suggests that memory management is a distinct cognitive skill that can be taught to an AI and then transferred between models and tasks. >> And the third point, the shift in agency. >> This is the big one for me. We are moving from AI that just reads a script to an AI that manages its own cognitive resources. >> What do you mean by cognitive resources? >> Attention and memory capacity are resources. They're finite. Until now, humans decided how an AI used those resources. We wrote the rules. Read everything. Summarize everything. A tom is an agent that decides for itself when to pay attention. It decides what is worth remembering. It's taking ownership of its own learning process. >> That sounds almost human, or at least more alive than a simple script follower. >> It's a huge step towards autonomy. An agent that can manage its own memory is an agent that can operate for days, weeks, or even months without a human having to handhold it. It won't get clogged up with junk data. It can evolve its understanding of a topic over time using that crucial update function. >> It's moving from just being a chatbot to being a true digital assistant that can handle a long-term project. Yeah. >> Imagine an AI that tracks a project for 6 months. >> It doesn't need to remember every single email. >> No, >> just the decisions and the key changes. >> And it creates the summary report at the end, not by rereading 10,000 emails, but by just checking its own well-maintained scratchpad and vector database. >> It's incredible stuff. But as we start to wrap up, I have a question about the learning process itself. We talked about how the reward system works. It gets a reward only if it gets the final answer right. >> Yes, that's the core of it. >> Does that create a risk of of shortcuts? If an AI can decide what to remember and what to forget based purely on what gets me the reward, does it eventually develop a form of confirmation bias? >> Wow, that is a fascinating and very important technical question. >> I mean, think about it. If nuance or conflicting opinions confuse the model and make it more likely to miss the final answer, will it learn to just delete the counterarguments? Will it start to optimize for simple truth rather than complex truth because simple truth gets the cookie more reliably? >> You're asking if reinforcement learning ensures it remembers what is complete or just what is useful for the test. And you know, history tells us those two things aren't always the same thing, >> right? If the benchmark only rewards clear-cut black and white answers, the agent might learn to aggressively prune any ambiguity it finds. >> It becomes a yes man >> or a dogmatist. It might decide that strategy A always works. So, it learns to ignore any evidence for strategy B. It's a powerful reminder that when we design these reward functions, these mathematical goals, we are defining what the model considers success. If we wanted to handle ambiguity, we have to make sure the test requires handling ambiguity. It's all about the incentives we set. We're teaching them how to think. So, we have to be incredibly careful about what we define as a good thought. >> Absolutely. The system is only as good as the goal you give it. >> So, to recap, AdamM replaces the old rigid librarian throws a book away every Tuesday >> rules with a dynamic learned policy. It uses these atomic operations. Create, read, update, delete, manage a vector database, and a scratchpad. And it learns this whole strategy by getting a reward for solving the puzzle, not just for hoarding data. >> And in doing so, it proves that update is the most powerful tool in the box. And that sometimes doing nothing is the smartest move of all. >> I'm going to try to apply that to my own life. Next time I hear something totally irrelevant, I'm just going to run a delete operation immediately. >> Good luck with that. >> I'll need it. To our listeners, think about your own atomic operations. When you learn something new today, do you update your views? Do you delete the junk? or do you just read it and then forget it? >> That critical thinking is mostly about that update button. You know, don't be afraid to use it. >> Well said. Thanks for diving deep with us today. We will catch you on the next one. Goodbye everyone.