Advancements in Robotic Memory Systems

The biggest limitation in today’s AI agents is not their fluency. It is memory. Most LLM-based systems forget what happened in the last session, cannot improve over time, and fail to reason across multiple steps. This makes them unreliable in real workflows. They respond well in the moment but do not build lasting context, retain task history, or learn from repeated use. A recent paper, “Rethinking Memory in AI,” introduces four categories of memory, each tied to specific operations AI agents need to perform reliably: 𝗟𝗼𝗻𝗴-𝘁𝗲𝗿𝗺 𝗺𝗲𝗺𝗼𝗿𝘆 focuses on building persistent knowledge. This includes consolidation of recent interactions into summaries, indexing for efficient access, updating older content when facts change, and forgetting irrelevant or outdated data. These operations allow agents to evolve with users, retain institutional knowledge, and maintain coherence across long timelines. 𝗟𝗼𝗻𝗴-𝗰𝗼𝗻𝘁𝗲𝘅𝘁 𝗺𝗲𝗺𝗼𝗿𝘆 refers to techniques that help models manage large context windows during inference. These include pruning attention key-value caches, selecting which past tokens to retain, and compressing history so that models can focus on what matters. These strategies are essential for agents handling extended documents or multi-turn dialogues. 𝗣𝗮𝗿𝗮𝗺𝗲𝘁𝗿𝗶𝗰 𝗺𝗼𝗱𝗶𝗳𝗶𝗰𝗮𝘁𝗶𝗼𝗻 addresses how knowledge inside a model’s weights can be edited, updated, or removed. This includes fine-grained editing methods, adapter tuning, meta-learning, and unlearning. In continual learning, agents must integrate new knowledge without forgetting old capabilities. These capabilities allow models to adapt quickly without full retraining or versioning. 𝗠𝘂𝗹𝘁𝗶-𝘀𝗼𝘂𝗿𝗰𝗲 𝗺𝗲𝗺𝗼𝗿𝘆 focuses on how agents coordinate knowledge across formats and systems. It includes reasoning over multiple documents, merging structured and unstructured data, and aligning information across modalities like text and images. This is especially relevant in enterprise settings, where context is fragmented across tools and sources. Looking ahead, the future of memory in AI will focus on: • 𝗦𝗽𝗮𝘁𝗶𝗼-𝘁𝗲𝗺𝗽𝗼𝗿𝗮𝗹 𝗺𝗲𝗺𝗼𝗿𝘆: Agents will track when and where information was learned to reason more accurately and manage relevance over time. • 𝗨𝗻𝗶𝗳𝗶𝗲𝗱 𝗺𝗲𝗺𝗼𝗿𝘆: Parametric (in-model) and non-parametric (external) memory will be integrated, allowing agents to fluidly switch between what they “know” and what they retrieve. • 𝗟𝗶𝗳𝗲𝗹𝗼𝗻𝗴 𝗹𝗲𝗮𝗿𝗻𝗶𝗻𝗴: Agents will be expected to learn continuously from interaction without retraining, while avoiding catastrophic forgetting. • 𝗠𝘂𝗹𝘁𝗶-𝗮𝗴𝗲𝗻𝘁 𝗺𝗲𝗺𝗼𝗿𝘆: In environments with multiple agents, memory will need to be sharable, consistent, and dynamically synchronized across agents. Memory is not just infrastructure. It defines how your agents reason, adapt, and persist!

Memory is key to effective AI agents, but it's hard to get right. Google presents memory-aware test-time scaling for improving self-evolving agents. It outperforms other memory mechanisms by leveraging structured and adaptable memory. Technical highlights: TL;DR: A memory framework that turns an agent’s own successes and failures into reusable reasoning strategies, then pairs that memory with test-time scaling to compound gains over time. What it is: ReasoningBank distills structured, transferable memory items from past trajectories using an LLM-as-judge to self-label success or failure. Each item has a title, description, and content with strategy-level hints. At inference, the agent retrieves top-k relevant items and injects them into the system prompt, then appends new items after each task. Why it matters: Unlike storing raw traces or only successful routines, ReasoningBank explicitly learns from failures. Adding failed trajectories improves SR vs. success-only memories, while prior memories stagnate or degrade. This yields more robust, generalizable guidance across tasks. Memory-aware test-time scaling (MaTTS): Parallel self-contrast across multiple rollouts and sequential self-refinement within a rollout produce richer contrastive signals for better memory. On WebArena-Shopping, success rate rises with scaling factor k, e.g., parallel MaTTS goes from 49.7 at k=1 to 55.1 at k=5, outperforming vanilla TTS at the same k (52.4). Stronger memory makes scaling more effective, and scaling curates stronger memory. Efficiency: Efficiency is important for memory mechanisms to be feasible in the real world. Results show step reductions are larger on successful cases, suggesting the agent finds solutions with less redundant exploration. Why this fits the current TTS wave: ReasoningBank plugs directly into test-time scaling practices and shows that memory quality is a multiplier on TTS benefits. It complements methods like s1’s budgeted thinking by turning extra compute into durable, strategy-level memory that compounds across tasks.

