AI Engineer World's Fair 2026

Agent Memory Is Solved. Agent Learning Isn't. — Karthik Ranganathan, Yugabyte

Loading slides…

Read the talk

Agent Memory Is Solved. Agent Learning Isn't.

Selected presentation frame from Agent Memory Is Solved. Agent Learning Isn't. — Karthik Ranganathan, Yugabyte at 35 secondsOpen full source frame
Opening slide: “Agent memory is a solved problem. Agent learning isn’t.”

Karthik Ranganathan and Heather Downing explain why agent handoffs lose hard-won context, how Yugabyte rebuilt its retrieval pipeline, and how Meko carries selected lessons across sessions and agents without making every private memory shared.

From a talk by Karthik Ranganathan and Heather Downing

At a glance

Ideas worth remembering

  • An output-only handoff loses rejected approaches and decision context, causing the next agent to repeat discovery and spend tokens again.

  • Reusable shared context needs supervised promotion and traceable sources, because making information accessible does not make it reliable.

  • The slide reports Markdown faithfulness improving from 14% to 65%, PDF faithfulness from 20% to 74%, and context precision from 5% to 82%, alongside a reduction from over 7,000 context chunks to about 1,000.

  • The email-incident demo distinguishes session resumption from sharing: Claude retrieves a saved private memory, while Codex finds it only after promotion into shared knowledge.

  • Human promotion supplies examples of what a team values. Using those examples to train future orchestration is a proposal; human selection remains part of the demonstrated system.

A remembered conversation does not teach the next agent

An agent finishes a task and hands over a Markdown file, a PDF or another document. The next agent receives the result, but loses the reasoning that produced it: which alternatives failed, what constraints mattered and why the team settled on this approach. It must discover those things again, spending tokens to repeat work someone already did. This handoff problem drives Karthik Ranganathan’s distinction between individual memory and collective learning.

Selected presentation frame from Agent Memory Is Solved. Agent Learning Isn't. — Karthik Ranganathan, Yugabyte at 211 secondsOpen full source frame
Diagram contrasts Agent A’s completed work with what Agent B lacks after the handoff: reasoning, dead ends, and context.

Yugabyte encountered the problem while building four agents: two for internal customer support and sales–marketing coordination, and two for customers. PerfAdvisor handled database administration; Voyager helped migrate and modernize databases. Nearly a year of trying to make these agents work exposed a data problem that more scalable vector, graph or relational storage did not resolve. For a database company, Ranganathan says, “it becomes personal.”

The human analogy is a new teammate proposing alternatives the team considered weeks or months ago. A useful onboarding conversation includes the project’s history, rejected approaches and current working assumptions. Agents need a comparable handoff. Saving a conversation for one agent supplies memory; making its useful lessons available to another agent requires additional infrastructure for sharing, selection and retrieval.

0:130:43
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:13 · section reference included

Shared context needs selection and a source

Ranganathan challenges five common responses to the handoff problem. His objections concern preserving and reusing lessons across agents; they should be read within that scope rather than as universal claims about the usefulness of these techniques.

  • More memory: storing more material does not decide which lessons another agent should use.
  • Shared state: access to the same file does not automatically supply the reasoning behind it.
  • Retrieving every transcript: a larger searchable pile can introduce irrelevant material and make the model spend more tokens interpreting it.
  • Fine-tuning: he rejects repeated custom training as a scalable way to persist agents’ newly discovered lessons.
  • Bigger context windows: adding capacity leaves the quality and deterioration of the context unresolved.

The proposed replacement has three requirements. Agents must be able to work from shared context. Contributions must pass through supervised promotion because shared context can degrade. And each piece of information must be traceable to a source—a person, conversation or data source—so someone can investigate a questionable claim and improve it. The comparison to code review is useful: producing a contribution and accepting it into the team’s working knowledge are separate decisions.

3:424:12
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

3:42 · section reference included

A scalable RAG pipeline still needed diagnosis

The first implementation treated the problem as a knowledge base: put everything into a distributed, elastic retrieval-augmented generation pipeline. It scaled, but did not produce useful results. The next attempt gave each agent a tiny Postgres database. That moved storage closer to the individual agent while leaving repeatable workflows to be reinvented on every run. A subsequent backend-heavy design omitted the UI because agents supposedly did not need one; humans then could not tell what was happening.

