Video yükleniyor...

Video Yüklenemedi

Ana Sayfaya Dön

Martin Keen from IBM just explained the one thing separating "chatbot users" from $300K AI architects > most people use Claude Opus 4.8 as a temporary tool -> the pros build it a permanent memory it's called the CoALA framework. the 4 layers your agent actually needs: > Working...

polydao's profile picture

Mr. Buzzoni

22,090 subscribers

10,442 görüntüleme • 4 ay önce •via X (Twitter)

LIVE

Anya Rossi• Live Now

Private livecam show

0 Yorum

Yorum bulunmuyor

Orijinal gönderinin yorumları burada görünecek

Benzer Videolar

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!
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

162,339 görüntüleme • 6 ay önce

HERMES AGENT LEARNS FROM ITS OWN MISTAKES. UPDATES ITS MEMORY. CREATES ITS OWN SKILLS. NO CLOUD. EVERYTHING STORED LOCALLY. THIS IS HOW THE SELF-IMPROVING LOOP WORKS. most agents start from zero every session. Hermes carries forward what it learned. THREE MEMORY SYSTEMS: 1. PROCEDURAL MEMORY (how to act) stored in ~/.hermes/skills/ as SKILL.md files. when the agent repeats a complex workflow, it saves the procedure as a reusable skill. next time the same task comes up, it follows the skill instead of figuring it out again. you can also create skills explicitly: "create a skill called video-prep that captures how I format my video scripts. spoken english, define jargon inline, no em-dashes, close with a catchphrase." the agent writes the SKILL.md. available as a slash command from that moment. Hermes ships with 90+ skills. the number grows the longer you use it. 2. SEMANTIC MEMORY (durable facts about you) stored in ~/.hermes/memory/memory.md the agent scans conversations for facts worth remembering. preferences, habits, corrections, project details. real example from the video: agent tried to scrape a YouTube channel. URL was wrong. it failed. it updated memory.md with the correct URL pattern so it never makes the same mistake again. you can also save explicitly: "save to memory that my favorite testing framework is pytest" the agent updates memory.md immediately. this file loads into context on every session. the agent knows you better every week. 3. EPISODIC MEMORY (chat history) stored in ~/.hermes/state.db (local SQLite). every conversation. every tool call. every result. searchable with FTS5 full-text search. "search our past sessions. what was the first thing I ever said to you?" the agent queries state.db and finds it. over time, auxiliary models consolidate episodic memory into semantic memory. distilling recurring patterns into durable facts. THE SELF-IMPROVING LOOP: every agent run follows this cycle: → you send a prompt → working memory loads: SOUL.md + memory.md + relevant skills + chat history → agent calls tools (terminal, browser, delegate_task) → agent completes the task, replies to you → AFTER the reply: agent checks "did I learn something worth saving?" → if yes: updates memory.md or creates a new skill → next session starts smarter than the last this happens automatically. you don't ask the agent to learn. it decides what to remember on its own. WHAT MAKES THIS DIFFERENT FROM CLAUDE CODE: Claude Code has memory too. but Hermes stores everything locally. no cloud. your data never leaves your machine. Claude Code doesn't auto-create skills from experience. Hermes turns repeated workflows into reusable procedures. Claude Code memory is instruction-based. Hermes memory is conversational and self-updating. over months of usage, Hermes builds a knowledge base of your preferences, your projects, your mistakes, and the procedures that work for your specific workflow. the agent that remembers your birthday also remembers why your last deploy failed. NO EMBEDDINGS. PLAIN TEXT. Hermes does not use embeddings or RAG for memory. skill and memory search runs on plain text keyword matching. simpler. faster. no vector database to maintain. works entirely offline on your local machine. DELEGATE TO CLAUDE CODE: Hermes can spawn a sub-agent that runs Claude Code in headless mode: "spawn a sub-agent using Claude CLI to build a Python script that fetches the top 5 Hacker News stories to markdown." Hermes delegates. Claude Code writes the code. result returns to Hermes. Hermes runs the script and delivers the output. use Hermes for orchestration. use Claude Code for heavy coding. both tools. not competitors. WHAT HERMES DOES NOT HAVE: no built-in eval or LMOps system. no LangSmith, no LangFuse integration out of the box. trajectory export and logs exist but there is no automated quality tracking. if you need eval, build it yourself or connect external tools. the loop is self-improving. measuring how well it improves is on you. comment LOOP and I'll send you the configs that control how fast Hermes learns and what it remembers. memory limits, skill auto-creation triggers, and the auxiliary model that runs the learning. Replace your entire team with 8 hermes agents👇
20:54

