← Chain of Thought | AI Agents, Infrastructure & Engineering

Switching Models Shouldn't Mean Starting Over | Walrus's Kimberly Logan

Evaluation and Summary

7.5/10

Chain of Thought host Conor Bronsdon interviews Kimberly Logan, Head of Product at the Walrus Foundation, about portable and verifiable memory for AI agents. The core problem: if an agent's memory lives inside one model provider's infrastructure, switching models or harnesses means losing that context and starting over. Longer context windows don't solve this—they're model-specific. Even import functions only capture a single point in time and don't address the underlying lock-in. The episode explores why Walrus Memory, built on a decentralized storage network, offers a solution. Logan explains that Walrus doesn't benchmark against other memory startups because she sees the opportunity as broader than memory alone. The conversation covers concrete use cases: coding agents (about 30% of usage), long-running study aids, trading agents, and security teams comparing production snapshots with code changes. A striking stat: 85% of memories written are read back more than 30 days later, suggesting real retention value. A significant portion addresses verifiability—how blockchain attestations and delegate keys let users prove what happened to their data. Logan clarifies an important nuance: unchanged data on-chain isn't proof of accuracy, only proof of non-tampering. The episode discusses recall quality and latency as table stakes, with knowledge graphs keeping recall focused on fresh memories. Logan's career arc—nearly 20 years in traditional software including seven at Google, now at a blockchain company—frames the philosophical shift. The episode closes with Walrus Console, a new interface for managing agent memories and files via UI or MCP connection, abstracting away storage configuration details. Throughout, the discussion stays grounded in engineering realities: model switching costs, data portability, trust across company boundaries. The show notes promise coverage of why model lock-in is fundamentally a memory problem, what portable memory enables, and where shared memory across trust boundaries goes next. The episode is sponsored by Walrus, which is disclosed upfront.

Verdict: A technically sharp, well-structured conversation that moves beyond hype to explore real engineering constraints in agent memory portability, with concrete use cases and honest discussion of verification limits.

Technology rubric

  • Technical accuracy 4/5 20%

    Shows solid understanding of model lock-in, context windows, and blockchain attestation mechanics; the distinction between non-tampering proof and accuracy proof is precise and non-trivial

  • Insight beyond the headlines 4/5 20%

    Moves beyond 'portable memory is good' to explore why context windows don't solve switching costs, why benchmarking memory startups misses the point, and the nuance of on-chain verification

  • Clarity for non-experts 3/5 15%

    Explains core concepts (model lock-in, attestations, knowledge graphs) but assumes some familiarity with AI agents and blockchain; could be opaque to newcomers without agent experience

  • Substance 4/5 15%

    Dense with concrete details: the 13-point accuracy swing, 85% 30-day reread rate, 30% coding agent usage split, and specific use cases (trading, security snapshots); minimal filler evident in chapter structure

  • Delivers on its title 5/5 15%

    Title promises why switching models shouldn't mean starting over; episode directly addresses portable memory, lock-in, verifiability, and Walrus Console as the solution

  • Value for time 4/5 15%

    38 minutes with 12 chapters suggests tight pacing; covers problem, solution, use cases, and philosophy without obvious padding, though full assessment limited by show notes alone

How we score Technology

Worth it if you build or deploy AI agents, care about vendor lock-in, or want to understand why decentralized storage matters for agent infrastructure.

Content flags

  • Sponsored Episode is sponsored by Walrus and features Walrus's Head of Product; guest has direct commercial interest in the solution discussed

Based on the episode description. AI-generated; it can be wrong.

Show notes

If your agent's memory lives inside one model provider, switching models or harnesses means starting over. You need portable memory - yet when switching agent memory between models, you can swing accuracy by thirteen points or more, depending on which model reads them back. Kimberly Logan, Head of Product at the Walrus Foundation, where she builds Walrus Memory, joins Chain of Thought to discuss how to build portable and verifiable memory for AI agents - and why Walrus's decentralized storage network has proved an apt primitive. She and host Conor Bronsdon get into why model lock-in is a memory problem, what people use agent memory for beyond coding, how you prove what happened to your data, and why Walrus doesn't publish memory quality benchmarks, plus more. This episode is sponsored by Walrus. We cover: Why longer context windows don't help once you switch models or harnesses, and why an import function only fixes one point in time Why Kimberly doesn't benchmark Walrus Memory against memory startups, and why she sees the opportunity as bigger than memory alone What people build with Walrus Memory besides coding agents, which Walrus puts at maybe 30% of usage: long-running study aids, trading agents, and security teams comparing production snapshots with code changes Walrus's figure that almost 85% of the memories written are read back more than 30 days later How attestations on the blockchain and a delegate key you control let you show what happened to your data, and why unchanged data still isn't proof that it's accurate Why Kimberly treats recall quality and latency as table stakes, and how a knowledge graph keeps recall on the freshest memories Why she left almost 20 years in traditional software, including seven at Google, for a blockchain company, and where shared memory across companies and trust boundaries goes next Walrus Console, announced this week: one place to manage agent memories and files through an interface or an MCP connection, without knowing how the storage underneath is configured Connect with Kimberly Logan: LinkedIn: https://www.linkedin.com/in/krlgn/ Twitter/X: https://x.com/kimblgn Walrus: https://walrus.xyz/cot Connect with Chain of Thought host Conor Bronsdon: Newsletter: https://newsletter.chainofthought.show/ Twitter/X: https://x.com/ConorBronsdon LinkedIn: https://www.linkedin.com/in/conorbronsdon/ YouTube: https://www.youtube.com/@ConorBronsdon 🔗 More episodes: https://chainofthought.show Chapters: (0:00) Why agent memory has to move with you (1:25) Context windows don't follow you to a new model (4:41) Why an import function doesn't fix lock-in (6:38) Why Walrus isn't competing head-on with memory startups (8:39) Where Walrus Memory goes next (10:38) Trading agents and security snapshots on Walrus Memory (14:44) Verifiability: answering what happened to your data (17:21) Fresh recall, and why Walrus doesn't publish memory benchmarks (20:22) From traditional software to a blockchain company (24:40) A record other companies and regulators can check (25:42) What Walrus Console is for (29:09) Use agent memory beyond coding agents (30:52) Plugging in your own agent stack (31:41) Memory across companies and trust boundaries (35:48) Closing thoughts Thanks to Walrus, presenting sponsor of season four of Chain of Thought. Walrus Memory gives AI agents portable, verifiable memory that carries context across apps, sessions, and other agents. Get started at https://walrus.xyz/cot #AI #AIAgents #AgentMemory #SoftwareEngineering #DevTools

Episode page

More from Chain of Thought | AI Agents, Infrastructure & Engineering

Andrea Malagodi, CTO at Sonar, joins Conor Bronsdon to explore why simple metrics for measuring AI engineer productivity—like cost per pull request—can be dangerously misleading. The episode opens with a concrete case study: Malagodi's finance team flagged two engineers with opposite metrics. One had 500+ PRs at low…

Worth it if you lead engineering teams, manage AI spend, or care about measuring developer productivity beyond vanity metrics.

Ad-heavy
/10