We analyzed Anthropic’s memory architecture and built something...

Uploaded: 2026-04-03T04:13:30.000Z
Duration: PT79.066S
Channel: andy nguyen

1:46

Memory for OpenClaw is now Native! Our first OpenClaw Memory Skill was a massive success: 30k+ downloads in a week and 500k+ organic impressions overnight for launch post. But we knew memory needed to be native. On March 21, OpenClaw merged PR #50848, allowing us to go beyond the skill layer and integrate directly into the agent’s context assembly flow. We try to make OpenClaw a truly 24/7 employee capable of complex workflows. The technical setup isn’t the hardest part but the real challenge is giving it a "brain" that remembers exact project details, past decisions, and team changes over time. The Native Memory Plugin is now live on NPM & ClawHub. Here is what it brings to your OpenClaw agents: 👉 Native Integration: Automatically manages a Three-Layer Memory architecture (Context Tree, Workspace Memory, Daily Memory). 👉 Git-like Stateful Memory: Organizes memory into a semantic hierarchy of human-readable, diffable Markdown files. You always get updated knowledge and can actually see and fix what your agent learns. 👉 Top Market Accuracy: Achieves an industry-leading 92.2% retrieval accuracy (LoCoMo & LongMemEval benchmarks), maintaining 90% accuracy even with cheap, lightweight models. 👉 Local-first & Portable: Local-by-default, fully portable for multi-agent teams. 👉 Super Easy Setup

andy nguyen

169,136 views • 4 months ago

1:37

New course: Agent Memory: Building Memory-Aware Agents, built in partnership with Oracle and taught by Richmond Alake and Nacho Martínez. Many agents work well within a single session but their memory resets once the session ends. Consider a research agent working on dozens of papers across multiple days: without memory, it has no way to store and retrieve what it learned across sessions. This short course teaches you to build a memory system that enables agents to persist memory and thereby learn across sessions. You'll design a Memory Manager that handles different memory types, implement semantic tool retrieval that scales without bloating the context, and build write-back pipelines that let your agent autonomously update and refine what it knows over time. Skills you'll gain: - Build persistent memory stores for different agent memory types - Implement a Memory Manager that orchestrates how your agent reads, writes, and retrieves memory - Treat tools as procedural memory and retrieve only relevant ones at inference time using semantic search Join and learn to build agents that remember and improve over time!

Andrew Ng

160,148 views • 4 months ago

2:26

Memory Skill for OpenClaw with 26k+ users in 1 week🚀 OpenClaw's memory system is broken by default. It requires curating massive MEMORY.md files or relying on duplicate-heavy generation. Hours are wasted tuning, and massive amounts of tokens are burned. It's time to stop. So we built the memory skill to solve that prob Here is our superpower ⚔️ 🎯 Top #1 market accuracy (92.19%) after 8+ months of intense architecture iteration 🧠 The ultimate solution to keep the timeline, facts, and meaning perfectly in place ☁️ Local & Cloud + Version control ⚡ Super easy setup

andy nguyen

589,092 views • 4 months ago

0:39

Clude is now available as a custom connector on Anthropic Claude. Giving it persistent memory across every conversation. It remembers your projects, your preferences, and the decisions you make, so you never start from zero again. Use Clude across Chat / Co-Work and Claude Code. Add it in 30 seconds, no API key: 1. In Claude: Customize, Add custom connector URL: Enter your email. That's it. Recap for people unfamiliar: Clude deviates from the traditional vector database that many others bolt onto Claude. We are a cognitive memory system modeled on how human memory works. Think traditional memory systems: Calculator > It computes. Fullstop. Excel > Dynamic, formula run, able to share and manipulate Clude scored 86% on LongMemEval, one of the toughest long-term memory benchmarks. This means less hallucinations to traditional platforms. It scores memories by relevance, recency, and importance, links them into a knowledge graph, and consolidates them over time. Tell Claude something, open a new chat, and watch it remember.

seb

19,640 views • 1 month ago

2:24

We’re excited to launch OpenMemory MCP, a private memory for MCP-compatible clients powered by mem0 Today, most AI assistants and dev tools operate without memory. You plan your roadmap in Claude, implement tasks in Cursor, but none of them know what the other did. Each tool operates in isolation, and your context disappears as soon as the session ends. OpenMemory MCP solves this. Built on the open Model Context Protocol (MCP), OpenMemory MCP runs 100% locally and provides a persistent, portable memory layer for all your AI tools. It enables agents and assistants to read from and write to a shared memory, securely and privately. Key capabilities: ✅Works across MCP clients like Cursor, Claude Desktop, Windsurf, Cline and more ✅Provides standardized memory operations (add_memories, search_memory, list_memories, delete_all_memories) ✅Stores data on your machine, fully private ✅Offers a centralized dashboard for visibility and control ✅Simple Docker-based setup with no vendor lock-in If you're building on MCP, OpenMemory MCP is the easiest way to add persistent, private memory to your clients with zero cloud dependencies and full local control. We’ve put together a short demo to show how it works Check it out in the links below 👇