HERMES AGENT LEARNS FROM ITS OWN MISTAKES. UPDATES ITS MEMORY. CREATES ITS OWN SKILLS. NO CLOUD. EVERYTHING STORED LOCALLY. THIS IS HOW THE SELF-IMPROVING LOOP WORKS. most agents start from zero every session. Hermes carries forward what it learned. THREE MEMORY SYSTEMS: 1. PROCEDURAL MEMORY (how to act) stored in ~/.hermes/skills/ as SKILL.md files. when the agent repeats a complex workflow, it saves the procedure as a reusable skill. next time the same task comes up, it follows the skill instead of figuring it out again. you can also create skills explicitly: "create a skill called video-prep that captures how I format my video scripts. spoken english, define jargon inline, no em-dashes, close with a catchphrase." the agent writes the SKILL.md. available as a slash command from that moment. Hermes ships with 90+ skills. the number grows the longer you use it. 2. SEMANTIC MEMORY (durable facts about you) stored in ~/.hermes/memory/memory.md the agent scans conversations for facts worth remembering. preferences, habits, corrections, project details. real example from the video: agent tried to scrape a YouTube channel. URL was wrong. it failed. it updated memory.md with the correct URL pattern so it never makes the same mistake again. you can also save explicitly: "save to memory that my favorite testing framework is pytest" the agent updates memory.md immediately. this file loads into context on every session. the agent knows you better every week. 3. EPISODIC MEMORY (chat history) stored in ~/.hermes/state.db (local SQLite). every conversation. every tool call. every result. searchable with FTS5 full-text search. "search our past sessions. what was the first thing I ever said to you?" the agent queries state.db and finds it. over time, auxiliary models consolidate episodic memory into semantic memory. distilling recurring patterns into durable facts. THE SELF-IMPROVING LOOP: every agent run follows this cycle: → you send a prompt → working memory loads: SOUL.md + memory.md + relevant skills + chat history → agent calls tools (terminal, browser, delegate_task) → agent completes the task, replies to you → AFTER the reply: agent checks "did I learn something worth saving?" → if yes: updates memory.md or creates a new skill → next session starts smarter than the last this happens automatically. you don't ask the agent to learn. it decides what to remember on its own. WHAT MAKES THIS DIFFERENT FROM CLAUDE CODE: Claude Code has memory too. but Hermes stores everything locally. no cloud. your data never leaves your machine. Claude Code doesn't auto-create skills from experience. Hermes turns repeated workflows into reusable procedures. Claude Code memory is instruction-based. Hermes memory is conversational and self-updating. over months of usage, Hermes builds a knowledge base of your preferences, your projects, your mistakes, and the procedures that work for your specific workflow. the agent that remembers your birthday also remembers why your last deploy failed. NO EMBEDDINGS. PLAIN TEXT. Hermes does not use embeddings or RAG for memory. skill and memory search runs on plain text keyword matching. simpler. faster. no vector database to maintain. works entirely offline on your local machine. DELEGATE TO CLAUDE CODE: Hermes can spawn a sub-agent that runs Claude Code in headless mode: "spawn a sub-agent using Claude CLI to build a Python script that fetches the top 5 Hacker News stories to markdown." Hermes delegates. Claude Code writes the code. result returns to Hermes. Hermes runs the script and delivers the output. use Hermes for orchestration. use Claude Code for heavy coding. both tools. not competitors. WHAT HERMES DOES NOT HAVE: no built-in eval or LMOps system. no LangSmith, no LangFuse integration out of the box. trajectory export and logs exist but there is no automated quality tracking. if you need eval, build it yourself or connect external tools. the loop is self-improving. measuring how well it improves is on you. comment LOOP and I'll send you the configs that control how fast Hermes learns and what it remembers. memory limits, skill auto-creation triggers, and the auxiliary model that runs the learning. Replace your entire team with 8 hermes agents👇

YanXbt

23,088 görüntüleme • 3 ay önce

Boris Cherny gave Claude Code a memory that has no database, no indexing, no setup, and 80% of Anthropic runs on it a CLAUDE.md "gets automatically read into context at the start of every session" 12:48 - CLAUDE.md loads into memory every session 13:15 - Keep memory short or it burns your context 15:48 - Memory stacks from you to your whole company 17:30 - The memory command shows what Claude remembers 19:33 - Hit pound and Claude remembers it forever the whole memory layer is files → drop a CLAUDE.md in your repo and Claude reads it in on every session → nest more in subfolders and it pulls them only where it works → stack them personal to project to enterprise so one config serves the whole team → hit the pound key mid task and Claude writes the new fact into memory itself the best coding agent's memory was never a database, it was markdown you can open and edit
27:26

Boris Cherny gave Claude Code a memory that has no database, no indexing, no setup, and 80% of Anthropic runs on it a CLAUDE.md "gets automatically read into context at the start of every session" 12:48 - CLAUDE.md loads into memory every session 13:15 - Keep memory short or it burns your context 15:48 - Memory stacks from you to your whole company 17:30 - The memory command shows what Claude remembers 19:33 - Hit pound and Claude remembers it forever the whole memory layer is files → drop a CLAUDE.md in your repo and Claude reads it in on every session → nest more in subfolders and it pulls them only where it works → stack them personal to project to enterprise so one config serves the whole team → hit the pound key mid task and Claude writes the new fact into memory itself the best coding agent's memory was never a database, it was markdown you can open and edit