The displayed slide separates three reported results: Markdown faithfulness rose from 14% to 65%, PDF faithfulness from 20% to 74%, and context precision from 5% to 82%. Faithfulness concerns whether an answer stays grounded in its retrieved material; context precision concerns how much of that material is relevant. The 82% endpoint therefore describes retrieval precision, rather than faithfulness. The spoken transcript renders the precision baseline as 57%, differing from the slide; the displayed metric labels and paired endpoints clarify the comparison.

Tracing and changing one variable at a time improved those separate grounding and retrieval measures. Meanwhile, the context fell from over 7,000 chunks to about 1,000—roughly one-seventh as much material. The recording does not identify the benchmark, changed variables or full evaluation conditions, so this is an account of Yugabyte’s pipeline improvement rather than a reproducible recipe or general performance guarantee.

Selected presentation frame from Agent Memory Is Solved. Agent Learning Isn't. — Karthik Ranganathan, Yugabyte at 423 secondsOpen full source frame
Slide reports faithfulness figures of 14%, 65%, 74%, and 82%, alongside a reduction from over 7,000 chunks to about 1,000.

The consequential decision was to inspect retrieval behavior rather than keep adding capacity. Less context accompanied better grounding and higher precision. That reduces the material an LLM must process and gives the team a reason to expect lower token spending, while preserving the more useful evidence. The lesson is specific: scalability did not substitute for tracing and tuning what the pipeline actually returned.

5:456:15
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

5:45 · section reference included

Data packs make private work available for deliberate reuse

Meko packages these lessons into an agent-native persistence layer. Its organizing unit is a data pack, which can hold a knowledge base, memories, conversations and observability information over multiple storage types, including vector, graph, relational and NoSQL databases. An agent writes context into a private space; selected pieces move into a shared space through promotion. Other agents and humans retrieve that promoted context to continue the work.

The talk’s own deck provides a collaboration example. Heather Downing wrote a demo outline, created a Meko data pack and sent Ranganathan a share request. He brought the outline into Claude Desktop, asked it to break down the talk, edited the outline and generated a deck. A poor diagram prompted a separate design pass. Downing then reviewed the finished material to connect it with her demo.

The shared outline supplied enough context for the collaborators to work with different tools without first agreeing on an agent harness or holding a meeting. Human judgment still changed the outline, rejected the initial diagram and checked the final handoff. The reusable part was the project context; the people remained responsible for deciding what the presentation should become.

7:157:45
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

7:15 · section reference included

Resume an email incident in a fresh session

Downing’s demonstration separates two capabilities: resuming work in a new session and sharing knowledge with a different agent. Application-specific memory or projects can support continuity inside one tool, but she wants context she can carry between desktop, coding and mobile workflows. Cloud persistence makes that possible; permission to retrieve a memory still has to be controlled.

The concrete lesson is an early-access launch incident. Sign-up emails failed because the team used an email-service sandbox rather than production and exceeded its limit during testing. In Claude Desktop, Downing asks to save the conversation in an early-access launch data pack. A connected Model Context Protocol (MCP) server exposes the operations, and a skill guides the agent’s use of them. The agent creates the data pack and adds the incident fact as searchable memory.

She then ends the session and opens a fresh chat outside a Claude project, without relying on Claude’s built-in memory. Asking about the incident retrieves the saved explanation from Meko. There is a small orchestration stumble: the agent tries to search before creating a new conversation record. The MCP server instructs it to create that record so the resumed interaction can also be stored, and the search finds the earlier incident.

This changes the next session’s starting point. The original investigation involved a back-and-forth with an LLM; the new session can retrieve its result through a tool call instead of repeating that investigation. The memory must first be captured, however, and the skill determines how frequently the agent writes it. Persistence and the instructions for using persistence both participate in resumability.

10:2010:50
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

10:20 · section reference included

A connected agent cannot read an unpromoted memory

The same email incident next becomes a sharing test. Downing asks Codex whether it knows a cause for failing sign-up emails. Codex can see that it is connected to a new data pack, but cannot find the explanation. The incident memory remains private in the Claude Desktop workflow. Connecting a data pack has not exposed all of its contents.

Downing switches accounts to access the data pack and promotes the incident memory into shared knowledge. The first response still does not find it; after she repeats the question, the agent retrieves the fact. The observable change is from an unavailable explanation to a retrievable one after promotion. It is the same incident and question, with the memory’s sharing state changed.