Taranjeet

471,972 views • 1 year ago

2:11

New course on serving LLMs efficiently -- how do you serve models to many concurrent users at low latency and reasonable cost? This short course is built with Red Hat and taught by Cedric Clyburn. Efficient LLM serving requires efficient memory management. A 70B-parameter model takes ~140 GB just to load the weights. On top of that, every active request needs its own chunk of GPU memory, the KV cache, to store the token context it has built up so far. In this course, you'll learn to reduce a model's memory footprint with quantization and serve it using vLLM, which handles many concurrent requests efficiently through smart memory management. Skills you'll gain: - Quantize a model and measure the accuracy tradeoff - Serve a model with vLLM and watch it handle concurrent requests efficiently - Benchmark your deployment and make informed tradeoffs between speed, cost, and accuracy Join and learn to serve LLMs efficiently:

Andrew Ng

127,603 views • 1 month ago

0:34

most agent memory is one file that grows forever and gets re-read every single turn. it overflows the context, overwrites old facts, loses the thread. that's why your agent feels sharp on day one and lost by week three. Sibyl Memory replaces the pile with a structure: → leaner context, lower token cost. a bloated agent file and flat memory get re-read in full every message. Sibyl Memory keeps a light hot layer and retrieves the rest on demand, so each turn carries only the tokens that matter. → relations are first-class. people link to projects, projects to deals, deals to the decisions behind them. ask about one partner and the agent surfaces the whole connected web around them. that relational context is what lets it help run a company. → one source of truth per fact, person, and project. no duplicates, no silent overwrites. works with hermes, claude code, and codex. beta open.

SIBYL

81,361 views • 1 month ago

0:29

