Загрузка видео...

Не удалось загрузить видео

На главную

We analyzed Anthropic’s memory architecture and built something better: a persistent, human-inspectable, and token-efficient memory layer that scales with your projects. Today, it’s OPEN-SOURCE. ByteRover CLI gives agents (like OpenClaw, Claude Code, and Hermes) persistent, structured memory. Built on the exact architecture that became the #1 memory system for...

28,980 просмотров • 3 месяцев назад •via X (Twitter)

Комментарии: 0

Нет доступных комментариев

Здесь появятся комментарии из оригинального поста

Похожие видео

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 просмотров • 3 месяцев назад

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 просмотров • 4 дней назад

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 просмотров • 2 месяцев назад

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 просмотров • 1 год назад

🚨 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 просмотров • 5 месяцев назад