NO1ennn

13,015 görüntüleme • 2 ay önce

The reason your AI gives generic answers isn't the model. It's that your company's knowledge lives in 12 different tools and your agent can't see any of it. So here's how to build a context database your agents can actually use: 1) Pull it in: - Slack, email, meetings, docs, tickets - Auto-collected on a schedule into one place. 2) Clean it up. - An agent files what matters and drops the noise, so your brain doesn't bloat. 3) Store it as memory. - Folders of files your agents read from and write back to as they learn. 4) Point your agents at it. - Now they draft, build, and ship with full context instead of guessing. Same model. Same agent. The difference is whether it can understand your company or not. Build the database once. Everything downstream gets smarter.
8:17

The reason your AI gives generic answers isn't the model. It's that your company's knowledge lives in 12 different tools and your agent can't see any of it. So here's how to build a context database your agents can actually use: 1) Pull it in: - Slack, email, meetings, docs, tickets - Auto-collected on a schedule into one place. 2) Clean it up. - An agent files what matters and drops the noise, so your brain doesn't bloat. 3) Store it as memory. - Folders of files your agents read from and write back to as they learn. 4) Point your agents at it. - Now they draft, build, and ship with full context instead of guessing. Same model. Same agent. The difference is whether it can understand your company or not. Build the database once. Everything downstream gets smarter.

The Startup Ideas Podcast (SIP) 🧃

13,666 görüntüleme • 4 ay önce

A 13-PAGE BREAKDOWN OF AGENT MEMORY THAT CUTS TOKEN COST BY 90% your agent reads the same 12 files every morning reaches the same conclusions and charges you for it again the model got 10x smarter in two years it still forgets everything the second a session ends five layers fix that: 1. working memory - what it sees right now > the context window > when it fills, the old context drops out > most agents live here and never leave 2. episodic memory - what happened > the full interaction log, timestamped > the deploy that died tuesday at 3am over a typo stays remembered > you explain it once 3. semantic memory - what is true > facts, entities and relationships in a knowledge graph > "this user prefers TypeScript" survives the session 4. procedural memory - how to do things > three approaches tried, one worked > that one becomes a reusable skill > the next run starts there 5. forgetting - what to delete > an agent that remembers everything collects contradictions > you move cities, it keeps recommending the old restaurants the numbers: > Mem0 - 1,800 tokens per query instead of 26,000 > 91% lower latency > Snowflake - one ontology layer, 20% more accuracy, 39% fewer tool calls memory pays for itself on day one the layer nobody builds is the forgetting engine it decides whether the other four stay worth trusting full 13-page breakdown below 👇
0:24

A 13-PAGE BREAKDOWN OF AGENT MEMORY THAT CUTS TOKEN COST BY 90% your agent reads the same 12 files every morning reaches the same conclusions and charges you for it again the model got 10x smarter in two years it still forgets everything the second a session ends five layers fix that: 1. working memory - what it sees right now > the context window > when it fills, the old context drops out > most agents live here and never leave 2. episodic memory - what happened > the full interaction log, timestamped > the deploy that died tuesday at 3am over a typo stays remembered > you explain it once 3. semantic memory - what is true > facts, entities and relationships in a knowledge graph > "this user prefers TypeScript" survives the session 4. procedural memory - how to do things > three approaches tried, one worked > that one becomes a reusable skill > the next run starts there 5. forgetting - what to delete > an agent that remembers everything collects contradictions > you move cities, it keeps recommending the old restaurants the numbers: > Mem0 - 1,800 tokens per query instead of 26,000 > 91% lower latency > Snowflake - one ontology layer, 20% more accuracy, 39% fewer tool calls memory pays for itself on day one the layer nobody builds is the forgetting engine it decides whether the other four stay worth trusting full 13-page breakdown below 👇

Annatar.md

31,541 görüntüleme • 21 gün önce

OpenClaw's memory out of the box sucks With this simple Obsidian system, it's actually awesome In this video I go over using Obsidian as a memory layer for your AI agent, making it SO much more smarter than it is now If you use OpenClaw or Hermes, you need to watch this:
10:57

OpenClaw's memory out of the box sucks With this simple Obsidian system, it's actually awesome In this video I go over using Obsidian as a memory layer for your AI agent, making it SO much more smarter than it is now If you use OpenClaw or Hermes, you need to watch this:

Alex Finn

89,897 görüntüleme • 6 ay önce

She is 18 built an AI agent with live memory and Anthropic bought it for $2.2M - and at Stanford shared how to repeat it from scratch: 00:40 - how Opus 5 builds an agent with live memory from scratch in 60 minutes 18:44 - the live memory system replaced 500 Anthropic engineers 39:42 - from first agent to $2.2M from Anthropic after watching I gave Opus 5 one prompt - an agent with live memory appeared in an hour I sent an invoice to Anthropic and got a check for $120k. save & watch - the article below shows how to build an AI agent with live memory and sell it to Anthropic for $2.2M.
1:22:18