Sharing a super simple, user-owned memory module we've been playing around: nanomem The basic idea is to treat memory as a pure intelligence problem: ingestion, structuring, and (selective) retrieval are all just LLM calls & agent loops on a on-device markdown file tree. Each file lists a set of facts w/ metadata (timestamp, confidence, source, etc.); no embeddings/RAG/training of any kind. For example: - `nanomem add ` starts an agent loop to walk the tree, read relevant files, and edit. - `nanomem retrieve ` walks the tree and returns a single summary string (possibly assembled from many subtrees) related to the query. What’s nice about this approach is that the memory system is, by construction: 1. partitionable (human/agents can easily separate `hobbies/snowboard.md` from `tax/residency.md` for data minimization + relevance) 2. portable and user-owned (it’s just text files) 3. interpretable (you know exactly what’s written and you can manually edit) 4. forward-compatible (future models can read memory files just the same, and memory quality/speed improves as models get better) 5. modularized (you can optimize ingestion/retrieval/compaction prompts separately) Privacy & utility. I'm most excited about the ability to partition + selectively disclose memory at inference-time. Selective disclosure helps with both privacy (principle of least privilege & “need-to-know”) and utility (as too much context for a query can harm answer quality). Composability. An inference-time memory module means: (1) you can run such a module with confidential inference (LLMs on TEEs) for provable privacy, and (2) you can selectively disclose context over unlinkable inference of remote models (demo below). We built nanomem as part of the Open Anonymity project ( but it’s meant to be a standalone module for humans and agents (e.g., you can write a SKILL for using the CLI tool). Still polishing the rough edges! - GitHub (MIT): - Blog: - Beta implementation in chat client soon: Work done with amazing project co-leads Amelia Kuang Coco Xu Erik Chi !!

Ken Liu

73,840 views • 3 months ago

0:50

Xiaomi just dropped a FREE CLAUDE CODE with memory that actually persists between sessions and nobody is talking about it MiMo Code dropped 4 days ago. 8k GitHub stars. Built-in free model called MiMo Auto - you just install it and it works, zero configuration, zero API keys What's inside: > persistent memory across sessions - agent picks up exactly where it stopped > subagents that spawn automatically and run in parallel > /dream extracts knowledge from your session into project memory > /distill turns your repeated workflows into reusable skills > /goal with a judge model that decides if the work is actually done - not just if the agent thinks it is How to install: > Mac / Linux: curl -fsSL | bash > Windows npm install -g MIMO-ai/cli Then run: > mimo video of me installing and running it is attached github(.)com/XiaomiMiMo/MiMo-Code

monokern

63,696 views • 1 month ago

0:43

researchers gave a tiny local model human-style memory and its context limit basically stopped existing a team from MBZUAI, Princeton and Weizmann took a 1B model and rebuilt how it reads. instead of attending to everything at once, the model reads in 1,024 token chunks and passes the important stuff forward through an associative memory, the same way you carry the plot of a book between chapters without rereading them. the design mirrors human memory on purpose. full attention inside a chunk works as short-term memory. the module that carries information between chunks works as long-term memory. they even trained it like a person, starting with short easy texts and raising the difficulty gradually, because memory thrown into the deep end learns nothing. the numbers back it up. the normal model burns 40GB of GPU memory on a long document and collapses hard past its limit, dropping from 0.86 to 0.32 accuracy. the memory version holds 0.71 at double that length while using a flat 12GB no matter how long the input gets. it also needs about 30% fewer FLOPs. the part i keep thinking about is that nobody scaled anything here. they didn't build a bigger model, didn't stretch the window, didn't add compute. they looked at how a brain handles a long day and copied the architecture. a model small enough to run on a consumer gpu now survives documents its own architecture used to choke on. we keep treating intelligence as a compute problem. sometimes it's a memory problem.

Alex Veremeyenko

16,147 views • 4 days ago

0:37

AI Agent Teams, DeFi Builders & Enterprises; this is the infrastructure you’ve been waiting for. Menese Protocol delivers entirely on-chain execution that is 100% trustless, non-custodial, and sovereign across 50+ blockchains with full composability into every DeFi protocol. No bridges. No custodians. No off-chain components. No single point of failure. Your autonomous AI agents gain native superpowers with $MENES $ICP $BTC $SOL $ETH $SUI and 50+ others: • Instant token swaps, liquidity provision, and 0% fixed-interest borrowing — executed directly on-chain • OpenClaw native plugin or lightweight SDK for fast integration • Smart contract brain for persistent state, memory, and autonomy (state survives even if the agent is replaced) • Built on Internet Computer threshold cryptography for true 24/7 sovereign operation Build with us. #AIAgents #DeFi #Multichain #OnChain #Trustless #NonCustodial #EnterpriseDeFi #BuiltOnICP #ICP #MeneseProtocol

Menese Protocol

14,976 views • 2 months ago

0:29

AutoGPT might be the next big step in AI. Here's why Karpathy recently said "AutoGPT is the next frontier of prompt engineering" AutoGPT is the equivalent of giving GPT-based models a memory and a body. You can now give a task to an AI agent and have it autonomously come up with a plan, execute on it, browse the web, and use new data to revise the strategy until the task is completed. It can analyze the market and come up with a trading strategy, customer service, marketing, finance, or other tasks that requires continuous updates. There are three components to it: 1. Architecture: It leverages GPT-4 and GPT-3.5 via API. 2. Autonomous Iterations: AutoGPT can refine its outputs by self-critical review, building on its previous work and integrating prompt history for more accurate results. 3. Memory Management: Integration with Pinecone allows for long-term memory storage, enabling context preservation and improved decision-making. 4. Multi-functionality: Capabilities include file manipulation, web browsing, and data retrieval, distinguishing AutoGPT from previous AI advancements by broadening its application scope.

Lior Alexander

808,102 views • 3 years ago

3:02

Our latest LangChain Academy course – Building Ambient Agents with LangGraph – is now available! Most agents today handle one request at a time through chat interfaces. But as models have improved, agents can now run in the background – and take on long-running, complex tasks. LangGraph is built for these “ambient agents,” with support for human-in-the-loop workflows and memory. LangGraph Platform provides the infrastructure to run these agents at scale, and LangSmith helps you observe, evaluate, and improve your agents. Together, they make it easier to build reliable, production-ready agents. In this course, you’ll: 📩 Learn the fundamentals of LangGraph and how to build your own email agent 📊 Evaluate your agent using LangSmith ✅ Add human-in-the-loop for reviews, and memory so your agent adapts over time 🚀 Deploy your agent with LangGraph Platform and connect it to Gmail

LangChain

33,192 views • 1 year ago

0:36

RAG might already be becoming obsolete. A month ago, Andrej Karpathy dropped a simple GitHub gist called “LLM Wiki.” Now the comments section looks like the birth of an entirely new AI category. 5000+ stars later, developers are rapidly building: • persistent AI memory systems • self-maintaining knowledge bases • multi-agent research environments • contradiction detection engines • AI-native company operating systems • local-first memory architectures • graph-based reasoning layers • evolving second brains And the craziest part? Most of them were built in DAYS. Because the core idea is insanely powerful: Instead of AI repeatedly retrieving raw chunks like traditional RAG… …the model continuously maintains a living knowledge system. Not temporary context. Persistent synthesis. The shift sounds subtle until you realize what it changes: RAG: retrieve → answer → forget LLM Wiki: ingest → synthesize → evolve That one architectural difference is causing an explosion of experimentation right now. People are already building: • agent memory operating systems • AI-maintained engineering documentation • self-healing knowledge graphs • persistent research environments • conversational memory architectures • contradiction-aware wikis • context compression engines • machine-readable company systems The comments section alone feels like watching an ecosystem form in real time. One developer built deterministic contradiction detection using sheaf cohomology Another built “sleep consolidation” for AI memory systems inspired by human memory formation Another created persistent multi-agent vault conversations Another turned entire repositories into continuously maintained AI wikis Another built local-first memory systems with audit trails, provenance, graph exports, and MCP integration This is the important part: Karpathy didn’t launch a product. He introduced a pattern. And patterns are what create ecosystems. The same way: • transformers created modern AI • RAG created AI retrieval startups • agents created orchestration frameworks LLM Wikis may create persistent AI memory infrastructure. That’s why this moment feels different. For years, AI systems have been stateless. Now developers are trying to build systems that actually accumulate understanding over time. And once knowledge compounds instead of resetting… …the entire interface layer of AI changes. (Link in comments)

Suryansh Tiwari

141,981 views • 2 months ago

0:28

GARRY TAN PUBLISHED HIS PERSONAL CLAUDE CODE SETUP ON GITHUB. IT HIT 108,000 STARS AND AN 18 YEAR OLD WON A HACKATHON BUILDING A FULL GAME IN 2 HOURS the repo is called gstack. the president of y combinator open sourced his claude code workflow with 23 structured skills most developers treat claude code like smart autocomplete. gstack turns it into a full pipeline for product thinking, architecture, design, qa and docs an 18 year old from bishkek used it to win the cursor hackathon. he built a multiplayer game with computer vision in 1 hour 45 minutes install is 3 commands. git clone the repo, run setup, add the skills to your claude.md. then call /office-hours, /plan-eng-review, /qa, /ship gbrain gives claude persistent memory between sessions. developers report saving 3 to 5 hours a day on routine work bookmark this and read the article below

starmex

94,715 views • 1 month ago

2:57

New short course: LLMs as Operating Systems: Agent Memory, created with Letta, and taught by its founders Charles Packer and Sarah Wooders. An LLM's input context window has limited space. Using a longer input context also costs more and results in slower processing. So, managing what's stored in this context window is important. In the innovative paper MemGPT: Towards LLMs as Operating Systems, its authors (which include the instructors) proposed using an LLM agent to manage this context window. Their system uses a large persistent memory that stores everything that could be included in the input context, and an agent decides what is actually included. Take the example of building a chatbot that needs to remember what's been said earlier in a conversation (perhaps over many days of interaction with a user). As the conversation's length grows, the memory management agent will move information from the input context to a persistent searchable database; summarize information to keep relevant facts in the input context; and restore relevant conversation elements from further back in time. This allows a chatbot to keep what's currently most relevant in its input context memory to generate the next response. When I read the original MemGPT paper, I thought it was an innovative technique for handling memory for LLMs. The open-source Letta framework, which we'll use in this course, makes MemGPT easy to implement. It adds memory to your LLM agents and gives them transparent long-term memory. In detail, you’ll learn: - How to build an agent that can edit its own limited input context memory, using tools and multi-step reasoning - What is a memory hierarchy (an idea from computer operating systems, which use a cache to speed up memory access), and how these ideas apply to managing the LLM input context (where the input context window is a "cache" storing the most relevant information; and an agent decides what to move in and out of this to/from a larger persistent storage system) - How to implement multi-agent collaboration by letting different agents share blocks of memory This course will give you a sophisticated understanding of memory management for LLMs, which is important for chatbots having long conversations, and for complex agentic workflows. Please sign up here!

Andrew Ng

200,788 views • 1 year ago

2:59

Tried out stripe projects this week! built a customer support bot with hermes from Nous Research + supermemory. bot remembers every customer across sessions. the piece worth highlighting, Stripe projects ships a hermes skill that lets the agent auto-provision supermemory itself. ask hermes to build the bot, it runs stripe projects add supermemory/memory. stripe creates the supermemory account, syncs the api key to .env, and bills it on your stripe invoice. and supermemory is one of 30+ providers. databases ( Neon Postgres, Supabase), hosting ( Vercel , Cloudflare), auth ( Clerk), search ( Exa), analytics ( PostHog). one CLI for the whole stack.

Muskan Jain

20,335 views • 1 month ago

3:18

Learn a development pattern to systematically improve the accuracy and reliability of LLM applications in our new short course, Improving Accuracy of LLM Applications, built in partnership with Lamini and Meta, and taught by Lamini’s CEO Sharon Zhou, and Meta’s Senior Director of Partner Engineering, Amit Sangani. (Disclosure: I am an investor in Lamini.) The path to tuning an LLM application can be complex. In this course, you'll learn a systematic sequence of steps for improving accuracy by reducing hallucinations: - Create an evaluation dataset to measure model accuracy - Add prompt engineering and self-reflection - Fine-tune your model including "memory-tuning" which is a new method of embedding facts in an LLM Using the Llama 3-8B parameter model, you will: - Build a text-to-SQL agent with a custom schema and simulate situations where it hallucinates - Understand the difference between instruction fine-tuning, which gives pre-trained LLMs instructions to follow, and memory fine-tuning - See how Performance-Efficient Fine-tuning (PEFT) techniques like Low-Rank Adaptation (LoRA) reduce training time by 100x and Mixture of Memory Experts (MoME) reduces it even further I appreciate Meta releasing the Llama's family of open models -- this course gives an example of the unique type of work that developers can do with such models. Please sign up here:

Andrew Ng

66,435 views • 1 year ago

0:36

🚨 memU bot is live. A better alternative to OpenClaw🦞 (formerly Moltbot / Clawdbot) 👉Get instant access to the memU bot: 🕒 A 24/7 proactive assistant memU bot runs continuously on your machine and works as a proactive assistant. It takes action based on your behavior and context — instead of waiting for explicit commands. 🧠 Highly personal, built for you memU bot learns from your long-term usage and memory, and gradually adapts to your work style and preferences. It becomes your assistant — not a generic AI. ⚡ Very easy to use — download and run No complex setup. No configuration. Even non-technical users can simply download and run memU bot. 🔒 Local-first and secure, with no server dependency memU bot runs locally on your device. Your data never needs to be uploaded to public networks or third-party servers. 💸 Lower LLM token cost (more efficient than OpenClaw🦞) While supporting always-on and proactive behavior, memU bot is designed to reduce LLM calls and token usage — so it runs cheaper than OpenClaw, without sacrificing performance. 🧠 "Always-on" is the real key to a proactive agent. And memory is what gives it true proactivity. With memory, an agent is no longer generic. It becomes personal — shaped by who you are. This is how a user-intention-driven proactive agent is born: before you even issue a command, it can already anticipate what kind of help you’ll need, based on your past, your habits, your context. 🔮 A 24/7 process that can observe 👀, remember 📝, and act ⚡ — not just wait for prompts. 🤖 memU bot is our attempt at a user-intention-driven proactive agent — one that lives beyond the chat box.

memU

818,160 views • 5 months ago

1:22

This is my take on the perfect AI assistant. A Rust-based agentic operating system designed to scale for large Slack and Discord communities. The channel is the ambassador to the human. Branches think. Workers execute. Nothing ever blocks. Meet Spacebot 🟣 The biggest issue with OpenClaw is when it's doing work, it can't talk to you. Spacebot's architecture fixes this by design the conversation layer never touches tools. It delegates thinking to branches and heavy tasks to workers, so it's always responsive even with 100 people talking at once. Dump your memory files, notes, documents and chat histories into a folder — Spacebot turns them into structured memories automatically. Eight typed memory categories, graph associations, hybrid search. Not markdown files. Not vibes in a vector database. Built-in OpenCode workers for deep coding sessions. Browser automation. Brave web search. Cron jobs. A skill system compatible with your existing OpenClaw skills. And a gorgeous control UI at The cortex oversees the whole system — auditing memories, actioning goals and todos. You teach your Spacebot by talking to it. Structure and speed over config files and markdown. Self-hosting is a single Rust binary. Or one-click cloud deploy at This is for teams, communities, and personal assistants. It will blow you away. ⭐️

Jamie Pine

169,264 views • 5 months ago

Live Cam

Video Failed to Load

andy nguyen

Anya Rossi• Live Now

0 Comments

Related Videos