I’m noticing some really big shifts in how AI models handle memory. Hermes Agent got a lot of attention for its multi-layered memory and for storing how a task is done, not just what to do. And now there’s a new paper saying the same thing: it really matters to store the whole problem-solving journey. East China Normal University and others introduced Memory Intelligence Agent (MIA) framework that turns memory into something closer to experience. MIA separates the system into 3 parts: - one that stores past experiences (Manager) - one that plans how to solve a task (Planner) - and one that executes the plan (Executor) These 3 pieces evolve together and at a high level, MIA is built around a loop: retrieve memory → plan → execute → store experience → improve: 1. When a new question comes in, the system searches its memory for similar past cases, prioritizing proven successes. It also samples rarer ones to avoid being too narrow. It keeps both successful and failed examples. 2. Then the Planner takes the question and retrieved experiences and creates a step-by-step plan (like a chain-of-thought, but structured as a strategy). It keeps improving during use, while solving tasks through reinforcement learning. 3. Finally, the Executor follows this plan, interacting with tools (like search), collecting information, and trying to solve the task. This happens in a ReAct-style loop: think → act → observe → repeat. Importantly, there’s a feedback loop. After execution, the Executor reports back. If something fails or stalls, the Planner reflects, updates the plan, and tries again, only when needed. Another important part of MIA is compression of the experience: long trajectories become structured summaries of workflows, images become captions, and redundant memory is replaced or merged. And it turns out that MIA uses 2 types of memory at the same time: - Non-parametric memory → explicit storage (retrieved examples, workflows) - Parametric memory → knowledge inside the model (learned weights) Results clearly show the advantages of MIA's workflow: • It becomes new SOTA among memory agents: +5.5 avg gain, ~53.6 accuracy • Achieves up to +9.1 on complex tasks like multi-hop/in-house reasoning • Small 7B model matches / beats larger closed models • MIA is also strong on multimodal & text tasks and improves further via test-time learning Yes, this line of research definitely needs to continue, because the question of memory efficiency in agents is only just beginning to mature.

𝗪𝗵𝘆 𝗔𝗜 𝗔𝗴𝗲𝗻𝘁𝘀 𝗪𝗶𝘁𝗵𝗼𝘂𝘁 𝗠𝗲𝗺𝗼𝗿𝘆 𝗔𝗿𝗲 𝗝𝘂𝘀𝘁 𝗖𝗵𝗮𝘁𝗯𝗼𝘁𝘀! A groundbreaking survey just dropped from researchers at National University of Singapore, University of Oxford, Peking University, and Fudan University that fundamentally reframes how we should think about agentic AI systems. The paper 'Memory in the Age of AI Agents' (arXiv:2512.13564) introduces a new taxonomy that moves beyond the outdated 'short-term vs long-term' classifications. Instead, it proposes understanding agent memory through three critical lenses:- 𝗙𝗼𝗿𝗺𝘀 – How memory is implemented:- Token-level memory (context windows). Parametric memory (model weights). Latent memory (hidden representations). 𝗙𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝘀 – What memory does:- Factual memory (knowledge from interactions) Experiential memory (learned problem-solving) Working memory (task-specific workspace) 𝗗𝘆𝗻𝗮𝗺𝗶𝗰𝘀 – How memory evolves:- Formation, retrieval, and adaptation over time! Here's what caught my attention as someone building agentic solutions:- The difference between an LLM and an agent isn't just reasoning or tool use, it's the ability to LEARN and ADAPT through memory. Without sophisticated memory systems, agents remain 'forgetful' and ephemeral, unable to deliver on the promise of continual evolution that AGI demands. The survey highlights emerging frontiers that every builder should watch:- → Automation-oriented memory design → Deep integration with reinforcement learning → Multimodal memory architectures → Shared memory for multi-agent systems → Trustworthiness and governance concerns. For those of us working on AI governance and responsible deployment, that last point is critical. As agents gain memory, the stakes around what they remember, how long they retain it, and who controls that memory become paramount. The conceptual fragmentation in this space has been real. This survey provides the unified framework we've needed to move from ad-hoc implementations to principled design. If you're building production agentic systems, this is essential reading. 📄 Full paper: https://lnkd.in/eZbWSDny 💻 GitHub resource list: https://lnkd.in/e7kYKFDp What's your biggest challenge with agent memory in production? I'm particularly interested in hearing from teams moving beyond POCs to scaled deployments. #AgenticAI #AIGovernance #MachineLearning #AIResearch #Innovation #ArtificialIntelligence