She is 18 built an AI agent with live memory and Anthropic bought it for $2.2M - and at Stanford shared how to repeat it from scratch: 00:40 - how Opus 5 builds an agent with live memory from scratch in 60 minutes 18:44 - the live memory system replaced 500 Anthropic engineers 39:42 - from first agent to $2.2M from Anthropic after watching I gave Opus 5 one prompt - an agent with live memory appeared in an hour I sent an invoice to Anthropic and got a check for $120k. save & watch - the article below shows how to build an AI agent with live memory and sell it to Anthropic for $2.2M.

Noisy

88,300 görüntüleme • 27 gün önce

HERMES AGENT IS THE MOST POWERFUL OPEN SOURCE AI AGENT FRAMEWORK AVAILABLE RIGHT NOW — AND MOST PEOPLE HAVE NO IDEA HOW TO USE IT PROPERLY. This masterclass fixes that completely. From zero to a fully operational autonomous agent system in one sitting. Installation. Skills. Memory. MCP servers. Scheduler. Multi-agent operations. Every section builds on the previous one. The people who read this this weekend will have a production-ready autonomous agent operation running by Monday. Read this and bookmark it now.
1:05

HERMES AGENT IS THE MOST POWERFUL OPEN SOURCE AI AGENT FRAMEWORK AVAILABLE RIGHT NOW — AND MOST PEOPLE HAVE NO IDEA HOW TO USE IT PROPERLY. This masterclass fixes that completely. From zero to a fully operational autonomous agent system in one sitting. Installation. Skills. Memory. MCP servers. Scheduler. Multi-agent operations. Every section builds on the previous one. The people who read this this weekend will have a production-ready autonomous agent operation running by Monday. Read this and bookmark it now.

CyrilXBT

34,637 görüntüleme • 4 ay önce

Every AI agent I've used has the same bug: It forgets everything. Not after a month. Sometimes after a single session. This week I tested Memanto, an open-source memory companion for AI agents, and it completely changed how I think about agent workflows. 👇 Moorcheh.ai #ad
6:20

Every AI agent I've used has the same bug: It forgets everything. Not after a month. Sometimes after a single session. This week I tested Memanto, an open-source memory companion for AI agents, and it completely changed how I think about agent workflows. 👇 Moorcheh.ai #ad

Kaitee

37,566 görüntüleme • 4 ay önce

New short course: Long-Term Agentic Memory with LangGraph. Learn to build an agent with long-term memory in this course developed in collaboration with taught by its Co-Founder and CEO, Harrison Chase! Personal assistance and productivity tasks have become important use cases for agents. An important feature of an AI assistant, such as a coding or calendar assistant, is its ability to keep improving over time from its experience. Agent memory is the key capability that enables this. To add memory to an agent, you must first figure out what to store and what to retrieve when it is time to use the information. Additionally, you’ll have to decide when to update the stored information. For example, you might update in each iteration loop of the agent or perform updates in the background, with a helper agent. In this course, you will learn a mental framework to build agents with long-term memory. You'll create a useful email assistant that can respond, ignore, and notify using writing, scheduling, and memory-management tools. You’ll develop your agent's memory by adding facts to its memory store, provide examples to learn the user's preferences, and optimize system prompts to evolve instructions based on previous responses. In detail, you’ll: - Learn how the three types of memory--semantic, episodic, and procedural–and the two update mechanisms–via hot path and in the background–apply to your agents. - Build an email agent with writing, scheduling, and availability tools, along with a router that triages incoming email and handles it accordingly by ignoring, responding, or notifying the user. - Add tools to your email agent that allow it to operate on semantic memory by learning facts about the user, storing them in a long-term memory store, and searching over them in future interactions. - Incorporate episodic memory, in the form of few-shot examples, in the triage step of your agents to help them learn and update user preferences. - Add procedural memory as system prompts, optimized with feedback to improve the instructions the agent follows. Learn how to approach memory in agents, and start building agents with long-term memory with LangGraph! Please sign up here:
2:06

New short course: Long-Term Agentic Memory with LangGraph. Learn to build an agent with long-term memory in this course developed in collaboration with taught by its Co-Founder and CEO, Harrison Chase! Personal assistance and productivity tasks have become important use cases for agents. An important feature of an AI assistant, such as a coding or calendar assistant, is its ability to keep improving over time from its experience. Agent memory is the key capability that enables this. To add memory to an agent, you must first figure out what to store and what to retrieve when it is time to use the information. Additionally, you’ll have to decide when to update the stored information. For example, you might update in each iteration loop of the agent or perform updates in the background, with a helper agent. In this course, you will learn a mental framework to build agents with long-term memory. You'll create a useful email assistant that can respond, ignore, and notify using writing, scheduling, and memory-management tools. You’ll develop your agent's memory by adding facts to its memory store, provide examples to learn the user's preferences, and optimize system prompts to evolve instructions based on previous responses. In detail, you’ll: - Learn how the three types of memory--semantic, episodic, and procedural–and the two update mechanisms–via hot path and in the background–apply to your agents. - Build an email agent with writing, scheduling, and availability tools, along with a router that triages incoming email and handles it accordingly by ignoring, responding, or notifying the user. - Add tools to your email agent that allow it to operate on semantic memory by learning facts about the user, storing them in a long-term memory store, and searching over them in future interactions. - Incorporate episodic memory, in the form of few-shot examples, in the triage step of your agents to help them learn and update user preferences. - Add procedural memory as system prompts, optimized with feedback to improve the instructions the agent follows. Learn how to approach memory in agents, and start building agents with long-term memory with LangGraph! Please sign up here:

