Memory and dreaming for self learning agents

Memory and dreaming for self learning agents ![rw-book-cover](https://readwise-assets.s3.amazonaws.com/static/images/article4.6bc1851654a0.png) 🔗 **Source:** [Memory and dreaming for self learning agents](https://www.youtube.com/watch?v=IGo225tfF2I) > [!note]+ Document Notes > tags: [ai-agents, memory-systems, anthropic, self-improving-ai] > author: Ravi > source: YouTube > reference: https://www.youtube.com/watch?v=IGo225tfF2I > date created: {{date:YYYY-MM-DD}} {{time:HH:mm}} > > # 🏷️ Title: Memory and dreaming for self learning agents >  ## 🧭 Table of Contents - [📝 Summary](#-summary) - [📖 Main Content](#-main-content) - [🗒️ Notes](#️-notes) - [📚 References](#-references) - [🗣️ Paraphrase](#️-paraphrase) - [📰 Newsletter](#-newsletter) - [✅ Action Items](#-action-items) - [🧪 Hypotheses](#-hypotheses) - [📊 Methodology](#-methodology) - [❓ Questions](#-questions) - [🔮 Future Research](#-future-research) - [💡 Implications](#-implications) - [🧠 Learning Styles Assessment](#-learning-styles-assessment) - [📊 Accessibility Assessment](#-accessibility-assessment) - [🌍 DEIB Assessment](#-deib-assessment) - [✅ Logical Validity](#-logical-validity) - [🛡️ DARVO Analysis](#-darvo-analysis) - [🎯 Conclusion](#-conclusion) ## 📝 Summary - Anthropic released memory and dreaming capabilities for AI agents to learn and improve over time - Memory allows agents to carry forward learnings between tasks using a file system approach - Dreaming is an out-of-band process that optimizes and curates memory globally across agent sessions - Enterprise customers saw dramatic improvements: 97% decrease in errors, 6x increase in completion rates - The system supports multi-agent environments with version control, audit trails, and enterprise controls ## 📖 Main Content Anthropic has introduced two breakthrough features for AI agents: memory and dreaming. These capabilities address the fundamental challenge of context management in long-horizon tasks by enabling agents to learn from previous experiences and improve performance over time. **Memory Architecture**: Instead of starting each task from scratch, agents now maintain persistent memory across sessions. The system models memory as a file system, leveraging Claude's existing strengths in navigating virtual environments and using familiar tools like bash and git. This approach follows Anthropic's principle of "getting out of Claude's way" by using capabilities the model already possesses. **Multi-Agent Memory**: The system supports sophisticated memory hierarchies with different scopes. Agents can access organization-wide read-only memory (like company policies) while maintaining granular read-write memory stores for specific tasks. Optimistic concurrency control prevents conflicts when multiple agents access shared memory simultaneously. **Dreaming Process**: Dreaming represents a major innovation - an out-of-band feedback loop that analyzes patterns across agent sessions and automatically curates memory. Unlike in-task memory updates that can be locally optimal but globally suboptimal, dreaming provides holistic optimization by identifying recurring mistakes, inefficiencies, and successful patterns across multiple agents and sessions. **Enterprise Implementation**: The system includes version control, audit trails, attribution tracking, and a standalone API for memory management. This enables teams to integrate memory capabilities into existing production systems while maintaining enterprise-grade controls and observability. ### 🗒️ Notes #### ⏱️ [00:01:30](https://www.youtube.com/watch?v=IGo225tfF2I?t=90) Timeline of Anthropic agent milestones - 2024: Model Context Protocol (MCP) for external tools and data access - 2025: Cloud Code and agent SDK for lowering barriers - Skills release providing generic capability abstractions - Cloud managed agents platform for reliable operation #### ⏱️ [00:03:15](https://www.youtube.com/watch?v=IGo225tfF2I?t=195) The memory problem - Agent task complexity doubling every seven months (Meter study) - Context management over long horizons remains challenging - Goal: Performance improvement from task to task, not starting from blank slate #### ⏱️ [00:06:30](https://www.youtube.com/watch?v=IGo225tfF2I?t=390) File system approach to memory - Models excel at navigating virtual environments - Claude capable with bash, git for organizing files - Opus 4.7 state-of-the-art at file system based memory - Principle: "Let it cook" - leverage existing model capabilities #### ⏱️ [00:08:45](https://www.youtube.com/watch?v=IGo225tfF2I?t=525) Multi-agent memory architecture - Readonly organization-wide memory vs read-write granular stores - Optimistic concurrency control prevents write conflicts - Version control creates audit trails with attribution - Standalone API enables external memory management #### ⏱️ [00:11:20](https://www.youtube.com/watch?v=IGo225tfF2I?t=680) Dreaming breakthrough - Addresses locally optimal but globally suboptimal memory patterns - Out-of-band feedback loop analyzing cross-session patterns - Can be triggered ad hoc, scheduled, or event-driven - Harvey saw 6x increase in legal benchmark completion rates #### ⏱️ [00:14:00](https://www.youtube.com/watch?v=IGo225tfF2I?t=840) Dreaming architecture benefits - Decoupled from agent loops enables multi-agent analysis - Clear objectives without trading off task completion - No latency impact on agent performance - Dedicated dreaming harness built on managed agents #### ⏱️ [00:16:30](https://www.youtube.com/watch?v=IGo225tfF2I?t=990) SRE demo walkthrough - Agent platform for alert triage and incident response - Organization-wide readonly memory for policies and runbooks - Cross-session coordination through shared memory stores - Audit logs and version history for enterprise compliance #### ⏱️ [00:20:15](https://www.youtube.com/watch?v=IGo225tfF2I?t=1215) Dreaming process demonstration - Analyzes patterns across multiple sessions - Identifies recurring issues like CPU spike to alert correlations - Updates memory with holistic insights rather than rote logs - Built using cloud managed agents analyzing themselves ## 📚 References - [Anthropic Memory and Dreaming](https://www.youtube.com/watch?v=IGo225tfF2I) - Model Context Protocol (MCP) - Cloud Managed Agents platform - Meter study on agent task complexity growth ## 🗣️ Paraphrase Anthropic has developed a sophisticated memory system for AI agents that fundamentally changes how they learn and improve. Rather than treating each task as isolated, agents now maintain persistent memory using familiar file system operations they already excel at. The breakthrough "dreaming" feature acts as a global optimizer, analyzing patterns across multiple agent sessions to identify and fix recurring problems automatically. This creates a continuous improvement loop where agents get smarter over time, with enterprise customers seeing dramatic performance gains in production deployments. ## 📰 Newsletter 🧠 **AI Agents Just Got Memory (And Dreams!)** - Anthropic dropped some serious agent upgrades that WordPress developers should pay attention to. Their new memory system lets AI agents actually learn from previous tasks instead of starting fresh each time - think of it like giving your debugging assistant the ability to remember that weird plugin conflict from last week. Even cooler is "dreaming" - an automated process that spots patterns across multiple agent sessions and optimizes their knowledge base. Early users saw 97% fewer errors and 6x better completion rates. While this is enterprise-focused for now, the implications for WordPress automation, support systems, and developer tooling are huge. [Check out the demo](https://www.youtube.com/watch?v=IGo225tfF2I) to see agents coordinating like a well-oiled DevOps team. ## ✅ Action Items #### DevRel - Research integration opportunities between Anthropic's memory APIs and WordPress developer workflows - Create educational content demonstrating memory-enabled agents for common WordPress development tasks - Explore partnerships with Anthropic for WordPress-specific agent memory templates #### Community - Document memory system patterns that could benefit WordPress plugin and theme development - Investigate community-driven memory stores for common WordPress troubleshooting scenarios - Develop guidelines for responsible memory usage in WordPress agent implementations #### WordPress - **Core AI**: Evaluate memory capabilities for WordPress.org's AI initiatives and documentation systems - **Documentation**: Assess how persistent agent memory could improve DevHub and HelpHub user experiences - **Support**: Research memory-enabled agents for WordPress.org support forum automation and knowledge management ## 🧪 Hypotheses - Memory-enabled agents will dramatically reduce repetitive debugging time for WordPress developers - Cross-session memory sharing will create emergent knowledge networks within development teams - Dreaming-style optimization will identify and resolve common WordPress configuration anti-patterns automatically - File system based memory will integrate naturally with existing WordPress development workflows and version control - Enterprise WordPress agencies will see significant productivity gains from persistent agent memory - Community-driven memory stores will emerge as valuable resources for WordPress troubleshooting and best practices ### 📊 Methodology - A/B testing with and without memory-enabled agents on WordPress development tasks - Longitudinal analysis of agent performance improvement over multiple sessions - Survey research on developer productivity metrics before and after memory system adoption - Case study analysis of enterprise WordPress implementations using memory-enabled agents - Benchmarking studies comparing memory approaches against traditional stateless agent interactions ### ❓ Questions - How can WordPress-specific memory schemas be designed to maximize learning efficiency? - What privacy and security considerations arise when agents maintain persistent memory about client projects? - How might memory-enabled agents change the economics of WordPress maintenance and support? - What role could the WordPress.org community play in developing shared agent memory resources? - How do memory capabilities interact with existing WordPress caching and performance optimization strategies? ### 🔮 Future Research - Investigation of memory portability between different AI agent platforms and WordPress environments - Development of standardized memory schemas for common WordPress use cases and troubleshooting scenarios - Research into federated learning approaches for WordPress agent memory across multiple organizations - Exploration of memory-enabled agents for WordPress accessibility testing and WCAG compliance automation - Study of memory system integration with WordPress REST API and GraphQL implementations ### 💡 Implications **WordPress Development**: Memory-enabled agents could transform debugging from repetitive manual processes to accumulated institutional knowledge, dramatically reducing time-to-resolution for common issues. **Community Knowledge**: Shared memory stores could create unprecedented collaboration opportunities, allowing the global WordPress community to collectively improve agent capabilities through shared experiences. **Enterprise Adoption**: Organizations managing large WordPress installations could see significant cost savings through agents that learn and improve their maintenance and support capabilities over time. **Security Considerations**: Persistent agent memory introduces new vectors for both enhanced security monitoring and potential data exposure that the WordPress security community must address. **Educational Impact**: Memory-enabled agents could revolutionize WordPress education by providing personalized learning experiences that adapt based on individual developer progress and common stumbling points. ### 🧠 Learning Styles Assessment Reading level estimate: Grade 12-14 (Flesch-Kincaid) - technical content with complex concepts explained clearly #### 👀 Visual learners - Present: Architecture diagrams showing memory hierarchy and dreaming feedback loops - Improve: Interactive visualizations of memory evolution over time, flowcharts of agent decision-making processes #### 🔊 Aural learners - Present: Video presentation with clear narration and live demonstration - Improve: Podcast-style deep dive discussions, audio summaries of key memory concepts #### 🗣️ Verbal learners - Present: Clear definitions, analogies to human memory and learning, comprehensive glossary - Improve: Story-driven case studies, conversational explanations of technical concepts #### 🧩 Kinesthetic learners - Present: Interactive demo showing memory system in action, hands-on SRE scenario - Improve: Sandbox environments for experimenting with memory configurations, step-by-step tutorials #### 🧠 Logical learners - Present: Systematic architecture breakdown, performance metrics, clear cause-and-effect relationships - Improve: Decision trees for memory optimization, algorithmic explanations of dreaming processes #### 🧑‍🤝‍🧑 Social learners - Present: Multi-agent collaboration examples, cross-session memory sharing demonstrations - Improve: Community forums for sharing memory patterns, collaborative memory store development #### 🧘‍♀️ Solitary learners - Present: Self-contained demo, individual agent performance improvement examples - Improve: Personal reflection prompts on memory applications, self-paced learning modules #### 🌿 Naturalistic learners - Present: Analogies to biological memory and learning systems, ecosystem thinking about agent networks - Improve: Connections to natural learning patterns, environmental impact considerations of persistent memory systems ### 📊 Accessibility Assessment #### Screen reader semantics - Present: Clear headings, logical document structure, descriptive video narration - Improve: Alt text for architecture diagrams, ARIA labels for interactive demo elements #### Keyboard navigation - Present: Standard video controls accessible via keyboard - Improve: Keyboard shortcuts for demo navigation, tab-accessible memory management interfaces #### Contrast and readability - Present: High contrast slides, clear typography in presentation - Improve: Dark mode options for console interfaces, customizable text sizes #### Text resizing and reflow - Present: Responsive design considerations mentioned - Improve: Zoom support verification for technical diagrams, scalable UI elements #### Media and captions - Present: Full transcript provided for video content - Improve: Closed captions with technical term definitions, audio descriptions for visual demonstrations #### Forms and interactions - Present: Clear API examples and parameter descriptions - Improve: Form validation feedback, error state explanations for memory operations ### 🌍 DEIB Assessment #### Cultural breadth - Present: Enterprise examples from multiple domains (legal, SRE, document verification) - Improve: Examples from diverse global WordPress communities, non-English use cases #### Inclusive language - Present: Clear technical explanations without unnecessary jargon - Improve: Glossary with plain-language definitions, cultural context for "dreaming" terminology #### Neurodiversity support - Present: Structured presentation with clear sections and timestamps - Improve: Multiple information processing pathways, attention-friendly content chunking #### Representation - Present: Focus on technical capabilities rather than specific demographic groups - Improve: Diverse use case examples, consideration of different organizational structures #### Psychological safety - Present: Professional, technical presentation style - Improve: Acknowledgment of AI limitations, clear boundaries on memory privacy and security ### ✅ Logical Validity #### Strong reasoning - **Empirical evidence**: Customer metrics (97% error reduction, 6x completion improvement) provide concrete validation - **Analogical reasoning**: File system approach leverages proven model capabilities rather than inventing new paradigms - **Causal logic**: Clear progression from problem identification (context management) to solution design (persistent memory) to optimization (dreaming) #### Fallacies - **Appeal to novelty**: Minor tendency to emphasize "breakthrough" aspects without sufficient comparison to existing memory systems - **Hasty generalization**: Limited customer examples may not represent broader applicability across all use cases - **Cherry-picking**: Selective presentation of success metrics without discussion of limitations or failure modes #### Tone of voice - **Professional and confident**: Technical presentation style with clear expertise demonstration - **Enthusiastic but measured**: Excitement about capabilities balanced with practical implementation details - **Solution-oriented**: Focus on addressing real problems rather than theoretical capabilities ### 🛡️ DARVO Analysis No DARVO tactics detected. This is a straightforward technical presentation of new capabilities with supporting evidence and demonstrations. The presenter acknowledges the evolutionary nature of memory concepts while clearly differentiating their approach. ## 🎯 Conclusion Anthropic's memory and dreaming capabilities represent a significant evolution in AI agent architecture, moving from stateless task execution to persistent learning systems. The file system approach cleverly leverages existing model strengths while the dreaming feedback loop addresses the critical challenge of global optimization across agent sessions. For WordPress developers and the broader web development community, these capabilities suggest a future where AI assistants accumulate domain expertise over time, potentially transforming how we approach debugging, maintenance, and knowledge management. The enterprise-grade controls and multi-agent coordination features indicate readiness for production deployment, making this a technology worth monitoring closely as it becomes more broadly available. ## 🔄 Refactor Appendix — Memory and dreaming for self learning agents ### 📚 Literature Atoms (H3) #### Memory enables cross-task learning through persistent file system storage > [!quote] > "Memory lets agents learn. It lets agents carry forward learnings from their previous tasks. In the simplest sense, imagine a set of tasks. Task one, task two, task three, and so on. The goal is for performance to improve from one task to the next." **Context & use**: - Core value proposition around 3:15 in presentation - Fundamental shift from stateless to stateful agent operation **Tags**: #ai-agents #memory-systems #performance-optimization  #### Dreaming provides global memory optimization across agent sessions > [!quote] > "Dreaming is a process that looks for patterns and mistakes across agents and sessions, and it automatically curates their memory. It's completely decoupled. Think of it like a feedback loop. Agents write memories and dreaming refines and this process repeats." **Context & use**: - Introduced around 11:20 as solution to locally optimal but globally suboptimal memory patterns - Key innovation distinguishing Anthropic's approach from simple persistence **Tags**: #ai-agents #optimization #distributed-systems  #### File system approach leverages existing model capabilities for memory management > [!quote] > "With memory we've leaned into that same direction with files. Models and claude are great at navigating virtual environments and a file system. And Claude is also very capable at using familiar tools like bash and GP to read, update, and organize files." **Context & use**: - Design philosophy explanation around 6:30 - Demonstrates principle of building on model strengths rather than forcing new paradigms **Tags**: #ai-design #file-systems #model-capabilities  ### 🧠 Permanent Candidates (H4) #### AI agents achieve continuous improvement through persistent memory and global optimization **Claim**: Memory systems combined with out-of-band optimization processes enable AI agents to learn from experience and improve performance across task boundaries, similar to how humans build expertise over time. **Evidence pointer**: [[#Memory enables cross-task learning through persistent file system storage]] and [[#Dreaming provides global memory optimization across agent sessions]] **Scope & conditions**: - Requires sufficient task volume to identify patterns worth optimizing - Benefits increase with multi-agent environments where learning can be shared - Most effective for domains with recurring patterns and learnable best practices **Links**: - [[Distributed AI systems]] — because extends coordination capabilities beyond single sessions - [[Enterprise AI deployment]] — because enables production-ready agent systems with institutional memory - [[Human-computer collaboration]] — because applies-in scenarios where agents need to build domain expertise  ### ✏️ Fleeting Queue - Research memory persistence patterns in WordPress development workflows #fleeting #wordpress - Investigate privacy implications of persistent agent memory in client work #fleeting #security - Explore community-driven memory sharing for WordPress troubleshooting #fleeting #community ### → Things 3 - [ ] Test Anthropic's memory APIs with WordPress development scenarios — evaluate integration potential #things - [ ] Document memory system patterns relevant to WordPress agent implementations — create educational resource #things --- ## Full Transcript [00:13] Hello. Thank you for joining us today. [00:15] I'm excited to kick things off on uh the [00:18] breakout stage. My name is Ravi and I [00:22] lead the API knowledge team within [00:24] platform at Enthropic. And since joining [00:27] Anthropic last year, my focus has been [00:31] creating the building blocks for agents [00:33] to interact with many forms of [00:35] knowledge, ranging from the context [00:37] window itself to skills, files, and even [00:41] content on the web. And we recently [00:44] released two features that I'm most [00:46] excited about. [00:48] Memory and dreaming. We now have the [00:51] building blocks for agents to learn over [00:53] time and improve from one task to the [00:56] next. And I'll talk about why we think [00:59] memory is important, how we designed it, [01:01] and we'll close out with dreaming, our [01:03] new frontier memory feature. [01:09] There we go. [01:11] But first, a quick timeline of [01:14] milestones that got us here. And the [01:17] important thing is models have been [01:19] improving and agents are capable of [01:23] completing tasks that take many many [01:26] hours and are increasingly complex. So [01:28] in 2024 [01:30] we released model context protocol MCP [01:33] and this gave models access to external [01:36] tools and data in a principled way. In [01:39] 2025, we released Cloud Code and the [01:43] agent SDK, which lowered the barrier to [01:45] using and building agents, [01:48] which as an aside, that blows my mind [01:51] that that was in 2025. It honestly feels [01:53] like a lifetime ago. Later that year, we [01:56] launched skills, which gave model models [02:00] a generic abstraction for unlocking and [02:03] effectively bolting on new capabilities [02:06] to complete specific tasks. [02:09] Last month we released cloud managed [02:11] agents a platform for reliably running [02:14] agents that takes care of the hard [02:16] parts. [02:18] Now [02:20] the important through line here is that [02:22] agents can do more and they can operate [02:25] over longer and longer time horizons. So [02:28] in 2025, Meter released a study saying [02:32] the length of tasks that agents can [02:34] complete is doubling every seven months. [02:38] And we're seeing this happen. [02:41] But managing context over long horizon [02:43] tasks is still a work in progress. And [02:47] that's where memory comes in. [02:52] Memory lets agents learn. [02:54] It lets agents carry forward learnings [02:57] from their previous tasks. And in the [03:01] simplest sense, imagine a set of tasks. [03:04] Task one, task two, task three, and so [03:08] on. The goal is for performance to [03:11] improve from one task to the next. In [03:14] the base case without something like [03:16] memory, performance on each task might [03:18] be similar [03:20] because every agent is just starting [03:23] from the same slate. In the optimal [03:26] case, performance improves from task one [03:28] to two, task two to three, and so on. [03:32] That's the goal. Learning from task to [03:34] task, but also from environment to [03:37] environment and agent to agent. So with [03:41] memory agents can learn from common [03:43] strategies and previous mistakes. They [03:46] can learn from the tools they have [03:47] access to or code bases and files. And [03:50] finally they can transfer these [03:52] learnings to and from other agents. [03:56] Think swarms of agents contributing to [03:59] and maintaining a shared understanding [04:01] of the organization they work in. [04:05] This is the dream. [04:10] So we recently launched memory for cloud [04:13] managed agents and this is a major step [04:16] towards this vision. It gives developers [04:19] a frontier memory system that is built [04:22] to maximize intelligence out of the box [04:25] and it supports multi- aent systems all [04:28] with enterprise control and [04:30] observability. [04:35] And we built memory in partnerships with [04:38] several teams that are using managed [04:40] agents. And the results speak for [04:42] themselves. Racketin saw a 97% decrease [04:47] in first pass errors in agents deployed [04:50] in production. Wise docs reduced common [04:54] issues using cross session memory in [04:56] their document document verification [04:58] pipeline. And the through line here and [05:01] the common feedback we get is that our [05:04] memory primitive allows teams to focus [05:07] on building the product not the infra [05:10] and all while reaping the benefits of [05:12] increased intelligence that comes along [05:14] with better memory. [05:20] Now [05:21] you might be thinking is memory really [05:24] new? Rightfully so. [05:28] Memory is a concept that's not entirely [05:30] new, but our approach for it with agents [05:33] has greatly evolved and previously we [05:37] built memory focusing on capabilities in [05:40] the harness. So you might be familiar [05:42] with claw.md for cloud code or dedicated [05:46] memory tools in the SDKs. [05:49] But one pattern we're seeing is that as [05:52] models improve, we really just want to [05:54] get out of Claude's way, similar to what [05:57] we did with skills. And skills was a [06:00] very basic format that was highly [06:03] flexible. And it created endless [06:05] possibilities. And the model understood [06:07] how to operate with it. And so with [06:09] memory, we've leaned into that same [06:11] direction with files. [06:17] So let's talk about some of the [06:19] capabilities that we design memory [06:21] around. So right now with the current [06:24] set of models, we know a few things. [06:27] Models and claude are great at [06:29] navigating virtual environments and a [06:31] file system. And Claude is also very [06:35] capable at using familiar tools like [06:37] bash and GP to read, update, and [06:39] organize files. [06:41] Opus 4.7 [06:43] that we launched last month is a [06:46] state-of-the-art model at file system [06:48] based memory and it's increasingly [06:51] capable of discerning which context is [06:54] most important to save for its future [06:57] self and how it should be structured and [06:59] how it should be represented. And so [07:01] with memory we've modeled it as a file [07:04] system to quad. Again, the key principle [07:08] is getting out of cloud's way and [07:10] letting it use the capabilities it [07:12] already has that are very strong. Or as [07:15] we like to say, let it cook. This is the [07:18] dream. [07:22] But we've talked about Claude's memory [07:25] capabilities within the context of a [07:27] single agent, but we want it to work [07:30] across multiple agents that are [07:33] operating in the same environment at the [07:35] same time or maybe across environments. [07:37] And this introduces new requirements [07:40] like for example letting multiple [07:42] sessions share the same memory store at [07:44] the same time. And maybe they want [07:46] different scopes. So we offer readonly [07:48] scopes and read write scopes. So for [07:51] example, you could have organizationwide [07:55] memory that's readon and it's updated [07:57] fairly infrequently and it can be [07:59] accessed by all agents and the same set [08:01] of agents can have access to more [08:04] granular memory stores that they can [08:06] read and write freely and so this [08:08] creates a hierarchy and uh allows the [08:11] memory system to really scale. [08:14] Now, to combat right conflicts, to make [08:16] sure that one agent isn't clobbering [08:18] another's rights, we employed a [08:20] optimistic concurrency control model to [08:22] avoid agents overwriting each other's [08:24] changes. [08:28] And last but not least, memory needs to [08:32] work for real production agents. This [08:35] means enterprisegrade controls. So [08:39] version control uh creates an audit [08:42] trail as agents make changes and [08:44] developers can see how memory evolves [08:46] over times. They can even diff between [08:48] versions and there's attribution to see [08:51] which agent wrote which part of the [08:54] memory. [08:55] And I think one of the most important [08:58] pieces is that memory has a standalone [09:01] API. It enables developers to manage [09:04] their memory from anywhere. And the [09:06] reality is teams are building their [09:08] systems in many different environments. [09:10] So they can use memory via these APIs [09:14] which provide standard credit operations [09:16] but also more enterprise focused [09:18] operations like exports and redactions. [09:26] Okay. So we've covered three key [09:29] components of a memory architecture. [09:31] One, we started with the storage layer, [09:34] which is how the data is managed itself [09:36] and how changes are tracked. Next, the [09:39] structure of memory, optimizing in a [09:41] format that allows Claude to get the [09:44] most out of it. And finally, [09:47] cloud-driven processing for updating the [09:50] memory. [09:53] Now, let's stop at that processing [09:54] point. [09:59] agents writing memory as they work is [10:02] very key to the processing layer. Think [10:03] of it as taking notes while you're doing [10:05] something. But as we scaled up this [10:09] pattern to more complex multi- aent [10:12] works like uh use cases, we started [10:15] seeing some limits across different [10:18] sessions and we started seeing some [10:19] common patterns. For example, [10:22] agents were prone to making many of the [10:25] same mistakes and they learned from [10:27] their mistakes independently. agents [10:29] also displayed some of the same patterns [10:31] of inefficiency. [10:33] And the general theme was memory was [10:36] being updated in a locally optimal way, [10:38] but it wasn't globally optimal. In some [10:41] cases, there was duplication or [10:43] fragmentation. [10:45] And so we started thinking really deeply [10:48] about this problem and in the last [10:50] couple of months we built a feedback [10:51] loop in the processing layer that combed [10:54] some of these problems. [10:58] Now, I've said it a couple times, but [10:59] this time I mean it. This really [11:05] is available in research preview right [11:07] now, and it can be used with managed [11:08] agents. [11:10] It's a process that looks for patterns [11:12] and mistakes across agents and sessions, [11:16] and it automatically [11:18] curates their memory. [11:20] Customers [11:22] like Harvey saw a six times increase in [11:26] completion rates for their legal [11:28] benchmark with Dreaming and we're [11:30] actively seeing other usage of Dreaming [11:32] and we're really excited to see how [11:34] people are benefiting from it. [11:40] A quick overview of how [11:43] it is process [11:45] from sessions. It's completely [11:47] decoupled. Think of it like a feedback [11:50] loop. Agents write memories and dreaming [11:53] refines and this process repeats. And [11:56] dreaming can be kicked off ad hoc, [11:58] nightly, hourly, or it can even be [12:00] triggered by events like the end of a [12:03] session. It's all controlled via API. [12:06] So, it's very flexible. [12:08] Each dreaming run analyzes session [12:11] transcripts. It inspects the existing [12:13] state of memory and it proposes [12:16] optimizations to the memory in scenarios [12:18] where sessions were inefficient, made [12:21] mistakes or needed improved guidance. [12:24] And the output is a verified better [12:28] organized snapshot of memories that [12:31] agents can choose to adopt. [12:34] And dreaming truly enables continuous [12:37] selfarning. It closes the loop on [12:40] memory. [12:44] I mentioned outofband the outofband [12:47] component of dreaming is really really [12:49] critical [12:50] creating a process that's decoupled from [12:53] the underlying agent loop has benefits [12:56] for one architecture makes it useful for [13:00] multi- aent systems looking at cross [13:03] session cross agent transcripts discerns [13:06] patterns that a single agent in [13:08] isolation might struggle to identify [13:12] There's also benefits to having a [13:14] dedicated dreaming harness. It allows [13:16] for clearer objectives. Since dreaming [13:19] is an independent process, there's no [13:21] risks of agents needing to trade off [13:24] between [13:26] improving their memory quality or [13:28] actually just completing their task [13:29] objective. [13:31] It's clean separation. And lastly, it [13:34] doesn't add any latency to the agent. [13:37] It's completely removed from the hot [13:39] pass. [13:43] So zooming out, [13:46] we now have a robust memory layer that [13:48] can be shared across agents and [13:50] environments instead of only within [13:52] specific tasks or usage. We also have [13:55] dreaming, a process that globally [13:58] optimizes and reconciles memory across [14:01] agents. [14:02] And the result is a capable memory [14:05] system for organizational memory that is [14:08] capable of scaling up both the size as [14:12] well as the quality of memory. And the [14:17] way I think about it is sharing memory [14:19] that's constantly improving across [14:21] agents raises the floor for every agent [14:24] and dreaming raises it even further. [14:31] And if you really explode the size of [14:34] this capability and you pull it all [14:36] together, memory becomes a huge source [14:40] of knowledge. [14:50] models or test time compute where [14:54] letting models spend some tokens to [14:56] explore a problem on average produces [14:59] better outcomes. With dreaming, agents [15:02] are doing the same thing. They're [15:04] spending some work up front to curate [15:06] and produce higher quality memory and [15:08] that pays dividends for all downstream [15:10] agent performance. [15:16] We believe that dreaming and memory form [15:19] the basis of a frontier memory system. [15:21] Memory on the left helps agents learn [15:24] and remember from task to task and [15:26] dreaming on the right verifies, [15:28] organizes and enriches the memory. [15:32] The way I think about it is dreaming is [15:35] the bridge between memory as we know it [15:38] today and organization scale memory and [15:41] knowledge. [15:44] Now I'm going to flip over to a demo. [15:53] So this uses both dreaming and memory in [15:56] practice. It's an agent platform for [15:59] SRRES [16:00] and everyone loves being on call, right? [16:02] So here we have a system that looks at [16:05] incoming alerts and pages and for some [16:07] of them it actually uh spins up agents [16:10] that decide how to triage and fix the [16:12] issues as they come up [16:16] and it has access to a couple of memory [16:18] stores. One is a readonly orwide [16:22] knowledge memory store. And so this [16:24] contains things like the SLO policy or [16:27] runbooks and on call mappings [16:29] information that doesn't change very [16:31] often but is important for every agent. [16:33] And it also has access to read write [16:35] memory stores that are specific to the [16:38] task at hand. [16:40] Now [16:41] we can dig into an interesting example [16:44] here where an agent investigated [16:49] and found the root cause of an alert [16:54] and [16:56] it put up a fix and it noted in memory. [16:59] You can see the writes. It noted in [17:00] memory that a fix was in flight and it [17:03] was incoming. And then [17:06] the shared memory store can be read by [17:10] uh subsequent sessions. And so here we [17:13] can see that when a similar issue [17:15] arises, [17:17] the downstream session already knows [17:20] that a fix is in flight and it's able to [17:22] act based on that information. [17:27] And I really think this is [17:31] just such a cool pattern because you [17:33] know the I I was once an SR in my career [17:36] and this really uh helps coordinate [17:40] across all agents [17:42] and it's really cross- session memory at [17:44] work. [17:46] Now for running in enterprises uh an [17:50] important piece here is audit logs and [17:53] history. So with memory you can see the [17:57] full version history. You can switch [17:59] between different versions and you can [18:01] also attribute the rights to specific [18:03] sessions. And there's also a [18:06] precondition here and that's the [18:07] optimistic concurrency model to make [18:09] sure that agents aren't clobbering each [18:11] other's rights. [18:14] Now [18:16] we'll flip over to the cloud console. [18:27] One moment. [18:29] There we go. [18:31] So, here we see the list of underlying [18:34] memory stores that we were using in that [18:35] application. And so, we'll go over to [18:38] our team SR memory store. And you can [18:40] see exactly the underlying files that [18:42] were populated there. [18:45] And we're going to head over to the [18:46] dreams tab. And we're going to kick off [18:48] a dream. And so this can also be done [18:51] via the API uh but also in the UI. And [18:55] we're going to select the team SR memory [18:56] store and we're going to select a batch [18:58] of sessions from the last seven days. So [19:00] that's about five. [19:02] And we're going to start dreaming. [19:05] As it begins, you can see it making [19:06] progress. [19:09] You can look at the dream and see that [19:11] there are five input sessions. And then [19:14] you'll see there's actually an output [19:15] memory store that's being compiled. And [19:18] you can actually open the dreaming [19:19] session. This is an important piece. [19:21] Dreaming itself is built on cloud manage [19:23] agents. So it's a feature for cloud [19:25] manage agents built on cloud manage [19:26] agents itself. You can see that it spins [19:29] off a series of sub aents to analyze [19:30] transcripts in parallel. And it has all [19:33] the same UX as the rest of manage [19:35] agents. And we'll fast forward to a [19:38] completed dream session. And you can see [19:41] the diffs on the memory store updates. [19:45] And [19:46] in this example here, we see that [19:51] across sessions and across agents, [19:54] there's a a common pattern of an alert [19:57] triggering 60 seconds after a CPU spike. [20:01] And this is a recurring pattern. And so [20:04] it starts to discern that there might be [20:06] some issue with the retry behavior. [20:09] And so it makes a note. So this dreaming [20:11] process makes a note and updates memory [20:13] so that the next agent that sees this [20:16] pattern can actually [20:19] similarly updates the triage log in a [20:22] more holistic way rather than just being [20:24] a wrote log of all the events that [20:26] happened. [20:33] And that's memory and dreaming at work. [20:34] So we'll flip back over to the slides [20:39] and we'll close out. So with that demo, [20:43] we saw how we can build a a production [20:46] agent that uses memory and dreaming to [20:50] self-improve the agents. [20:52] And [20:54] this year I think is going to be a [20:55] really big one. We're going to see [20:57] agents run for longer and longer time [20:59] scales, days for example, and [21:02] continuously building upon and improving [21:05] their understanding and view of the [21:07] world around them is very critical to [21:09] unlocking that capability. And I think [21:12] memory systems are going to be a big [21:14] part of what makes this behavior [21:16] possible. So give it a try. I'm excited [21:20] to see what everyone builds with it. And [21:23] I'll be outside if you have more [21:24] questions. Thank you.  ## Highlights - Memory lets agents learn. It lets agents carry forward learnings from their previous tasks. In the simplest sense, imagine a set of tasks. Task one, task two, task three, and so on. The goal is for performance to improve from one task to the next. - Note: 📚 Memory enables cross-task learning through persistent file system storage · - Core value proposition around 3:15 in presentation - Fundamental shift from stateless to stateful agent operation · #atom/literature/h1 - Dreaming is a process that looks for patterns and mistakes across agents and sessions, and it automatically curates their memory. It's completely decoupled. Think of it like a feedback loop. Agents write memories and dreaming refines and this process repeats. - Note: 📚 Dreaming provides global memory optimization across agent sessions · - Introduced around 11:20 as solution to locally optimal but globally suboptimal memory patterns - Key innovation distinguishing Anthropic's approach from simple persistence · #atom/literature/h2 - With memory we've leaned into that same direction with files. Models and claude are great at navigating virtual environments and a file system. And Claude is also very capable at using familiar tools like bash and GP to read, update, and organize files. - Note: 📚 File system approach leverages existing model capabilities for memory management · - Design philosophy explanation around 6:30 - Demonstrates principle of building on model strengths rather than forcing new paradigms · #atom/literature/h3 - AI agents achieve continuous improvement through persistent memory and global optimization - Note: Requires sufficient task volume to identify patterns worth optimizing · - [[Distributed AI systems]] — because extends coordination capabilities beyond single sessions · #atom/zettel/z1 - Research memory persistence patterns in WordPress development workflows #fleeting #wordpress - Note: ✏️ Fleeting capture #atom/fleeting/f1 - Investigate privacy implications of persistent agent memory in client work #fleeting #security - Note: ✏️ Fleeting capture #atom/fleeting/f2 - Explore community-driven memory sharing for WordPress troubleshooting #fleeting #community - Note: ✏️ Fleeting capture #atom/fleeting/f3 - Limited customer examples may not represent broader applicability across all use cases - Note: 🔍 Fallacy: Hasty Generalization #fallacy/hasty-generalization