What changes between saving a lesson and making it useful to another agent? The flow below follows the email incident through private storage, session resumption and supervised sharing. Its two retrieval paths show why resumability and shareability need separate treatment: the originating workflow can recover its private memory, while another agent receives the selected lesson only after promotion.

Promotion can be fine-grained. A maintainer can open the whole data pack, but Downing demonstrates releasing one useful piece of information. This supports sharing a best practice or an ongoing process without exposing every memory gathered while working on it. The cost of that control is a human selection step; the benefit is a smaller, intentional body of shared knowledge.

One incident, two retrieval paths

Claude captures the incidentSign-up emails failed after sandbox limits were exceeded.
Private searchable memoryThe incident is stored in the early-access launch data pack.
Fresh Claude sessionSearch retrieves the earlier incident without a project or built-in memory.
Human promotionOne selected memory becomes shared knowledge.
Codex retrieves the causeThe connected agent can now find the previously private explanation.
Saving supports a fresh session. Promotion makes the selected incident available to another agent.
Read the diagram as text
  • Claude captures the incident. Sign-up emails failed after sandbox limits were exceeded.
  • Private searchable memory. The incident is stored in the early-access launch data pack.
  • Fresh Claude session. Search retrieves the earlier incident without a project or built-in memory.
  • Human promotion. One selected memory becomes shared knowledge.
  • Codex retrieves the cause. The connected agent can now find the previously private explanation.
  • Claude captures the incident → Private searchable memory: Add searchable memory.
  • Private searchable memory → Fresh Claude session: Resume through search.
  • Private searchable memory → Human promotion: Select a lesson to share.
  • Human promotion → Codex retrieves the cause: Search shared knowledge.
14:2214:52
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

14:22 · section reference included

Inspect the savings; keep promotion human for now

The way to inspect token savings is to follow the stored conversation down to its tool calls. Meko includes embedded Langfuse traces, which Downing describes as exposing the decision trace and token usage. That lets a team compare repeated investigation with retrieval of a saved lesson. The demo gives a mechanism for reducing repeated work and a means of inspecting it, but does not present a quantified before-and-after token comparison.

Selected presentation frame from Agent Memory Is Solved. Agent Learning Isn't. — Karthik Ranganathan, Yugabyte at 987 secondsOpen full source frame
Meko data pack interface is displayed during the explanation of inspecting conversation traces.

Human promotion also creates a possible future training signal. Each decision that a memory is worth keeping becomes a labeled example of useful shared knowledge. Downing proposes using those examples to train an agent around a team’s preferences and improve orchestration over time. That remains a future direction in this recording; the demonstrated system keeps a human in the loop. Its present learning mechanism is the accumulation and reuse of selected context, rather than a demonstrated automatic training loop.

An outage illustrates why collective context could matter operationally. Without shared knowledge, several agents may repeatedly call the same unavailable server while people ask the same questions in Slack. Downing proposes having the first agent record the failure so the others can retrieve it. The shared observation would let subsequent agents start from a known incident rather than independently rediscover it; the recording does not develop how that observation would expire or be updated when the service recovers.

11:2011:50
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

16:14 · section reference included

Turn launch experience into team knowledge

The team uses Meko to launch Meko. Beyond the early-access launch work, Downing created a separate troubleshooting data pack after some initial users had trouble accessing their packs. Colleagues load that shared context into their preferred agents: engineers use coding tools such as Claude Code or Codex, while Ranganathan works mainly in Claude Desktop. The same operational knowledge supports different kinds of work without requiring everyone to use the same client.

The closing examples extend beyond debugging.

  • Customer communication: Ranganathan uses a data pack containing context about his writing voice to help draft an apology email for a user who could not get access, and to prepare LinkedIn posts.
  • Onboarding: a new teammate can receive project context, get up to speed and contribute further lessons.
  • Capturing working patterns: useful practices can emerge from ordinary work and then be selected for reuse, even when the person doing the work did not set out to write a formal best practice.

These uses bring the discussion back to tribal knowledge: capture what a team learns, control who can share it, and keep enough visibility to understand what agents are doing with it. Ranganathan closes by inviting people to connect an agent to Meko’s free tier. The practical starting point demonstrated here is modest and concrete: save one useful lesson, recover it in a fresh session, then deliberately make it available to another agent.

17:5418:25
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

17:54 · section reference included

Resources

Transcript download
Full transcript

Loading transcript…