Andrew Ng

132,058 görüntüleme • 1 yıl önce

Introducing Memory 101 🧠 Every ai tool you use is a goldfish. brilliant for one chat, close the tab and it forgets you completely. memory is the most underbuilt layer in ai right now. so we're explaining how it actually works, one episode at a time. coming up: → rag vs memory, why most "ai memory" is just search → the 5 things real memory needs: facts, profiles, graphs, time, forgetting → why good memory has to forget things follow along!
0:50

Introducing Memory 101 🧠 Every ai tool you use is a goldfish. brilliant for one chat, close the tab and it forgets you completely. memory is the most underbuilt layer in ai right now. so we're explaining how it actually works, one episode at a time. coming up: → rag vs memory, why most "ai memory" is just search → the 5 things real memory needs: facts, profiles, graphs, time, forgetting → why good memory has to forget things follow along!

supermemory

17,235 görüntüleme • 3 ay önce

MICROSOFT TRIED TO BUY IT. HARVARD AND THREE US UNIVERSITIES RELEASED IT FOR FREE a team from Harvard, Michigan State, Minnesota, and Georgia ran the first hard study on how agent memory behaves over time. the finding is uncomfortab they call it the "experience-following property": when a new task looks like a memory the agent pulls up, its answer copies that memory's answer almost 1:1 (correlation up to 0.95). the agent isn't reasoning - it's imitating that breaks in two ways: > error propagation - one wrong memory repeats on every similar task after it > misaligned replay - "successful" past runs turn out low-value or misleading when reused so "just add more memory" quietly makes agents worse. what fixed it: > store only high-quality experiences, not everything > use future task outcomes as free labels to delete low-value memories > pair selective adding with utility-based deletion the payoff: ~10% absolute accuracy gains, a cleaner memory bank, and agents stable under distribution shift no company owns this. they dropped the whole thing open-source, for free bookmark this. the next edge in AI agents isn't more memory - it's cleaner memory
0:23

MICROSOFT TRIED TO BUY IT. HARVARD AND THREE US UNIVERSITIES RELEASED IT FOR FREE a team from Harvard, Michigan State, Minnesota, and Georgia ran the first hard study on how agent memory behaves over time. the finding is uncomfortab they call it the "experience-following property": when a new task looks like a memory the agent pulls up, its answer copies that memory's answer almost 1:1 (correlation up to 0.95). the agent isn't reasoning - it's imitating that breaks in two ways: > error propagation - one wrong memory repeats on every similar task after it > misaligned replay - "successful" past runs turn out low-value or misleading when reused so "just add more memory" quietly makes agents worse. what fixed it: > store only high-quality experiences, not everything > use future task outcomes as free labels to delete low-value memories > pair selective adding with utility-based deletion the payoff: ~10% absolute accuracy gains, a cleaner memory bank, and agents stable under distribution shift no company owns this. they dropped the whole thing open-source, for free bookmark this. the next edge in AI agents isn't more memory - it's cleaner memory

NO1ennn

27,999 görüntüleme • 2 ay önce

Ex-Google engineer explains how to build memory for self-improving AI agents in 12 minutes. procedural (how to act / skills) + semantic (durable facts / profile) + episodic (dated events / chat history). Memory is an important part of an agentic loop. Memory + loops + harness + evals = self-improving agent system. This is better than $500 paid courses on the internet - in under 12 minutes. Watch it today, then save the detailed guide on building agent memory from scratch
11:54

Ex-Google engineer explains how to build memory for self-improving AI agents in 12 minutes. procedural (how to act / skills) + semantic (durable facts / profile) + episodic (dated events / chat history). Memory is an important part of an agentic loop. Memory + loops + harness + evals = self-improving agent system. This is better than $500 paid courses on the internet - in under 12 minutes. Watch it today, then save the detailed guide on building agent memory from scratch

Codez

90,000 görüntüleme • 3 ay önce