Why do RAG systems feel like they hit a ceiling? I've been diving into Leonie Monigatti's latest article on agent memory, and it provided so much clarity into the current evolution of RAG systems. The progression from RAG → Agentic RAG → Agent Memory isn't about adding features. It's about changing 𝗵𝗼𝘄 𝗶𝗻𝗳𝗼𝗿𝗺𝗮𝘁𝗶𝗼𝗻 𝗳𝗹𝗼𝘄𝘀. 𝗥𝗔𝗚: 𝗥𝗲𝗮𝗱-𝗢𝗻𝗹𝘆, 𝗢𝗻𝗲-𝗦𝗵𝗼𝘁 Traditional RAG is like a library where you can only check out books. You retrieve context, generate a response, done. The knowledge base is static - updated offline, queried online. Simple, but inflexible. 𝗔𝗴𝗲𝗻𝘁𝗶𝗰 𝗥𝗔𝗚: 𝗦𝗺𝗮𝗿𝘁 𝗥𝗲𝗮𝗱-𝗢𝗻𝗹𝘆 Agentic RAG adds intelligence to retrieval. The agent decides: • Do I even need external information? • Which knowledge source should I query? • Is this retrieved context actually relevant? Still read-only, but way more sophisticated about 𝘸𝘩𝘢𝘵 it reads. 𝗔𝗴𝗲𝗻𝘁 𝗠𝗲𝗺𝗼𝗿𝘆: 𝗥𝗲𝗮𝗱-𝗪𝗿𝗶𝘁𝗲 𝗢𝗽𝗲𝗿𝗮𝘁𝗶𝗼𝗻𝘀 Agent memory introduces write operations during inference. The agent can now: • Store new information from conversations • Update existing knowledge • Create memories from important events • Build personalized context over time Your AI assistant doesn't just retrieve your preferences - it 𝗹𝗲𝗮𝗿𝗻𝘀 them through interaction. It's not just searching a static knowledge base - it's actively building one. Leonie breaks this down with code examples showing how WriteTool extends the SearchTool paradigm. The agent gets tools for storing, updating, even consolidating memories. But (and this is important) - she's also super clear this is a simplified mental model. Real agent memory systems need sophisticated memory management: deciding what to remember, what to forget, how to handle memory corruption. It's messier than it looks 😅 The article also touches on different memory types - procedural ("use emojis"), episodic ("user mentioned trip on Oct 30"), semantic ("Eiffel Tower is 330m tall") - potentially stored in separate collections. I love this framing because it shows how each evolution solved specific limitations. RAG was too rigid. Agentic RAG made retrieval smarter. Agent memory made the whole system adaptive. Full article here: https://lnkd.in/eFBuDqYP

AI agents are forgetting what they shouldn't - and it's a design flaw, not a capacity problem. Most AI agent memory systems today follow an "Ahead-of-Time" approach: they compress historical information into lightweight memory structures before requests arrive. This seems efficient, but there's a fundamental issue - compression always means information loss. Researchers from the Beijing Academy of AI propose General Agentic Memory (GAM), a system that flips this paradigm using "Just-in-Time compilation." Instead of compressing everything upfront, GAM maintains complete historical information in a page-store while creating a lightweight navigational memory. When a request comes in, it performs "deep research" - iteratively planning, searching, and reflecting across the full history to retrieve exactly what's needed. The architecture consists of two modules: a Memorizer that indexes history with searchable abstracts, and a Researcher that conducts multi-step information gathering at runtime. This design leverages the agentic capabilities of frontier LLMs and benefits from test-time scaling—more compute at inference leads to better results. GAM demonstrates substantial improvements across memory benchmarks like LoCoMo and long-context tasks like HotpotQA, with accuracy gains of 6+ percentage points from the architecture itself. On top of that, the framework is optimizable end-to-end through reinforcement learning, allowing it to improve with deployment experience. The takeaway? GAM shows us that search might be a critical component of agent memory systems. ↓ 𝐖𝐚𝐧𝐭 𝐭𝐨 𝐤𝐞𝐞𝐩 𝐮𝐩? Join my newsletter with 50k+ readers and be the first to learn about the latest AI research: llmwatch.com 💡

