<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Walrus Protocol - Medium]]></title>
        <description><![CDATA[News and product updates from Walrus, the Verifiable Data Platform for AI builders. Created by the ex-Meta engineers behind Sui. - Medium]]></description>
        <link>https://medium.com/walrus-protocol?source=rss----6f872fb399e0---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Walrus Protocol - Medium</title>
            <link>https://medium.com/walrus-protocol?source=rss----6f872fb399e0---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 21:45:41 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/walrus-protocol" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[What Is Data Verifiability, and Why Does It Matter for AI?]]></title>
            <link>https://medium.com/walrus-protocol/what-is-data-verifiability-and-why-does-it-matter-for-ai-99f3860ca4bc?source=rss----6f872fb399e0---4</link>
            <guid isPermaLink="false">https://medium.com/p/99f3860ca4bc</guid>
            <category><![CDATA[data-verification]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[tech]]></category>
            <dc:creator><![CDATA[Jessie Mongeon]]></dc:creator>
            <pubDate>Thu, 05 Nov 2026 23:30:16 GMT</pubDate>
            <atom:updated>2026-11-05T23:30:15.014Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Verifiability lets you independently confirm your stored data is unaltered and available, without taking a provider’s word for it.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kQAOXdTAUI1QY-KO83jSkg.jpeg" /></figure><p><strong>Data verifiability</strong> is the ability to independently confirm that stored data remains unaltered and available, without relying on the provider’s own records or assurances. It is a property of the system itself, not a simple promise. Walrus is the data platform built for the demands of AI with verifiability built in, so confirmation doesn’t depend on trusting any single operator.</p><h3>Key takeaways</h3><ul><li>Data verifiability lets you confirm integrity and availability independently of the provider.</li><li>Encryption protects <em>who can read</em> data; verifiability confirms <em>whether the data itself is intact</em>. They solve different problems, and neither substitutes for the other.</li><li><a href="https://console.walrus.xyz/?utm_campaign=blog_content&amp;utm_source=blog&amp;utm_medium=organic">Walrus Console</a>, built on Walrus, lets developers <strong>confirm retrieved data matches what they stored and remains available.</strong></li></ul><p>An AI agent doesn’t stop to ask whether the data it’s using can be trusted. It just uses it to approve a transaction, price a policy, or hand context to the next agent in line.</p><p>That’s the quiet risk underneath every AI-driven decision: unverifiable data can be altered or lost, and nothing catches it until the output is already wrong.</p><p><strong>Here’s what data verifiability actually means</strong> — and why it’s becoming non-negotiable as AI systems are given more decision-making ability.</p><h3>What is data verifiability?</h3><p><strong>Data verifiability is the ability to confirm, independently of a storage provider, that data has not been altered and is still available.</strong> <a href="https://csrc.nist.gov/glossary/term/Integrity_authentication?ref=blog.walrus.xyz">The National Institute of Standards and Technology (NIST)</a> defines integrity verification as the process of obtaining assurance that data has not been modified since it was created or last checked. Verifiability confirms that the same data has been stored, but it doesn’t confirm whether or not the data was accurate when it was written.</p><p>However, most storage relationships don’t work this way. A hyperscale cloud provider tells you your file is intact and your bucket is available. You can compare checksums you kept yourself, but the record of what is stored and whether it’s available lives entirely in the provider’s systems. You’re trusting the provider’s own dashboard, logs, and support team. Verifiability replaces that trust with proof.</p><p>This distinction matters more as AI systems become the ones acting on that data. As AI takes actions with consequence, the data it runs on has to be provable. One builder’s approach shows what that looks like in practice: <a href="https://walrus.xyz/blog/carry-verifiable-agent-answers-built-on-walrus-memory/">Carry adds a proof and access layer on top of Walrus Memory</a>, so every agent answer carries a verifiable receipt of what it remembered and whether it was authorized to use it.</p><h3>How do I verify the source of a dataset?</h3><p>Verifying a dataset’s source comes down to four checks:</p><p><strong>1. Confirm the data has an independent record, not just a provider’s log</strong><br>A file’s existence and history should be recorded somewhere the storage provider doesn’t fully control, not just in their internal database.</p><p><strong>2. Confirm the identifier is derived from the content, not assigned by the provider</strong><br>If the identifier is generated from the data itself, altering the data would change the identifier too, making tampering detectable rather than invisible.</p><p><strong>3. Confirm availability was certified independently, not just reported</strong><br>Most storage systems report availability through a status page the provider controls. Look for availability that a quorum of independent storage nodes certifies and records publicly at the time of upload..</p><p><strong>4. Re-run the check on retrieval, not just at upload</strong><br>A dataset that was verified once at upload can’t detect later tampering. Verification should be repeatable every time the data is accessed.</p><p><strong>On Walrus, this looks like:</strong> each blob’s ID is derived from its content, and its availability is certified onchain when it’s uploaded, by a quorum of storage nodes, until an end date you pay for. Reads through the Walrus client re-verify the bytes against the blob ID by default, and anyone can check a blob’s certification and expiry on Sui. The checks are built into the protocol rather than left to a manual audit.</p><h3>Why does verifiability matter as AI systems scale?</h3><p>Verifiability matters more as AI systems scale because decisions get made further away from a human who could catch a data problem before it compounds. An agent acting on stale, altered, or missing data doesn’t just produce one bad output: it can act on that output, and pass it to the next agent in a workflow.</p><p><a href="https://www.gartner.com/en/newsroom/press-releases/2025-02-26-lack-of-ai-ready-data-puts-ai-projects-at-risk?ref=blog.walrus.xyz">Gartner predicted in 2025</a> that <strong>60% of AI projects lacking AI-ready data would be abandoned through 2026</strong>, with 63% of organizations either lacking or unsure whether they have the right data-management practices for AI at all. Unverifiable datais one part of that readiness gap, not separate from it.</p><p>Multi-agent systems raise the stakes further: when several agents share a memory layer or dataset, each one is trusting not just the data but every other party who touched it. This is also where <a href="https://walrus.xyz/blog/what-is-agentic-memory-debt-and-why-your-agents-keep-accumulating-it-verifiable-portable/">agentic memory debt</a> compounds fastest. Altered or missing memory can quietly skew every downstream decision built on it. Verifiability is what lets that trust be checked rather than assumed.</p><h3>How is verifiability different from encryption or access controls?</h3><p>Encryption, access control, and verifiability are frequently bundled together as “security,” but they answer three different questions.</p><p>Encryption protects confidentiality: who can read the data. Access control protects authorization: who can act on it, and how. Verifiability protects integrity and availability: whether the data is still there and unchanged, regardless of who’s allowed to see it.</p><p>A file can be perfectly encrypted and access-controlled and still be silently corrupted, deleted, or unavailable. Verifiability is the property that detects silent data loss. On Walrus, these are separate layers. Walrus itself provides verifiability: every blob is public, content-addressed, and certified onchain. Seal adds encryption and onchain access policies on top, so you can choose who can read the data without changing how its integrity and availability are verified.</p><h3>How does Walrus Console make verifiability practical?</h3><p><a href="https://console.walrus.xyz/?utm_campaign=blog_content&amp;utm_source=blog&amp;utm_medium=organic">Walrus Console</a> is the managed way to build on Walrus, and it’s built directly on that verifiable foundation. Every file you store in Console is a Walrus blob, and Console returns its blob ID. You can use that ID to read the blob through the Walrus client, which verifies the bytes against the ID, and to check its certification and expiry on Sui, without going through Console.</p><p>Console adds per-file envelope encryption and file-level access controls on top of Walrus’s underlying verifiability, so developers get confirmable integrity, confidentiality, and authorization as three separate, explicit settings.</p><p>This is also where Console diverges from a typical S3-style object store: with a hyperscale provider, availability and integrity are represented by an SLA and a status page, a promise you take on trust. With Console, availability and integrity are properties of the underlying Walrus protocol, so the same familiar upload-and-retrieve workflow comes with something an SLA doesn’t: a claim you can check yourself instead of one you have to take the provider’s word for.</p><h3>FAQs</h3><p><strong>Is data verifiability the same as encryption?<br></strong>No. Encryption controls who can read your data; verifiability confirms whether the data itself is still intact and available. A file can be fully encrypted and still be corrupted or missing. Verifiability is the separate guarantee that detects that.</p><p><strong>How is verifiability different from just trusting my cloud provider’s SLA?</strong>An SLA is a contractual promise backed by the provider’s own systems and reporting. Verifiability means you can check the claim independently, rather than relying on the same party that runs the systems being measured.</p><p><strong>Can verifiability help with AI agent memory?<br></strong>Yes. When an agent’s memory or context is shared across sessions or other agents, verifiability lets every party confirm that memory hasn’t been silently altered or lost. It confirms the memory is unchanged, not that it was accurate when written. This provides a foundation that portability and encryption alone can’t offer.</p><h3>About Walrus</h3><p>Walrus is the data platform built for the demands of AI. It helps builders and enterprises keep data useful across apps and models, protect it with encryption and access controls, and verify it independently. As AI systems take increasingly consequential actions, the data they rely on must be provable. Walrus was created by the cryptographers and distributed-systems engineers behind Sui and Meta’s digital currency and payments infrastructure. Start building with <a href="https://console.walrus.xyz/?utm_campaign=blog_content&amp;utm_source=blog&amp;utm_medium=organic">Walrus Console</a> and give your agents portable memory with <a href="https://memory.walrus.xyz/?utm_campaign=blog_content&amp;utm_source=blog&amp;utm_medium=organic">Walrus Memory</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=99f3860ca4bc" width="1" height="1" alt=""><hr><p><a href="https://medium.com/walrus-protocol/what-is-data-verifiability-and-why-does-it-matter-for-ai-99f3860ca4bc">What Is Data Verifiability, and Why Does It Matter for AI?</a> was originally published in <a href="https://medium.com/walrus-protocol">Walrus Protocol</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Where to Store AI Agent Data?]]></title>
            <link>https://medium.com/walrus-protocol/where-to-store-ai-agent-data-dfa5368d4149?source=rss----6f872fb399e0---4</link>
            <guid isPermaLink="false">https://medium.com/p/dfa5368d4149</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[agent-memory]]></category>
            <category><![CDATA[ai-data]]></category>
            <category><![CDATA[data-storage]]></category>
            <dc:creator><![CDATA[Jessie Mongeon]]></dc:creator>
            <pubDate>Thu, 10 Sep 2026 16:28:07 GMT</pubDate>
            <atom:updated>2026-09-10T16:28:06.166Z</atom:updated>
            <content:encoded><![CDATA[<p><em>No single database model answers every question about agent data. Match each kind to the store built for it, and give durable memory its own layer.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*4q-5DSu9Fjo84-ZQ.jpg" /></figure><p><strong>AI agent data is every record an agent reads or writes as it runs. That includes session and working state, conversation history, embeddings, files and artifacts, logs, and long-term memory.</strong> No single database model serves all of them. This post covers what each class is, which system fits it, the one rule that keeps the data honest, one source of truth with rebuildable indexes, and where durable memory belongs.</p><h3>Key takeaways</h3><ul><li>No single database model answers every question. Match each class of agent data to the model whose consistency, query, retention, and security fit it, rather than one durable home.</li><li>Keep one source of truth for each type of data. Treat vector, graph, and full-text indexes as copies you can rebuild.</li><li>Memory is a behavior of a system, not a database type. An agent memory system has to decide what to remember, store it, retrieve it, and put it back into context when it’s useful.</li><li>Portability is not automatic. Exporting embeddings does not carry your schemas, scopes, provenance, access rules, or deletion policies. Durable memory should live outside any single model, runtime, or app.</li></ul><p>Your agent finishes a run and leaves a a pile of information behind: a conversation transcript, a half-finished plan, tool responses, some embeddings, a few files, and a trace you will want the next time something breaks. These records do different jobs, and forcing them into one storage model creates problems quickly. The harder problem comes later: deciding which data needs to survive beyond the application or runtime that created it.</p><h3>What kinds of data does an AI agent produce?</h3><p>An agent produces several distinct classes of data, and each one has a different owner, lifetime, and access pattern.</p><p><strong>Session and working state</strong> is where a run takes place and what actions can safely happen next: the current plan, completed and pending steps, retry counts, budgets, approvals, locks, and the IDs of side effects. An agent needs to resume from exactly where it stopped without losing or repeating work, so this belongs in a transactional or checkpoint store. <a href="https://langchain-ai.github.io/langgraph/concepts/langgraph_server/?ref=blog.walrus.xyz">LangGraph’s</a> server writes checkpoints after each step and resumes an interrupted run from the last one.</p><p><strong>Conversation and event history</strong> is the ordered record of messages, tool requests, responses, and timestamps. Keep a raw audit record separate from any compressed summary, so the summary can be regenerated and challenged. Replaying full history is not selective memory, and it grows without bound.</p><p><strong>Long-term memory</strong> is a smaller set of records meant to influence later runs: preferences, confirmed facts, prior outcomes, and reusable lessons. Each has a scope, source, timestamp, and expiration. This class exists because a base model does not carry state between runs, which is <a href="https://blog.walrus.xyz/why-do-ai-agents-lose-memory-between-sessions/">why agents lose memory between sessions</a>.</p><p><strong>Embeddings and retrieval records</strong> are the vectors plus the metadata that makes them usable: source record ID, chunk offsets, content hash, tenant and ACL fields, and the embedding model and version. You need this metadata because changing the embedding model or dimension usually means <a href="https://github.com/pgvector/pgvector/blob/master/README.md?ref=blog.walrus.xyz">re-embedding and reindexing</a>.</p><p><strong>Files and artifacts</strong> are the bytes: patches, reports, PDFs, datasets, and model-generated deliverables. If you store the bytes in object storage, you can keep the lineage, hash, owner, status, and URI in your operational database.</p><p><strong>Logs, traces, and evaluation data</strong> are the retrieved candidates, assembled context, outcome labels, cost, and latency. Without the candidate set and the final context, you cannot tell whether a failure came from generation, retrieval, filtering, or stale storage.</p><p>One more rule worth stating plainly: secrets are generally not memory. Store credential references in a secrets manager, grant short-lived scoped identities, and record only which authorization was used.</p><h3>What’s different about storing data for autonomous agents?</h3><p>Autonomous agents need more than chat history, because their work spans many steps and can fail after it has already changed something in production.</p><p><strong>Resumability.</strong> A chatbot can retry a turn. An agent may have edited files, sent requests, or spent money before a crash. Store step-level checkpoints and idempotency keys so it can resume without repeating those actions.</p><p><strong>Shared state and concurrency.</strong> When multiple agents work on the same task, they need clear rules for who can change what and how conflicts are resolved. A vector search can’t tell you which agent owns a task. LangGraph keeps durable state in PostgreSQL and uses Redis for signaling, which shows the split between coordination and durable truth.</p><p><strong>Action provenance.</strong> The more an agent can do, the more dangerous bad memory becomes. If an agent uses stored information to send money, change a file, or call an API, you need to know where that information came from, when it was valid, and whether the agent was allowed to use it. Before an irreversible action, the agent should re-check the current system of record. Poisoning is a real path: <a href="https://arxiv.org/abs/2407.12784?ref=blog.walrus.xyz">AgentPoison</a>, a peer-reviewed NeurIPS 2024 study, corrupted under 0.1% of memory records yet reached at least 80% average attack success across three agent types, with no change to model weights.</p><p><strong>Multi-tenant blast radius.</strong> If your system serves multiple users or organizations, enforce tenant and access rules before data reaches the model. Don’t rely on the LLM to decide what a user is allowed to retrieve. MongoDB’s own <a href="https://www.mongodb.com/docs/vector-search/deployment/multi-tenant-architecture/?ref=blog.walrus.xyz">vector-search guide</a> notes that a tenant pre-filter constrains results but is not the same as database-level isolation. For how this state accumulates and gets recalled, see <a href="https://blog.walrus.xyz/how-do-ai-agents-learn-from-past-interactions/">how AI agents learn from past interactions</a>.</p><h3>The rule that prevents most mistakes: source of truth versus derived indexes</h3><p>Keep one authoritative source of truth, and treat every search index as a rebuildable projection of it. This is the single decision that keeps an agent’s data honest as it grows.</p><p>The source of truth is the record you cannot regenerate: the transactional state, the confirmed facts, the raw events, the artifact bytes. A derived index, a vector index, a graph, a full-text index, are things you build from that source to answer a particular kind of question, and are data artifacts you can throw away and rebuild.</p><p>A vector index is the clearest example. It depends on your embedding model, chunking strategy, and distance metric. Change those, and you may need a new index. That’s routine if the original data still exists somewhere else. It’s a serious problem if the vector index quietly became your only copy of information the agent depends on.</p><p>When you keep this line clear, migrations, model swaps, and index changes stay safe, because the truth never lived in the thing you are rebuilding. When you blur it, a re-embedding job or a compaction pass can silently drop a fact, and you have no source to restore it from.</p><p>This is also where consolidation pays off. Different query models are not the same as different providers, and you do not need a separate vendor for every class of data. What you want underneath is one durable home for the records that must persist, with the specialized indexes projecting from it. That is the role <a href="https://walrus.xyz/?ref=blog.walrus.xyz">Walrus is built for as a Verifiable Data Platform</a>: a foundation to store and manage your data, persistent, portable, and under your control across apps, providers, and agents. Your transactional and vector layers still sit where they belong; the authoritative data underneath has one verifiable home.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YTf0hooPExIilDDLwXd4yQ.jpeg" /><figcaption><em>Layered diagram showing an AI agent reading and writing through a memory layer. Transactional state and object storage hold original data, while vector, graph, and cache indexes provide specialized ways to access it and can be rebuilt from the underlying data.</em></figcaption></figure><h3>What are your storage options, and what is each for?</h3><p>There are five storage categories, each good at one job and poor at others. Memory layers sit on top of these.</p><p><strong>Relational and document databases</strong> (PostgreSQL, Aurora, MongoDB, SQLite for prototypes) are the natural home for authoritative structured state: joins, transactions, row versions, provenance, and checkpoints. LangGraph Agent Server, for example, uses PostgreSQL by default for persistent application data such as threads, runs, checkpoints, and stored items. They are not the fastest at very large approximate-nearest-neighbor workloads.</p><p><strong>Key-value and cache stores</strong> (Redis, DynamoDB) are for hot session state, counters, locks, deduplication keys, and TTL-bound values. They’re useful when data needs to be read or updated quickly, but temporary state is the wrong place for evidence that needs to survive an audit.</p><p><strong>Vector databases</strong> (Pinecone, Qdrant, Weaviate, Milvus, pgvector, and others) are for semantic similarity and filtered retrieval. Use them to find relevant information by meaning. Don’t make the vector index your only copy of important data or rely on it alone to enforce access.</p><p><strong>Object and blob storage</strong> (Amazon S3, Google Cloud Storage, Azure Blob, MinIO) are for large immutable outputs, raw logs, media, backups, and content-addressed artifacts. Object storage is good at keeping large files cheaply and reliably. It doesn’t manage your agent’s workflow or understand what a file means, so you’ll usually pair it with a database or search index.</p><p><a href="https://walrus.xyz/?ref=blog.walrus.xyz">Walrus</a> sits in this category with a difference: it is a Verifiable Data Platform, a durable home for your data that is provider-independent and verifiable, so you can confirm stored bytes have not been tampered with since upload and move them across providers instead of locking to one.</p><p><strong>Graph databases</strong> (Neo4j, Neptune, ArangoDB) are for explicit entities, dependency paths, temporal relationships, and multi-hop provenance. Extraction is costly, and generated edges can be wrong. Graph tooling also inherits injection risk: a <a href="https://github.com/advisories/GHSA-gg5m-55jj-8m5g?ref=blog.walrus.xyz">March 2026 advisory</a> for Graphiti documented attacker-controlled labels reaching Cypher construction through prompt injection.</p><h3>How do you choose where each kind of data goes?</h3><p>Start with what the data does. Is it state the agent needs to resume work? A file that has to persist? An index for semantic search? A relationship graph? Temporary coordination data? Or memory that needs to influence future runs? Then choose the system built for that job. Keep the original data separate from the indexes you can rebuild, decide what must survive a crash, and enforce tenant and access rules before data reaches the model. The table maps the classes to their fit.</p><p><strong>Session and working state </strong>belongs in a transactional or checkpoint store. Why: resume without losing or repeating work. Not a similarity-search problem.</p><p><strong>Conversation and event history </strong>belongs in an append-only log or table, with a separate summary. Why: auditable, regenerable, bounded by policy. Not selective long-term memory.</p><p><strong>Embeddings and retrieval records </strong>belong in a vector index built from the original data. Why: find relevant information by meaning. Not the source of truth or task state.</p><p><strong>Files and artifacts </strong>belong in object storage, with lineage in the database. Why: durable storage for large files while metadata remains queryable. Not a transactional workflow store.</p><p><strong>Logs, traces, and evaluations </strong>belong in an observability or analytics store. Why: debug retrieval, cost, and quality over time. Not the agent’s operational state.</p><p><strong>Long-term memory </strong>belongs in a memory layer over persistent, scoped storage. Why: needs write policy, scope, provenance, and expiry. Not a raw vector dump or chat transcript.</p><h3>Where does durable memory belong?</h3><p>Memory is a behavior of the surrounding system: a write policy that decides what is worth keeping, storage that persists it, retrieval that finds it, and <a href="https://blog.walrus.xyz/what-is-context-engineering/">context assembly</a> that puts it in front of the model at the right moment. A vector index can serve the retrieval step, but on its own it does not decide what to remember, resolve conflicting facts, scope a record to a user or project, expire what is stale, or establish that a recalled item is true.</p><p>Agent memory layers do that job. LangGraph’s checkpointer and store, Mem0, and others sit above raw storage and decide what to extract, consolidate, scope, expire, and retrieve. Their backend may be SQL, vector, graph, or a combination, and they are typically tied to the framework or service that provides them. None of them remove the need for a source of truth, artifact storage, and access control underneath.</p><p><a href="https://blog.walrus.xyz/how-do-ai-agents-store-long-term-memory/">Durable memory belongs in a persistent layer</a> that lives outside any single model, runtime, or app. Note the scope: memory is one class of agent data, not all of it. Your transactional state, artifact bytes, and embeddings still live in the systems above. What memory needs on top of raw storage is a write policy, scoping, provenance, and rules for how memories are corrected, retained, or deleted. There is no universal cross-provider standard that makes all of this portable today.</p><p><a href="https://walrus.xyz/products/walrus-memory/?ref=blog.walrus.xyz">Walrus Memory</a> is a portable memory layer for AI agents, the memory layer built on the Walrus Verifiable Data Platform. It keeps durable memory outside the model or tool that created it, so connected tools can access the same memory across sessions and workflows. You define who can access it, and its integrity can be independently verified. Memory stops being tied to one runtime and can move with your agent across tools.</p><h3>FAQs</h3><h4><strong>Is a vector database enough for agent memory?</strong></h4><p>No. A vector database helps you find information by semantic similarity. An agent memory system also needs to decide what gets remembered, how memories are scoped and retained, and when they should return to the model’s context. Your exact task state and artifacts also live elsewhere.</p><h4><strong>Can I just use object storage like S3 for agent data?</strong></h4><p>Use it for the right data. Object storage is well suited to files, large outputs, raw logs, media, and backups. But storing a file doesn’t give your agent transactions, workflow state, or semantic retrieval. You’ll usually pair object storage with a database, index, or catalog depending on how the data needs to be used.</p><h4><strong>Where does autonomous agent state live?</strong></h4><p>In a transactional or checkpoint store that supports exact recovery. Autonomous runs edit files, call APIs, and spend money, so you need step-level checkpoints and idempotency keys to resume without repeating actions that already happened. LangGraph writes checkpoints after steps and keeps that durable state in PostgreSQL while using Redis only for ephemeral coordination.</p><h4><strong>Is Walrus Memory a vector database?</strong></h4><p>No. Walrus Memory is a portable memory layer for AI agents. A vector database is one way to index data for semantic retrieval. Walrus Memory handles the memory layer, including persistent memory and scoped access, so the same memory can remain available across sessions, apps, and workflows.</p><h4><strong>How portable is agent memory between providers today?</strong></h4><p>There is no universal standard that makes agent memory portable across providers today. Exporting embeddings alone does not carry your schemas, scopes, access rules, metadata, provenance, or retention policies. Keeping memory outside any single model or runtime is one way to remove that dependency. <a href="https://walrus.xyz/products/walrus-memory/?ref=blog.walrus.xyz">Walrus Memory</a> is designed around that model: persistent memory that can be accessed across supported tools and workflows instead of remaining bound to the assistant that created it.</p><h3><strong>About Walrus</strong></h3><p><a href="https://walrus.xyz/?ref=blog.walrus.xyz">Walrus is a Verifiable Data Platform</a> for builders in AI and onchain finance. No more fragile foundations: Walrus finally makes it possible to verify where data came from, prove it hasn’t been tampered with, and know it’s always available, without compromising on speed. It is the foundation for applications where unverifiable data can cause irrecoverable losses. The more we trust AI and onchain finance with our money and decisions, the more mission-critical this becomes. Created by the ex-Meta engineers behind Sui.</p><p><em>Originally published at </em><a href="https://blog.walrus.xyz/where-to-store-ai-agent-data/"><em>https://blog.walrus.xyz</em></a><em> on September 3, 2026.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dfa5368d4149" width="1" height="1" alt=""><hr><p><a href="https://medium.com/walrus-protocol/where-to-store-ai-agent-data-dfa5368d4149">Where to Store AI Agent Data?</a> was originally published in <a href="https://medium.com/walrus-protocol">Walrus Protocol</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What Is Context Engineering?]]></title>
            <link>https://medium.com/walrus-protocol/what-is-context-engineering-33747e333750?source=rss----6f872fb399e0---4</link>
            <guid isPermaLink="false">https://medium.com/p/33747e333750</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[agent-memory]]></category>
            <category><![CDATA[prompt-engineering]]></category>
            <category><![CDATA[context-engineering]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Jessie Mongeon]]></dc:creator>
            <pubDate>Thu, 10 Sep 2026 16:27:50 GMT</pubDate>
            <atom:updated>2026-09-10T16:27:49.347Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Context engineering is the design and management of information a model sees at runtime, including instructions, state, tools, retrieval, and recalled memory.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*OhsP0zLkT8YGmAfP.jpg" /></figure><p><strong>Context engineering</strong> decides what a model sees at each step: instructions, history, tools, state, and recalled memory in one working context. This post covers what it is and how it differs from prompting. That includes what goes into an agent’s context, where it sits in agentic infrastructure, and where it stops. Context engineering assembles that working context, but the durable state it draws on lives in a separate layer, like Walrus Memory.</p><h3>Key takeaways</h3><ul><li>Context engineering is the assembling of information a model needs for its next inference step.</li><li>It manages more than prompt engineering does: retrieval, history, tools, state, recalled memory, and context size.</li><li>Memory may be managed by a context-engineering framework, but durable state remains architecturally distinct from the temporary context view.</li><li>Memory persistence, portability, verifiability, and control are not automatic outcomes of context engineering.</li></ul><p>Context engineering is the practice of building the right working context for each model call.</p><blockquote><strong><em>Context engineering:</em></strong><em> the runtime design, selection, transformation, and management of the information a model sees for a specific inference step. It includes choosing what to retrieve, retain, compress, omit, or isolate so the model receives a small, relevant working set instead of every piece of available data.</em></blockquote><p>The term does not yet have one universally accepted boundary. <a href="https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents?ref=blog.walrus.xyz">Anthropic</a> defines it as strategies for curating and maintaining an optimal set of tokens during inference. <a href="https://www.langchain.com/blog/context-engineering-for-agents?ref=blog.walrus.xyz">LangChain</a> describes filling the context window with the right information at each step of an agent’s trajectory. <a href="https://www.ibm.com/think/topics/context-engineering?ref=blog.walrus.xyz">IBM</a> emphasizes the deliberate design and optimization of context for accurate and relevant output.</p><p><strong>These definitions agree on three points:</strong></p><ul><li>Context engineering is broader than prompt wording.</li><li>It happens repeatedly during an agent’s run.</li><li>It works within a finite context window, even when that window is large.</li></ul><p>They disagree at the edges. <a href="https://www.promptingguide.ai/guides/context-engineering-guide?ref=blog.walrus.xyz">The Prompt Engineering Guide</a> treats context engineering partly as a broader rebranding of prompt engineering. Anthropic calls it a natural progression. <a href="https://www.gartner.com/en/articles/context-engineering?ref=blog.walrus.xyz">Gartner</a> frames it as an enterprise capability covering data, workflows, environments, and persistent context. That is a disagreement about category boundaries, not the underlying mechanics.</p><h3>How is context engineering different from prompt engineering?</h3><p>Prompt engineering designs instructions, while context engineering designs the model’s full working situation and information supply chain.</p><p>Prompt engineering focuses on phrasing, roles, examples, output constraints, and the instructions given to a model. Context engineering includes all of that, plus:</p><ul><li>Which history should be included</li><li>What external information should be retrieved</li><li>Which tools the agent can use</li><li>How tool results should be represented</li><li>What task state should remain active</li><li>Which memories should be recalled</li><li>What should be summarized, trimmed, or isolated</li></ul><p><a href="https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents?ref=blog.walrus.xyz">Anthropic</a> distinguishes the two by describing prompt engineering as methods for writing and organizing instructions, while context engineering manages all relevant tokens during inference, including information that arrives outside the prompt.</p><p><a href="https://www.ibm.com/think/topics/context-engineering?ref=blog.walrus.xyz">IBM</a> similarly treats prompting and RAG as narrower techniques. A prompt doesn’t cover all inference-time information, while RAG doesn’t manage system instructions, tool definitions, message history, or task state.</p><p>The shift in language reflects the move from single-turn model calls to agents that work across multiple steps. The wording of the initial instruction still matters. It’s no longer the whole job.</p><h3>What goes into an agent’s context?</h3><p>An agent’s context contains the smallest useful set of instructions, evidence, state, tools, and memory needed for its next step.</p><p><strong>Instructions and examples</strong> : Goals, rules, output schemas, tool guidance, and canonical demonstrations</p><p><strong>Conversation history: </strong>Recent messages and relevant earlier exchanges</p><p><strong>Retrieved information: </strong>Records selected from files, databases, search, or other knowledge sources</p><p><strong>Tools and tool results: </strong>Available actions and the information returned by previous actions</p><p><strong>Working state: </strong>The current plan, task status, intermediate results, and unresolved questions</p><p><strong>Recalled long-term memory: </strong>Selected facts, preferences, decisions, and procedures persisted beyond the active session</p><p><strong>Control information: </strong>Permissions, scope, routing, and information that must be isolated from the call</p><p>This list is broader than “everything the model might need.” More context is not always better. Anthropic recommends finding the smallest high-signal set of tokens likely to produce the desired outcome. Google’s production guidance warns that appending everything creates rising cost and latency, stale or distracting context, and eventual window overflow. Anthropic emphasizes compaction, structured note-taking, and multi-agent architectures for long-running work. <a href="https://arxiv.org/abs/2507.13334?ref=blog.walrus.xyz">A Survey of Context Engineering for LLMs</a> groups the field into context retrieval or generation, processing, and management.</p><p>These are different taxonomies for the same practical problem: deciding what the model should see at a given moment.</p><h3>What is agentic infrastructure, and where does context engineering fit?</h3><p>Agentic infrastructure is the set of runtime services and controls that let an LLM-based agent execute multi-step work reliably.</p><blockquote><strong><em>Agentic infrastructure:</em></strong><em> the models, runtime, orchestration, tools, connectors, retrieval systems, state and memory services, identity controls, observability, evaluations, and interfaces that support an AI agent while it plans, acts, and updates its state.</em></blockquote><p>This is an emerging umbrella term, not a standards-defined architecture. <a href="https://docs.cloud.google.com/architecture/choose-agentic-ai-architecture-components?ref=blog.walrus.xyz">Google’s current architecture guide</a> lists frontends, agent-development frameworks, tools, memory, agent runtimes, AI models, and model runtimes as production components. It also identifies externalized memory and state management as requirements for production systems.</p><p>Context engineering sits between the system’s information sources and a particular model call:</p><ol><li>Durable and transient sources hold files, records, memory, task state, tool results, and policy.</li><li>Context engineering retrieves, ranks, transforms, compresses, and scopes that information.</li><li>The resulting working context is sent to the model.</li><li>The model responds or chooses a tool.</li><li>Orchestration updates state and decides what happens next.</li></ol><p>Google’s ADK architecture calls the resulting context a “ <a href="https://developers.googleblog.com/architecting-efficient-context-aware-multi-agent-framework-for-production/?ref=blog.walrus.xyz">compiled view</a> “ over a larger stateful system. Sessions, memory, and files remain the underlying sources. The context compiler produces the temporary view used for one invocation.</p><h3>Where does context engineering end and memory begin?</h3><p>That compiled view is where context engineering ends: it builds the working context for one model call and can’t hold anything past it, so the durable state an agent needs next session, or in another app, belongs to a separate memory layer.</p><p>Leading architectures draw this line explicitly. <a href="https://developers.googleblog.com/architecting-efficient-context-aware-multi-agent-framework-for-production/?ref=blog.walrus.xyz">Google ADK</a> separates sessions, memory, and files from the per-invocation context view. <a href="https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents?ref=blog.walrus.xyz">Anthropic</a> describes structured note-taking as writing notes outside the context window and retrieving them later. The split is clean: context engineering is the compiler and traffic controller for the working context, and memory is the durable substrate it writes to and reads from.</p><p>Context engineering’s own techniques don’t close the gap. Replay and compaction manage the view, they don’t persist it. <a href="https://developers.googleblog.com/architecting-efficient-context-aware-multi-agent-framework-for-production/?ref=blog.walrus.xyz">Google</a> warns that append-everything approaches raise cost and time to first token, bury the signal in stale tokens, and eventually overflow even large windows, while <a href="https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents?ref=blog.walrus.xyz">Anthropic</a> notes that aggressive summaries drop details that matter later. Once the session ends, so does the state. Across a fleet of agents that cost compounds into <a href="https://blog.walrus.xyz/what-is-agentic-memory-debt-and-why-your-agents-keep-accumulating-it-verifiable-portable/">agentic memory debt</a>, the accumulating cost of agents relearning what they should have retained. For the failure modes in detail, see <a href="https://blog.walrus.xyz/why-do-ai-agents-lose-memory-between-sessions/">why AI agents lose memory between sessions</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ybyntPP3S_x1NdVCUFY7yg.png" /><figcaption><em>Flow diagram: durable sources (files, records, long-term memory, task state, policy) feed into context engineering, which retrieves, ranks, compresses, and scopes them into a temporary compiled context sent to the model. The model responds or calls a tool, and orchestration writes updated state back to the durable layer. A dashed line separates the durable memory layer from the temporary context view.</em></figcaption></figure><h3>What kind of memory layer does context engineering need?</h3><p>A temporary context view and a durable record have different lifecycles: one is rebuilt on every call, the other has to outlast the runtime. So the properties of that durable layer decide how much the agent can rely on it. Four properties do the heavy lifting:</p><ul><li><strong>Persistent:</strong> state survives beyond the current call and session.</li><li><strong>Portable:</strong> memory moves across runtimes, model providers, and apps instead of locking to one state format.</li><li><strong>Verifiable:</strong> writes carry provenance and an audit trail, so a recalled fact can be traced and checked.</li><li><strong>Controlled:</strong> access, correction, and deletion are yours to define.</li></ul><p>A memory layer that’s strong on retrieval but thin on portability, provenance, or control just pushes those problems back onto the builder. <a href="https://walrus.xyz/products/walrus-memory/?ref=blog.walrus.xyz">Walrus Memory</a> is one example that meets all four: a portable memory layer for AI agents that persists outside the context window, moves across apps and runtimes, and stays under your control.</p><h3>FAQs</h3><h3>What is context engineering in simple terms?</h3><p>Context engineering is deciding what an AI model should see for its next step. It assembles instructions, history, retrieved information, tools, task state, and selected memory into a useful working context.</p><h3>What is agentic context engineering?</h3><p>Agentic context engineering is context engineering applied across an agent’s multi-step run, assembling instructions, state, tools, retrieval, and memory fresh at each step rather than once in a single prompt.</p><h4>Is context engineering the same as prompt engineering?</h4><p>No. Prompt engineering focuses on writing and structuring instructions. Context engineering manages the model’s full inference-time situation, including retrieval, history, state, tools, memory, compression, and isolation.</p><h4>Does context engineering include memory?</h4><p>Partly. Context engineering decides which memories to recall into the working context, but the durable store is a separate layer with its own persistence, governance, and retrieval. Many frameworks manage the recall; few own the durable memory. One framework can implement both.</p><h4>What is agentic infrastructure?</h4><p>Agentic infrastructure is the collection of runtime systems that lets an AI agent perform multi-step work. It includes models, orchestration, tools, retrieval, memory, state, security, observability, evaluations, and interfaces.</p><h4>Can a larger context window replace persistent memory?</h4><p>No. A larger window delays overflow but doesn’t create cross-session persistence or guarantee relevance and reliable recall. Append-everything approaches also increase cost, latency, and distracting context.</p><h4>How does context engineering relate to Walrus Memory?</h4><p>Context engineering decides what a model sees for its current step, but the durable state it draws on has to live in a separate layer. <a href="https://walrus.xyz/products/walrus-memory/">Walrus Memory</a> is a portable memory layer for AI agents, one example of that layer, which context engineering can write to and recall from across apps and sessions.</p><h3>About Walrus Memory</h3><p><a href="https://walrus.xyz/products/walrus-memory/?ref=blog.walrus.xyz"><strong>Walrus Memory</strong></a><strong> is a portable memory layer for AI agents.</strong> It enables agents to operate reliably across apps and sessions without losing context — portable, verifiable, and fully under builders’ control. Walrus Memory lets agents handle complex, long-running workflows and coordinate using data they can trust.</p><p><em>Originally published at </em><a href="https://blog.walrus.xyz/what-is-context-engineering/"><em>https://blog.walrus.xyz</em></a><em> on August 25, 2026.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=33747e333750" width="1" height="1" alt=""><hr><p><a href="https://medium.com/walrus-protocol/what-is-context-engineering-33747e333750">What Is Context Engineering?</a> was originally published in <a href="https://medium.com/walrus-protocol">Walrus Protocol</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Do AI Agents Learn From Past Interactions?]]></title>
            <link>https://medium.com/walrus-protocol/how-do-ai-agents-learn-from-past-interactions-67d1e574c9b7?source=rss----6f872fb399e0---4</link>
            <guid isPermaLink="false">https://medium.com/p/67d1e574c9b7</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ai-learning]]></category>
            <category><![CDATA[agent-memory]]></category>
            <dc:creator><![CDATA[Jessie Mongeon]]></dc:creator>
            <pubDate>Thu, 10 Sep 2026 16:27:30 GMT</pubDate>
            <atom:updated>2026-09-10T16:30:50.255Z</atom:updated>
            <content:encoded><![CDATA[<p><em>AI agents learn from past interactions by storing what happened and retrieving it later, not by retraining the model after every conversation.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*-8CCSjd9-3GJNDPS.jpg" /></figure><p><strong>An AI agent learns from a past interaction when something it did changes how it handles a later task.</strong> That change usually lives in memory stored outside the model. This post covers how that works, from in-context adaptation to external memory and personalization, and why the durable part needs a portable memory layer.</p><h3>Key takeaways</h3><ul><li>Most deployed agents learn at runtime by changing external state.</li><li>Memory persists information. Context engineering decides which part of that information the model sees now.</li><li>Personalization can use explicit preferences, inferred preferences, prior conversations, workspace context, and past outcomes.</li><li>More memory can help, but irrelevant, stale, false, or poisoned memory can make an agent worse.</li><li>Durable memory needs provenance, time, scope, access control, correction, and deletion.</li></ul><p>When using an agent, if you explain your stack to it, close the session, the next session starts blank with no memory of what you told it last. AI agents <a href="https://blog.walrus.xyz/why-do-ai-agents-lose-memory-between-sessions/">lose memory between sessions</a> because the model doesn’t carry a durable record from one inference call to the next. When an agent does seem to learn, the surrounding system saved part of the earlier interaction, retrieved it, and placed it back in the model’s context on the next call. The model’s weights, or the underlying numerical parameters, usually stay the same.</p><h3>What does it mean for an AI agent to learn?</h3><p>An AI agent learns when a past interaction changes its later behavior, but several different mechanisms can cause that change.</p><p>The simplest is <strong>in-context adaptation</strong>. An instruction, example, tool result, or earlier message changes the next response. Nothing is written back to the model. This is called <a href="https://aclanthology.org/2025.findings-naacl.408/?ref=blog.walrus.xyz"><strong>in-context learning</strong></a>: the model adapts to instructions and examples in the current prompt without being retrained.</p><p>The next is <strong>session state</strong>. The application saves the conversation, plan, tool outputs, or workflow variables and sends selected state back on the next turn. It often ends when the current thread is closed or it hits a retention limit.</p><p><strong>External memory</strong> lasts longer. The application <a href="https://blog.walrus.xyz/how-do-ai-agents-store-long-term-memory/">stores messages, summaries, preferences, and other useful information outside the model</a>. When needed, it retrieves selected information and adds it to the model’s current context. These <a href="https://arxiv.org/pdf/2507.05257?ref=blog.walrus.xyz">external memory systems</a> are more common in deployed agents than memory stored by changing the model itself.</p><p>Agents can store different kinds of memory:</p><ul><li><strong>Episodic memory</strong> records an event, action, and outcome.</li><li><strong>Semantic memory</strong> stores facts or preferences.</li><li><strong>Procedural memory</strong> stores rules, prompts, skills, or tool instructions.</li><li><strong>Reflection</strong> turns outcomes into a saved lesson.</li></ul><p><strong>Training-time learning</strong> changes the model itself. <a href="https://developers.openai.com/api/reference/resources/fine_tuning?ref=blog.walrus.xyz">OpenAI’s fine-tuning tools</a> use training data to adjust a model’s internal settings and general behavior. For user-specific personalization, <a href="https://help.openai.com/en/articles/8590148-memory-faq?ref=blog.walrus.xyz">ChatGPT uses stored memory</a> instead of fine-tuning the model for each user.</p><h3>How does an interaction become useful later?</h3><p>An interaction becomes useful later through a write, update, retrieve, and use cycle.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ULZ57_F4MWEFmox1WJviUg.jpeg" /><figcaption>Flow diagram: in the surrounding agent system, an interaction is observed, extracted into a fact or lesson, stored and updated, then retrieved and assembled into context for the model. The model responds without changing itself, and feedback loops back to the observe step.</figcaption></figure><p>Suppose a developer tells a coding agent, “ <em>This repo uses pnpm, not npm. Always run </em><em>pnpm test before opening a pull request</em>.&quot;</p><p>The system records the observation with the user, the repository, a timestamp, and the source message. It extracts two facts, that the package manager is pnpm and the pre-PR check is pnpm test, and saves them to a profile scoped to that repository.</p><p>On a later task in the same repo, retrieval surfaces the saved preference, and context engineering assembles the current instructions and that preference into one temporary input. When the agent is about to run npm install, it uses pnpm instead and runs pnpm test before opening the pull request.</p><p>This lifecycle can fail at every step. Extraction can turn an inference into a fact. Storage can use the wrong account key. Consolidation can overwrite a valid exception. Retrieval can miss the right episode. The model can ignore correctly retrieved evidence. In <a href="https://arxiv.org/pdf/2410.10813?ref=blog.walrus.xyz">LongMemEval</a>, 15% to 19% of total errors came from cases where the system retrieved the right evidence but generated the wrong answer.</p><p>Memory includes the policy for what persists, how records change, and what enters the next model call.</p><h3>How do AI assistants personalize over time?</h3><p>Over time, an AI assistant might personalize itself by applying user, project, or workspace information to later content, tone, recommendations, tools, and actions.</p><p>This kind of personalization is not automatic across sessions. A base model starts each session fresh. Cross-session personalization happens only when the surrounding system saves preferences somewhere durable, such as a profile, a memory store, or a config file like AGENTS.md or CLAUDE.md, and loads them into a later session.</p><p>An explicit preference comes directly from the user: “Use concise bullets,” “default to a window seat,” or “run pnpm test before opening a pull request.&quot; An inferred preference comes from repeated behavior, such as noticing that a developer consistently replaces npm commands with pnpm. Inferred preferences might not be consistently applied, as the agent might treat it as uncertain because the pattern may apply to one repository rather than every project.</p><p>When it does persist, personalization can draw on saved preferences, profile fields, selected conversations, summaries, corrections, workspace rules, and past outcomes. This is different from replaying chat history. A transcript preserves what was said. A profile extracts a smaller claim. An episodic store preserves what happened and how it turned out.</p><p>Current assistants ship several versions of this as opt-in features. <a href="https://help.openai.com/en/articles/8590148-memory-faq?ref=blog.walrus.xyz">OpenAI</a> separates saved memories from dynamically selected chat history. <a href="https://support.claude.com/en/articles/11817273-use-claude-s-chat-search-and-memory-to-build-on-previous-context?ref=blog.walrus.xyz">Anthropic</a> documents RAG-based chat search plus project-scoped memory entries. <a href="https://ai.google/static/documents/building_personal_intelligence.pdf?ref=blog.walrus.xyz">Google’s Personal Intelligence report</a> describes retrieval and context packing across connected applications, with user permission.</p><p>Storage scope matters. A writing preference may follow a user. A repository rule belongs to a project. An organization policy belongs to the organization. Combining those scopes can make personal experiments affect professional work.</p><p>Cold-start personalization uses defaults, onboarding, imported context, or tentative in-session inference. As preferences change, the system needs timestamps, sources, and correction controls instead of one permanent label.</p><p>Personalization also has a failure mode: it can make a model too agreeable. In a two-week study with 38 participants, <a href="https://arxiv.org/pdf/2509.12517?ref=blog.walrus.xyz">a generated user profile increased agreement sycophancy for 3 of 4 tested models</a>.</p><h3>Why don’t agents remember everything?</h3><p>Agents don’t remember everything because total recall creates accuracy, cost, privacy, and security problems.</p><p>A large context window holds more tokens, but it doesn’t create durable state, nor will the model use every token equally. <a href="https://aclanthology.org/2024.tacl-1.9/?ref=blog.walrus.xyz">Lost in the Middle</a> found that models often performed best when relevant information appeared near the beginning or end.</p><p>Keeping every interaction produces duplicate, stale, and contradictory records. <a href="https://ai.google/static/documents/building_personal_intelligence.pdf?ref=blog.walrus.xyz">Google’s internal testing</a> documented personal intelligence where agents encountered tunnel vision and overlooked corrections when it stored too many interactions.</p><p>Stored content can become an attack surface. In <a href="https://proceedings.neurips.cc/paper_files/paper/2024/hash/eb113910e9c3f6242541c1652e30dfd6-Abstract-Conference.html?ref=blog.walrus.xyz">AgentPoison’s experiments</a>, poisoning under 0.1% of memory records triggered the attack at least 80% of the time, while degrading normal task performance by no more than 1%. In other words, a tiny, hard-to-notice amount of poisoned memory was enough to reliably hijack the agent.</p><p>Selective memory is a safety property. The system should keep what has future value, within the right scope and retention policy, and let the user remove what no longer belongs.</p><h3>What makes agent memory trustworthy?</h3><p>Agent memory is trustworthy when it keeps the evidence, time, scope, and control needed to check a recalled record before using it.</p><p>Each memory should carry a source, subject, scope, observation time, applicable time, and evidence type. The system should distinguish what the user stated from what a model inferred. Confidence can’t replace the source. Before a consequential action, the agent should verify remembered information against its source.</p><p>Changing facts need versions. If a user changes tasks or a project upgrades a dependency, the new record should supersede the old current fact while preserving valid history where policy allows. Deletion should ensure that data is removed from places like derived summaries, embeddings, indexes, and caches instead of stopping at the visible chat.</p><p>For memory to be truly trustworthy, access control must happen before retrieval. Another user’s memory should never be something that can be altered or deleted by unauthorized personnel.</p><p>You can inspect, correct, delete, export, pause, or disable memory for an agent. <a href="https://help.openai.com/en/articles/11146739-how-does-reference-saved-memories-work?ref=blog.walrus.xyz">OpenAI</a> notes that deleting a chat doesn’t automatically delete a separately saved memory, while <a href="https://support.claude.com/en/articles/12123587-import-and-export-your-memory-from-claude?ref=blog.walrus.xyz">Anthropic</a> documents separate chat-search and memory controls, including import and export.</p><h3>What kind of memory can survive models and apps?</h3><p>Memory survives across models and apps when it lives in a portable layer outside any single assistant, model, or runtime, so connected tools can read the same records. Import and export are a start, but they remain manual and may work for an occasional migration. It becomes cumbersome when you regularly switch between coding assistants or use several at once. Each tool must be taught the same repository conventions, preferred commands, and working style.</p><p>Claude Code shows the limitation. It can remember project-specific lessons across its own sessions, but <a href="https://code.claude.com/docs/en/memory?ref=blog.walrus.xyz">auto memory is stored locally and separately for each repository</a>. Anthropic says those files are not shared across machines or cloud environments. You can move selected lessons into a committed instruction file, but that file is then visible to everyone with repository access and only works with tools configured to read it. Claude Code’s accumulated auto memory does not automatically follow the project into Codex, another machine, or a custom agent.</p><p>That is the gap a portable memory layer is designed to address: it keeps memory outside the assistant that created it. <a href="https://docs.wal.app/walrus-memory?ref=blog.walrus.xyz">Walrus Memory</a> is a portable memory layer for AI agents. It keeps memory outside any single coding assistant, model, or runtime, allowing connected tools to access the same records across sessions and workflows. This reduces the need to copy preferences and project knowledge manually between compatible assistants.</p><h3>FAQs</h3><h4>Do AI agents retrain after every conversation?</h4><p>Usually, no. Documented assistant-memory systems save histories, memories, summaries, or profiles for later model calls. Fine-tuning may use conversation data in a separate training process.</p><h4>What is the difference between memory and context?</h4><p>Memory retains information across time. Context is the temporary information available for one inference step. Retrieved memory becomes context when the application inserts it. <a href="https://blog.walrus.xyz/how-to-add-portable-memory-to-claude-code-and-codex-with-walrus-memory/">Read more about the difference between context window and memory</a>.</p><h4>Can a larger context window replace long-term memory?</h4><p>No. A larger window delays truncation but doesn’t provide persistence, scope, updates, deletion, or reliable selection. <a href="https://aclanthology.org/2024.tacl-1.9/">Models can miss relevant information inside a long prompt</a>.</p><h4>How do AI assistants personalize over time?</h4><p>They save or infer preferences, retrieve conversations, maintain profiles, and apply project or workspace context. This can change content, tone, tools, or workflow without changing model weights.</p><h4>Is chat history the same as a user profile?</h4><p>No. Chat history is a transcript. A profile is a smaller set of claims about the user. Extraction can remove context or turn an uncertain inference into a false fact.</p><h4>Can an agent’s memory move between applications?</h4><p>Usually, memory is platform-bound. Moving it requires compatible identity, scope, permissions, deletion rules, and retrieval behavior.</p><h3>About Walrus Memory</h3><p><a href="https://walrus.xyz/products/walrus-memory/?ref=blog.walrus.xyz"><strong>Walrus Memory</strong></a><strong> is a portable memory layer for AI agents. </strong>It enables agents to operate reliably across apps and sessions without losing context — portable, verifiable, and fully under builders’ control. Walrus Memory lets agents handle complex, long-running workflows and coordinate using data they can trust.</p><p><em>Originally published at </em><a href="https://blog.walrus.xyz/how-do-ai-agents-learn-from-past-interactions/"><em>https://blog.walrus.xyz</em></a><em> on August 18, 2026.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=67d1e574c9b7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/walrus-protocol/how-do-ai-agents-learn-from-past-interactions-67d1e574c9b7">How Do AI Agents Learn From Past Interactions?</a> was originally published in <a href="https://medium.com/walrus-protocol">Walrus Protocol</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Do AI Agents Store Long-Term Memory?]]></title>
            <link>https://medium.com/walrus-protocol/how-do-ai-agents-store-long-term-memory-1dbc391bba85?source=rss----6f872fb399e0---4</link>
            <guid isPermaLink="false">https://medium.com/p/1dbc391bba85</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ai-infrastructure]]></category>
            <category><![CDATA[agent-memory]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[agent-memory-systems]]></category>
            <dc:creator><![CDATA[Jessie Mongeon]]></dc:creator>
            <pubDate>Thu, 10 Sep 2026 16:27:13 GMT</pubDate>
            <atom:updated>2026-09-10T16:27:12.632Z</atom:updated>
            <content:encoded><![CDATA[<p><em>AI agents store long-term memory in an external system that saves selected information outside the model, then retrieves it into the context window when it’s relevant.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*mKs-31H-NFF1h3r2.jpg" /></figure><p>An LLM doesn’t store long-term memory on its own. Long-term memory for an agent is a separate layer: a store, plus rules for what to write, when to retrieve it, and how to place it back into the model’s context. Without that layer, each session starts from zero. For why that happens, <a href="https://blog.walrus.xyz/why-do-ai-agents-lose-memory-between-sessions/">see why AI agents lose memory between sessions</a>.</p><h3>Key takeaways</h3><ul><li>Long-term memory is built outside the model: a persistent store plus rules for writing and retrieval.</li><li>Short-term memory is what’s in the context window now. Long-term memory is what survives after the session ends.</li><li>Agent memory is usually split into semantic, episodic, and procedural memory.</li><li>Context stuffing, summarization, RAG, and native memory features each create continuity, and each has failure modes.</li><li>A complete memory system also needs correction, deletion, conflict handling, access control, and provenance.</li></ul><h3>What’s the difference between short-term and long-term memory in AI agents?</h3><p>Short-term memory is the information actively available to an agent during its current task. Long-term memory is persisted information that can be recovered after the current context or session ends.</p><p><strong>Short-term, or working, memory</strong> includes the current goal, recent conversation, active plan, selected files, and tool results. It’s immediately usable because it’s already in the context window, but it’s finite, temporary, and increasingly expensive to replay as it grows.</p><p><strong>Long-term memory</strong> combines a persisted store with rules for writing and retrieving information. It usually splits into three kinds:</p><ul><li><strong>Semantic memory</strong> — stable facts and preferences, such as a user’s language or deployment region.</li><li><strong>Episodic memory</strong> — past events, decisions, failures, and outcomes.</li><li><strong>Procedural memory</strong> — reusable workflows, instructions, and policies.</li></ul><p>Storage alone isn’t enough. A working memory system also needs rules for promotion, ranking, recency, conflict handling, correction, deletion, provenance, and access. <a href="https://doi.org/10.1145/3586183.3606763?ref=blog.walrus.xyz">The Generative Agents architecture</a> demonstrates an early record, reflection, and retrieval pipeline for reusing stored experiences in later planning.</p><p>The short-term and long-term split is useful, but it isn’t a universal taxonomy. <a href="https://arxiv.org/abs/2512.13564?ref=blog.walrus.xyz">A 2026 survey</a> argues that modern agent systems blur the lines between memory, RAG, and context engineering.</p><h3>How do today’s tools fake memory, and where does each approach break?</h3><p>Today’s tools create the appearance of memory by replaying, compressing, retrieving, or extracting information outside the model.</p><h4>Context stuffing</h4><p>Context stuffing prepends old messages, instructions, or project material to each new request. It is simple and preserves exact recent wording.</p><p>The cost is growth. Larger prompts increase token use and generally increase time to first token. Old material must eventually be truncated, and irrelevant content can compete for attention. Even relevant information can be missed when buried in a long prompt.</p><h4>Summarization</h4><p>Summarization replaces older dialogue with a shorter running record. It controls prompt size and reduces the amount of text replayed.</p><p>But summaries are lossy. Details, exceptions, chronology, and exact requirements can disappear. OpenAI described an early saved-memory system as <a href="https://openai.com/index/chatgpt-memory-dreaming/?ref=blog.walrus.xyz">feeling like talking to someone who took notes but forgot what was not written down</a>.</p><p>A summary also needs links back to its source material if you want an audit trail.</p><h4>Retrieval-augmented generation</h4><p>RAG indexes external material, finds candidate passages for a query, and adds selected passages to the prompt. It gives the model access to updateable and potentially attributable information without replaying everything.</p><p>Its failures move into the retrieval pipeline: poor chunking, embedding mismatch, weak ranking, stale indexes, missed context, latency, or passages that are retrieved but not used. <a href="https://arxiv.org/abs/2005.11401?ref=blog.walrus.xyz">The foundational RAG paper</a> identified provenance and the updating of world knowledge as open problems.</p><p>RAG can be part of memory. It is not a complete memory system by itself. It doesn’t automatically capture an agent’s evolving decisions, user-specific state, or procedures.</p><h4>Native memory features</h4><p>Native memory features let a provider extract preferences, search history, synthesize past conversations, or maintain project-scoped knowledge. They reduce repetition and often provide user controls.</p><p>Their limits are scope and reliability. Recall is selective, retrieval criteria may be unclear, and memory usually remains inside one provider, assistant, or project. <a href="https://help.openai.com/en/articles/8590148-memory-faq?ref=blog.walrus.xyz">ChatGPT’s own documentation</a> says it doesn’t remember every detail.</p><h3>What have the big LLM providers shipped, and what remains unsolved?</h3><p>The big providers have shipped useful continuity features, but none of the reviewed systems establishes universal, portable, exact, and auditable memory across assistants and apps.</p><ul><li><strong>OpenAI:</strong> ChatGPT expanded memory beyond explicitly saved items to include information from chat history in 2025. In June 2026, OpenAI described a background <a href="https://openai.com/index/chatgpt-memory-dreaming/?ref=blog.walrus.xyz">“dreaming” architecture</a> intended to improve continuity, freshness, and relevance. OpenAI has not presented that architecture as exact archival recall or a cross-provider memory format.</li><li><strong>Anthropic:</strong> Claude can search prior chats, but searches are bounded to non-project chats or an individual project. Projects keep isolated histories, instructions, and uploaded knowledge. <a href="http://code.claude.com/docs/en/memory?ref=blog.walrus.xyz">In Claude Code</a>, each session starts with a fresh context window, and cross-session continuity comes from external memory files: the user-authored CLAUDE.md instructions and project-specific auto-memory notes that Claude Code loads into later sessions.</li><li><strong>Google:</strong> Gemini’s Memory can use past chats to personalize responses, and eligible users can turn it off or delete chats. Temporary Chats don’t personalize or save context, though Google retains them up to 72 hours. These controls improve privacy, but they don’t make <a href="https://support.google.com/gemini/answer/16598469?ref=blog.walrus.xyz">Gemini’s memory</a> a guaranteed record of a past decision or a portable layer another assistant can use.</li><li><strong>Microsoft:</strong> Microsoft 365 Copilot added Memory in 2025 for preferences, working style, and recurring topics, though as of its December 2025 update it wasn’t available for agents. <a href="https://docs.github.com/en/enterprise-cloud@latest/copilot/concepts/agents/copilot-memory?ref=blog.walrus.xyz">GitHub Copilot has a separate memory feature</a>, now in public preview, storing repository facts and user coding preferences. Both improve continuity inside Microsoft’s own coding and chat surfaces, not a portable, cross-assistant memory layer.</li></ul><p>The unsolved layer is not another chat-history toggle. It is durable state that applications and agents can use across sessions, with clear ownership, access rules, correction, deletion, and provenance.</p><h3>What solves cross-session memory for AI agents?</h3><p><strong>The category-level solution is a persistent, portable memory layer that lives outside any single model. </strong>It stores selected state, retrieves it when relevant, and places it back into the model’s working context. The implementation belongs in dedicated infrastructure, not in the assumption that a larger prompt will remember forever.</p><p><a href="https://walrus.xyz/products/walrus-memory/?ref=blog.walrus.xyz">Walrus Memory is a portable memory layer for AI agents</a> that enables AI agents to operate reliably across apps and sessions, without losing context. Memory persists outside prompts and context windows and isn’t tied to a single runtime or session.</p><h3>FAQs</h3><h4>Does Walrus Memory give agents long-term memory?</h4><p>The long-term memory described here is exactly the layer <a href="https://walrus.xyz/products/walrus-memory/?ref=blog.walrus.xyz">Walrus Memory</a> provides. Walrus Memory is a portable memory layer for AI agents: it stores selected state, retrieves it when relevant, and moves it across agents, apps, and workflows, rather than staying tied to a single runtime.</p><h4>Is a context window the same as memory?</h4><p>No. A context window is the finite amount of information available during the current model call. Memory persists outside that window and must be retrieved into a later call before the model can use it.</p><h4>Does a larger context window solve AI memory?</h4><p>No. A larger context window increases temporary input capacity but does not create cross-session persistence. <a href="https://walrus.xyz/products/walrus-memory/">Research</a> also shows that models may use information less reliably when it is buried within a long input.</p><h4>Is chat history the same as memory?</h4><p>No. Chat history is an archive of interactions. Memory is selected information retrieved and used later, and a product can maintain both as separate systems.</p><h4>How does Walrus Memory stop agents forgetting between sessions?</h4><p>The forgetting described in the article happens because memory has to live outside the model, and most tools keep it locked to one provider or session. <a href="https://walrus.xyz/products/walrus-memory/">Walrus Memory</a> is a portable memory layer for AI agents that persists that state outside prompts and context windows, so continuity survives across sessions instead of resetting.</p><p><em>Originally published at </em><a href="https://blog.walrus.xyz/how-do-ai-agents-store-long-term-memory/"><em>https://blog.walrus.xyz</em></a><em> on August 13, 2026.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1dbc391bba85" width="1" height="1" alt=""><hr><p><a href="https://medium.com/walrus-protocol/how-do-ai-agents-store-long-term-memory-1dbc391bba85">How Do AI Agents Store Long-Term Memory?</a> was originally published in <a href="https://medium.com/walrus-protocol">Walrus Protocol</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why do AI agents lose memory between sessions?]]></title>
            <link>https://medium.com/walrus-protocol/why-do-ai-agents-lose-memory-between-sessions-be0ab2e1e304?source=rss----6f872fb399e0---4</link>
            <guid isPermaLink="false">https://medium.com/p/be0ab2e1e304</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[ai-stack]]></category>
            <category><![CDATA[ai-agent-memory]]></category>
            <dc:creator><![CDATA[Jessie Mongeon]]></dc:creator>
            <pubDate>Thu, 10 Sep 2026 16:26:04 GMT</pubDate>
            <atom:updated>2026-09-10T16:26:03.276Z</atom:updated>
            <content:encoded><![CDATA[<p><em>AI agents lose memory between sessions because LLM calls are stateless, where each request is processed on its own with no record of the ones before it.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PmYwQuzCGO7vumHJTfYi7g.jpeg" /></figure><p><strong>AI agents forget information between sessions because LLM calls are normally stateless</strong>: the context window holds temporary input for one request, not durable memory. Chat history, bigger windows, summaries, RAG, and native memory features can fake continuity, but each drops details or stays locked to one provider. Real cross-session memory lives outside the model.</p><p>Walrus Memory is a portable memory layer for AI agents that persists selected state and moves it across apps, sessions, and agents.</p><h3>Key takeaways</h3><ul><li>AI agents forget context because LLM calls are normally stateless. Cross-session memory has to be built outside the model.</li><li>A context window is temporary input capacity, not durable memory.</li><li>Chat history is an archive. Memory is selected information retrieved and reinserted into a later request.</li><li>At the end of a session, the model’s working state is discarded unless another system persists it.</li></ul><p>AI agents lose memory between sessions because an LLM doesn’t automatically carry the state of one request into following sessions. The model can only use the information supplied in its current context window. If an application doesn’t store, retrieve, and reinsert information from an earlier session, the next model call starts without it. <a href="https://ai.google.dev/gemini-api/docs/text-generation?ref=blog.walrus.xyz">Google’s API documentation describes this as stateless operation.</a></p><p>The assistant didn’t necessarily lose a thought. The next session simply contains no record of it.</p><h3>Why does ChatGPT forget previous chats?</h3><p>Agents like ChatGPT forget previous chats when the product doesn’t pull relevant past context into the current model request. That context can include saved memories, prior chats, files, and connected-app information.</p><p>Chat transcripts and memory are separate systems. For <a href="https://help.openai.com/en/articles/8590148-memory-faq?ref=blog.walrus.xyz">OpenAI</a> models, the current memory system keeps a continually updated synthesis of context from past chats rather than a complete, verbatim record. The complete record is stored elsewhere. This makes it useful for personalization, but not a reliable archive of every prior detail.</p><p>That selectivity is deliberate: <a href="https://help.openai.com/en/articles/8590148-memory-faq?ref=blog.walrus.xyz">ChatGPT’s memory system</a> decides which details are most important to retain and update. Meanwhile, the Temporary Chat feature neither uses existing memories nor creates new ones, which acts as a privacy control.</p><p>Memory boundaries can also differ within the same provider. In <a href="https://help.openai.com/en/articles/8554407-gpts-in-chatgpt?ref=blog.walrus.xyz">ChatGPT today</a>, custom agents keep their own configured instructions and uploaded knowledge, but don’t use your saved memory, custom instructions, or previous conversations. New chats with the custom agent begin without the personal context from your regular ChatGPT chats.</p><h3>What’s the difference between a context window and memory?</h3><p>A context window is the temporary information available during a model call. Memory is an external mechanism that preserves information beyond that call and makes selected information available later.</p><blockquote><strong><em>Context window:</em></strong><em> The finite token budget a model can attend to while producing a response. It may contain system instructions, messages, retrieved documents, tool results, and output capacity. It’s not a durable account record.</em></blockquote><blockquote><strong><em>AI agent memory:</em></strong><em> An external system that retains information beyond the current request or session, then retrieves selected facts, events, decisions, or procedures and places them into a future context window.</em></blockquote><p>You can think of the context window like short-term memory: a larger window lets the model receive more material at once, but it does not make that material persist into a new session.</p><p>However, just because you can fit information into the window does not guarantee that the model will use it reliably. The peer-reviewed <a href="https://aclanthology.org/2024.tacl-1.9/?ref=blog.walrus.xyz">Lost in the Middle study</a> found that performance can decline when relevant information appears in the middle of a long input.</p><p>Agent memory can be thought of like long-term memory: it is writable, user- or application-specific information that can be recovered for later work.</p><h3>What happens at the end of a session?</h3><p>At the end of a session, the model’s working state disappears unless another system deliberately persists it.</p><p>During inference, the model receives tokens and generates more. To avoid re-deriving the same values at every step, serving systems commonly use a key-value cache: arithmetic the system declined to repeat, not stored information about the user. Every entry is a deterministic function of tokens the user already supplied, meaning nothing is learned. Delete the cache and you lose speed, not knowledge. This holds even when the cache is deliberately preserved. <a href="https://chenyoumin1993.github.io/papers/eurosys25-hcache.pdf?ref=blog.walrus.xyz">A 2025 systems paper</a> on state restoration takes stateless inference as the standard assumption and then relaxes it, writing intermediate activations to SSDs so context can be rebuilt hours later, but what persists is still a recomputable artifact of one’s session’s tokens, not a profile the model has formed.</p><p>Anything needed later must therefore be handled in a separate workflow. From the agent, you can resend the transcript, keep server-side conversation state, write selected information to storage, or retrieve earlier material before the next call.</p><p>Some providers offer wrappers to make these workflows programmatic. <a href="https://platform.openai.com/docs/api-reference/conversations?ref=blog.walrus.xyz">OpenAI’s Conversations API</a> can store and retrieve conversation state across Responses API calls, while <a href="https://ai.google.dev/gemini-api/docs/text-generation?ref=blog.walrus.xyz">Google’s Interactions API</a> can retain server-side state, however its stateless mode requires the client to send accumulated history.</p><p>But retained state is not necessarily permanent memory. Google documents session-handle retention of up to 24 hours in one API configuration, while OpenAI documents 30-day default application-state retention for its Responses API. These are provider retention policies, not portable long-term memory.</p><p>This is why a coding agent can regress when completing tasks like choosing a migration path. Once it processes enough logs to lose the original rationale, it can later repeat or reverse the decisions it made. They will only survive if the system preserves it and can retrieve it when relevant.</p><h3>What does this mean for building AI agents?</h3><p>If you’re building agents, cross-session memory is something you add, not something the model provides. The model won’t carry state between sessions on its own. Reliable continuity comes from a memory layer that lives outside the model: it stores selected state, retrieves it when relevant, and puts it back into the next context window.</p><p><a href="https://walrus.xyz/products/walrus-memory/?ref=blog.walrus.xyz">Walrus Memory is a portable memory layer for AI agents</a>. It keeps memory outside prompts and context windows, so it isn’t tied to a single runtime or session, and it can move across agents, apps, and workflows.</p><h3>FAQs</h3><h4>Why do AI agents forget between sessions?</h4><p>AI agents forget because LLMs are normally stateless. If no external system stores and retrieves earlier information, a new request contains no durable record of the previous session.</p><h4>Is a context window the same as memory?</h4><p>No. A context window is the finite amount of information available during the current model call. Memory persists outside that window and must be retrieved into a later call before the model can use it.</p><h4>Does a larger context window solve AI memory?</h4><p>No. A larger context window increases temporary input capacity but does not create cross-session persistence. <a href="https://walrus.xyz/products/walrus-memory/">Research</a> also shows that models may use information less reliably when it is buried within a long input.</p><h4>Is chat history the same as memory?</h4><p>No. Chat history is an archive of interactions. Memory is selected information retrieved and used later, and a product can maintain both as separate systems.</p><h4>How does Walrus Memory stop agents forgetting between sessions?</h4><p>The forgetting described in the article happens because memory has to live outside the model, and most tools keep it locked to one provider or session. <a href="https://walrus.xyz/products/walrus-memory/">Walrus Memory</a> is a portable memory layer for AI agents that persists that state outside prompts and context windows, so continuity survives across sessions instead of resetting.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=be0ab2e1e304" width="1" height="1" alt=""><hr><p><a href="https://medium.com/walrus-protocol/why-do-ai-agents-lose-memory-between-sessions-be0ab2e1e304">Why do AI agents lose memory between sessions?</a> was originally published in <a href="https://medium.com/walrus-protocol">Walrus Protocol</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>