Engineer runs a Kimi K3 memory layer that costs $11 a month and remembers what a $500,000 vector database keeps losing. No embeddings. Four nodes and one rule about what's allowed to be forgotten. He published the whole schema. His version starts from the opposite idea. Memory is not a pile you search. It's a set of claims that expire unless something keeps paying to keep them. Four nodes. Every memory carries a clock someone has to reset: > WRITER - stores a fact with the reason it mattered, never raw text > DECAY - ages every memory down. Silence is deletion > RENEWER - only re-lifts a memory the model actually used again > GRAVE - holds what died, and why nobody reached for it Three nodes keep memory alive. One keeps the dead ones. Recall isn't storage here. It's rent a fact has to keep earning. That's the entire design. When everything is remembered forever, the useful and the stale retrieve identically. He replayed two months of agent context. 90,000 stored facts. 71,000 never retrieved once. The vector store returned all of them on similarity. Similarity graded closeness. Nobody graded whether the memory was ever right. Everyone else stuffs more into the context window and calls it memory. He built a layer that lets a fact die unless it keeps proving itself. The cost isn't storage. It's finding out how much of what your agent "knows" it has never once used. The article below is the full build - node prompts, the decay curve, the renewal rule. Save it. You'll want it open in the other tab.
0:40

Engineer runs a Kimi K3 memory layer that costs $11 a month and remembers what a $500,000 vector database keeps losing. No embeddings. Four nodes and one rule about what's allowed to be forgotten. He published the whole schema. His version starts from the opposite idea. Memory is not a pile you search. It's a set of claims that expire unless something keeps paying to keep them. Four nodes. Every memory carries a clock someone has to reset: > WRITER - stores a fact with the reason it mattered, never raw text > DECAY - ages every memory down. Silence is deletion > RENEWER - only re-lifts a memory the model actually used again > GRAVE - holds what died, and why nobody reached for it Three nodes keep memory alive. One keeps the dead ones. Recall isn't storage here. It's rent a fact has to keep earning. That's the entire design. When everything is remembered forever, the useful and the stale retrieve identically. He replayed two months of agent context. 90,000 stored facts. 71,000 never retrieved once. The vector store returned all of them on similarity. Similarity graded closeness. Nobody graded whether the memory was ever right. Everyone else stuffs more into the context window and calls it memory. He built a layer that lets a fact die unless it keeps proving itself. The cost isn't storage. It's finding out how much of what your agent "knows" it has never once used. The article below is the full build - node prompts, the decay curve, the renewal rule. Save it. You'll want it open in the other tab.

wast3

67,778 görüntüleme • 1 ay önce

THIS GUY BUILT AN AUTONOMOUS AI AGENT OUT OF CLAUDE CODE + OBSIDIAN and this is way more interesting than another “use AI to take notes” demo the trick is simple: Obsidian is not the writing app here. it becomes the agent’s memory, task board, and context folder. Claude Code is not just answering prompts. it reads the vault, edits files, follows instructions, and keeps moving through the work like a junior operator with a filesystem. the reusable setup looks like this: 1. create an Obsidian vault for one project 2. keep goals, rules, tasks, decisions, and references as markdown files 3. point Claude Code at the folder 4. give it a clear operating loop: read context → choose next task → execute → write back what changed 5. use the notes as persistent memory instead of re-explaining the project every chat that’s the part people miss. the “agent” is not magic. it’s the boring combination of: - local files - explicit rules - task state - write access - a model that can run through the repo/vault Obsidian makes the memory human-readable. Claude Code makes the memory executable. that combo is why the video worked: it turns a notes app into an operating surface for actual work. best use cases: - content systems - research vaults - coding projects - client ops docs - personal knowledge bases that need actions, not just storage the caveat: if your vault is messy, your agent becomes messy too. folders, naming, “done” criteria, and forbidden actions matter more than the prompt. but once the structure is clean, this is one of the easiest ways to build an agent that remembers what happened yesterday without paying for a full custom app.
10:19

THIS GUY BUILT AN AUTONOMOUS AI AGENT OUT OF CLAUDE CODE + OBSIDIAN and this is way more interesting than another “use AI to take notes” demo the trick is simple: Obsidian is not the writing app here. it becomes the agent’s memory, task board, and context folder. Claude Code is not just answering prompts. it reads the vault, edits files, follows instructions, and keeps moving through the work like a junior operator with a filesystem. the reusable setup looks like this: 1. create an Obsidian vault for one project 2. keep goals, rules, tasks, decisions, and references as markdown files 3. point Claude Code at the folder 4. give it a clear operating loop: read context → choose next task → execute → write back what changed 5. use the notes as persistent memory instead of re-explaining the project every chat that’s the part people miss. the “agent” is not magic. it’s the boring combination of: - local files - explicit rules - task state - write access - a model that can run through the repo/vault Obsidian makes the memory human-readable. Claude Code makes the memory executable. that combo is why the video worked: it turns a notes app into an operating surface for actual work. best use cases: - content systems - research vaults - coding projects - client ops docs - personal knowledge bases that need actions, not just storage the caveat: if your vault is messy, your agent becomes messy too. folders, naming, “done” criteria, and forbidden actions matter more than the prompt. but once the structure is clean, this is one of the easiest ways to build an agent that remembers what happened yesterday without paying for a full custom app.

kocer

30,403 görüntüleme • 3 ay önce