Google Research just released "Nested Learning: The Illusion of Deep Learning Architectures" (https://lnkd.in/d8YRWk5F), addressing a fundamental limitation of current AI systems: they're frozen after training, unable to learn continuously. The core insight reframes neural networks not as stacks of layers, but as hierarchies of nested optimization problems—each layer solving an optimization task defined by the layer above it. This multilevel optimization perspective shares deep parallels with recent theoretical work viewing biological evolution itself as multilevel learning (https://lnkd.in/d-prdpMs), suggesting these hierarchical principles with nested timescales may be fundamental to any complex adaptive system. Technical contributions: Building on their earlier Titans architecture (which introduced neural long-term memory with surprise-based prioritization, https://lnkd.in/dGUt6VXC), the team developed HOPE—a self-modifying variant that extends Titans in three critical ways: * Deep Optimizers: By reframing optimizers as associative memory modules and replacing dot-product similarity with L2 regression objectives, the optimizer itself becomes a learnable neural network with richer, context-aware update rules * Continuum Memory System (CMS): Multi-frequency memory operating at different timescales, from fast synaptic changes to slow structural adaptations—echoing the historical ideas about multi-timescale brain processing (https://lnkd.in/dyQUcvP6) that inspired recent bio-inspired architectures like HRM (https://lnkd.in/eEMxYUcy). * Self-referential optimization: HOPE can modify its own learning rules, supporting unbounded levels of in-context learning rather than Titans' two-level parameter updates HOPE achieves state-of-the-art performance, demonstrating genuine continual learning capabilities while outperforming Titans, Samba, and standard (optimized) Transformers. Why this matters strategically: Current LLMs suffer from "amnesia"—they can't update their knowledge without expensive retraining. Nested Learning offers a path toward systems that self-improve and adapt in real-time, potentially solving one of the biggest deployment challenges in production AI. The paper also raises interesting questions about the nature of learning itself: if each layer is an optimizer solving problems defined by higher layers, where does "learning" actually happen? The architecture blurs the line between optimization and learning in ways that parallel how biological systems operate. Full review: https://lnkd.in/dj4c9wv4 The paper is worth reading it more carefully. #AI #MachineLearning #DeepLearning #ContinualLearning #NeuralNetworks #AIResearch #AIArchitecture

Google's Titans architecture rewrites the rules for how AI systems store and process information over extended timeframes. The Titans framework introduces a neural memory module that departs from static transformer approaches by enabling AI systems to learn and update their memory during inference, a capability that mirrors biological memory consolidation more closely than previous architectures. This shift from purely training-time learning to continuous test-time adaptation represents a meaningful architectural evolution. Benchmarks demonstrate substantial performance gains, with Titans outperforming GPT-4 and Llama3 + RAG variants on long-context reasoning tasks, particularly in the BABILong benchmark designed to stress test extended reasoning chains. The architecture scales to contexts exceeding 2 million tokens without accuracy degradation, a threshold that positions it well beyond current mainstream model capabilities. Practical applications span diverse domains, from maintaining coherence across long contexts to preserving interaction history in customer service systems with measurable fidelity improvements. The MIRAS framework compounds these gains by enabling faster computation and more efficient memory utilization, reducing the computational overhead typically associated with extended context processing. The incorporation of a "surprise metric" that weights learning based on information novelty introduces a principled approach to memory prioritization, effectively filtering signal from noise in streaming data scenarios. This mechanism prevents information overflow while preserving model adaptability, addressing a core limitation in systems that treat all inputs uniformly. From the paper: Low surprise: If the new word is "cat" and the model's memory state already expects an animal word, the gradient (surprise) is low. It can safely skip memorizing the word "cat" in its permanent long-term state. High surprise: If the model's memory state is summarizing a serious financial report, and the new input is a picture of a banana peel (the unexpected event), the gradient (surprise) will be very high. This signals that the new input is important or anomalous, and it must be prioritized for permanent storage in the long-term memory module. #AGI #AI #LLM #Technology #Google #Gemini #AIMemory