Creator of agent loops: "Anthropic also using my agent systems formula and still the biggest mistake in agents: is skipping Graphs" his 3 rules for every agent: rule 1 → loop it, don't run once - think, act, observe, repeat - cut the context and it forgets why it started rule 2 → an agent is memory + tools + reasoning - drop one and it breaks rule 3 → stop fine-tuning the model - the real alpha is the infrastructure around it the formula behind every AI agent - explained by the one who wrote it one agent → a loop → a graph of loops → a system that never forgets watch & bookmark - then read how to wire it into a graph ↓
45:37

Creator of agent loops: "Anthropic also using my agent systems formula and still the biggest mistake in agents: is skipping Graphs" his 3 rules for every agent: rule 1 → loop it, don't run once - think, act, observe, repeat - cut the context and it forgets why it started rule 2 → an agent is memory + tools + reasoning - drop one and it breaks rule 3 → stop fine-tuning the model - the real alpha is the infrastructure around it the formula behind every AI agent - explained by the one who wrote it one agent → a loop → a graph of loops → a system that never forgets watch & bookmark - then read how to wire it into a graph ↓

codila

23,915 görüntüleme • 2 ay önce

Google just dropped the best 1-hour course on Graph Engineering: from one agent to Loops and Graphs 00:00 - your first AI agent 08:24 - build agent memory 28:34 - agentic loops 40:04 - how to build MCP 1:00:22 - graph engineering free, and the best thing on graph engineering I have come across Prompts → Agents → Loops → Graphs most people will stop after the memory chapter and call it a system he saves the last twenty minutes for the layer above all of it same model, same tokens, completely different week watch it today the step-by-step guide is below, save it while it is still early ↓
1:13:16

Google just dropped the best 1-hour course on Graph Engineering: from one agent to Loops and Graphs 00:00 - your first AI agent 08:24 - build agent memory 28:34 - agentic loops 40:04 - how to build MCP 1:00:22 - graph engineering free, and the best thing on graph engineering I have come across Prompts → Agents → Loops → Graphs most people will stop after the memory chapter and call it a system he saves the last twenty minutes for the layer above all of it same model, same tokens, completely different week watch it today the step-by-step guide is below, save it while it is still early ↓

Residual

95,395 görüntüleme • 17 gün önce

ANTHROPIC KILLED THE VECTOR DATABASE AND REPLACED IT WITH A FOLDER no embeddings. no black-box retrieval. no special memory tools. the agent just reads and writes a folder the insight: your agent already knows how to use a filesystem. so Anthropic made long-term memory a directory of small markdown files, mounted straight into the agent's sandbox at /mnt/memory the agent manages it with the tools it already has, bash, read, write, edit, grep, and Anthropic auto-injects a note into the system prompt so the agent always knows the memory is there and where to look the result: > every change is an immutable version: full audit trail, point-in-time recovery, redaction > read-only or read-write per store, so many agents can safely share one memory > workspace-scoped and persistent, memory that survives every session end most teams bolt on a vector DB and pray retrieval works. Anthropic went the opposite way: compiled knowledge as plain, human-readable files you can open, diff, and edit yourself and there's a second layer. Anthropic's "Dreaming" runs offline, reviews past sessions and the store, and rewrites it into a cleaner, higher-signal version. the agent literally consolidates memory in its sleep. bookmark this. the most production-grade agent memory right now is just a well-organized folder, and Anthropic proved it.
0:50

ANTHROPIC KILLED THE VECTOR DATABASE AND REPLACED IT WITH A FOLDER no embeddings. no black-box retrieval. no special memory tools. the agent just reads and writes a folder the insight: your agent already knows how to use a filesystem. so Anthropic made long-term memory a directory of small markdown files, mounted straight into the agent's sandbox at /mnt/memory the agent manages it with the tools it already has, bash, read, write, edit, grep, and Anthropic auto-injects a note into the system prompt so the agent always knows the memory is there and where to look the result: > every change is an immutable version: full audit trail, point-in-time recovery, redaction > read-only or read-write per store, so many agents can safely share one memory > workspace-scoped and persistent, memory that survives every session end most teams bolt on a vector DB and pray retrieval works. Anthropic went the opposite way: compiled knowledge as plain, human-readable files you can open, diff, and edit yourself and there's a second layer. Anthropic's "Dreaming" runs offline, reviews past sessions and the store, and rewrites it into a cleaner, higher-signal version. the agent literally consolidates memory in its sleep. bookmark this. the most production-grade agent memory right now is just a well-organized folder, and Anthropic proved it.

NO1ennn

13,359 görüntüleme • 2 ay önce

AI memory is getting f...cking illegal 10 open-source GitHub projects that stop agents from starting from zero EVERY new session 01 Mem0 ▸ → 66K+ stars 02 Hindsight ▸ → retain → recall → reflect 03 memU ▸ TURN MEMORY INTO KNOWLEDGE 04 Cognee ▸ → documents + code + conversations → knowledge graph 05 Graphiti ▸ → remembers how facts change over time 06 OpenViking ▸ MAKE THE AGENT STATEFUL 07 Letta ▸ → memory + identity across sessions 08 Letta Code ▸ REMEMBER ACROSS THE STACK 09 OpenMemory ▸ 10 Agent Memory Benchmark ▸ the loop: experience → remember → connect → retrieve → act → update 3 builds I'd actually test: coding: Hindsight → Cognee → Letta Code personal agent: Mem0 → Graphiti → Letta company brain: Cognee → Graphiti → Hindsight and this is where the sh...t gets interesting: bigger context isn't the same as memory a model can hold 1M tokens and still meet you for the first time every morning these projects change that save this before your agent forgets it ⭣
0:36

AI memory is getting f...cking illegal 10 open-source GitHub projects that stop agents from starting from zero EVERY new session 01 Mem0 ▸ → 66K+ stars 02 Hindsight ▸ → retain → recall → reflect 03 memU ▸ TURN MEMORY INTO KNOWLEDGE 04 Cognee ▸ → documents + code + conversations → knowledge graph 05 Graphiti ▸ → remembers how facts change over time 06 OpenViking ▸ MAKE THE AGENT STATEFUL 07 Letta ▸ → memory + identity across sessions 08 Letta Code ▸ REMEMBER ACROSS THE STACK 09 OpenMemory ▸ 10 Agent Memory Benchmark ▸ the loop: experience → remember → connect → retrieve → act → update 3 builds I'd actually test: coding: Hindsight → Cognee → Letta Code personal agent: Mem0 → Graphiti → Letta company brain: Cognee → Graphiti → Hindsight and this is where the sh...t gets interesting: bigger context isn't the same as memory a model can hold 1M tokens and still meet you for the first time every morning these projects change that save this before your agent forgets it ⭣

Lummox

328,549 görüntüleme • 14 gün önce

THIS GUY CONNECTED HIS AI AGENTS TO HIS OBSIDIAN AND BUILT A BRAIN THAT LEARNS ON ITS OWN. HERE'S HOW TO BUILD IT Obsidian is just markdown files sitting in a folder. That turns out to be the perfect memory for an AI agent, because an agent can read and write those files directly. He wired his agents into the vault so they pull context from it, do the work, and write what they learned back. The notes aren't the point. The loop is, and it gets sharper every cycle How to build it: 1. Point an agent at your vault. The fastest way, no plugins, no API keys: open a terminal and run npx obsidian-mcp /path/to/your/vault. That exposes your Obsidian folder to Claude as a tool it can read, search, and write to. Add it to your Claude Code or Cowork config and restart 2. Confirm it can see the brain. Ask it: "list the notes in my vault and summarize what's in them." If it reads them back, the connection is live. Now it starts every task with everything the vault already holds instead of from zero 3. Give each agent one job and a write-back rule. Tell it: "research this, then save what you found as a new note in /brain with links to related notes." One agent researches, one summarizes, one plans. Each writes its output back into the vault 4. Close the loop. Add one line to every agent's instructions: "read /brain before starting, write your result back when done." Now each task leaves the vault richer, and the next run reads that before it works. It compounds instead of resetting 5. You only steer. Review what the brain produces, point it at the next thing. The agents handle the reading, writing, and connecting The edge isn't better notes. It's a brain that feeds itself, so the work gets sharper every cycle instead of starting over Bookmark this
0:24

THIS GUY CONNECTED HIS AI AGENTS TO HIS OBSIDIAN AND BUILT A BRAIN THAT LEARNS ON ITS OWN. HERE'S HOW TO BUILD IT Obsidian is just markdown files sitting in a folder. That turns out to be the perfect memory for an AI agent, because an agent can read and write those files directly. He wired his agents into the vault so they pull context from it, do the work, and write what they learned back. The notes aren't the point. The loop is, and it gets sharper every cycle How to build it: 1. Point an agent at your vault. The fastest way, no plugins, no API keys: open a terminal and run npx obsidian-mcp /path/to/your/vault. That exposes your Obsidian folder to Claude as a tool it can read, search, and write to. Add it to your Claude Code or Cowork config and restart 2. Confirm it can see the brain. Ask it: "list the notes in my vault and summarize what's in them." If it reads them back, the connection is live. Now it starts every task with everything the vault already holds instead of from zero 3. Give each agent one job and a write-back rule. Tell it: "research this, then save what you found as a new note in /brain with links to related notes." One agent researches, one summarizes, one plans. Each writes its output back into the vault 4. Close the loop. Add one line to every agent's instructions: "read /brain before starting, write your result back when done." Now each task leaves the vault richer, and the next run reads that before it works. It compounds instead of resetting 5. You only steer. Review what the brain produces, point it at the next thing. The agents handle the reading, writing, and connecting The edge isn't better notes. It's a brain that feeds itself, so the work gets sharper every cycle instead of starting over Bookmark this

Yarchi

58,643 görüntüleme • 4 ay önce