# Agent Memory Is Solved. Agent Learning Isn't.

Karthik Ranganathan & Heather Downing, Yugabyte | AI Engineer World's Fair 2026 | 20:36

Source: https://www.youtube.com/watch?v=9_oy4owGtPI
Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks.
Page: https://aietalks.com/talks/agent-memory-is-solved-agent-learning-isnt
Published: 2026-10-05
Tags: agents, context-engineering, memory, multi-agent, rag

## TL;DR
- Per-agent memory does not give a group of agents shared knowledge, because handoffs usually pass outputs while losing reasoning, failed attempts, and project history.
- Useful shared context needs controlled promotion and traceability to the source that produced it.
- Yugabyte improved its RAG pipeline from 14% to 82% faithfulness while reducing the context from over 7,000 chunks to about 1,000 chunks.

## Summary
Karthik Ranganathan argues that agents can already store and retrieve memories for themselves, but teams of agents still lose the context needed to work together. A handoff usually contains a document or answer, while the reasoning, failed approaches, and history remain with the first agent. The next agent then spends tokens reconstructing the same work. Ranganathan describes Yugabyte's failed attempts to solve this with a shared knowledge base, separate databases, backend processing, and a large RAG pipeline. After tracing and tuning the pipeline one variable at a time, the team raised faithfulness from 14% to 82% and cut context size by roughly seven times. Heather Downing then demonstrates Meko, Yugabyte's agent-native persistence layer, including private memories, promoted shared data packs, session resumption, cross-agent retrieval, and token tracing. Human promotion remains part of the process and may later provide training signals for orchestration.

## Key ideas
### Agent learning happens when agents share work, not when one agent stores memories
[00:31](https://www.youtube.com/watch?v=9_oy4owGtPI&t=31s)
Ranganathan separates memory from learning. An agent can extract memories from conversations and reuse them, but that process is per agent. Learning becomes difficult when several agents need to work together. Yugabyte runs four agents, including Hagen for customer support and Growth Vector for coordinated sales and marketing, plus Perf Advisor and Voyager for customers. The company spent almost a year trying to make its agents work before identifying the data problem. The infrastructure that gives one agent memory does not automatically provide the shared context needed by a group.

### A handoff loses the reasoning that makes an answer useful
[02:37](https://www.youtube.com/watch?v=9_oy4owGtPI&t=157s)
When Agent A hands work to Agent B, it usually passes an MD file, PDF, document, or other output. It does not pass the reasoning behind the result, the dead ends, or the failures that came before success. Ranganathan compares this with a new human teammate who is given the project's history before starting. Without that history, the second agent re-derives decisions that the first agent already made. The cost is more model calls and more tokens. The output survives the handoff, but the path to the output does not.

### More memory, shared files, raw transcripts, fine-tuning, and large context windows do not create learning
[03:57](https://www.youtube.com/watch?v=9_oy4owGtPI&t=237s)
Ranganathan lists five misconceptions. More agent memory is still only more memory, and it costs more. Shared state, such as an MD file, is not shared knowledge. Putting every transcript into RAG can add garbage and make the model burn more tokens for worse results. Fine-tuning is not a scalable way to persist lessons that agents discover. A bigger context window can become an expensive failure because the context rots. He describes each mistake as an architecture gap rather than a missing amount of storage.

### Shared context needs promotion rules and a source trail
[05:02](https://www.youtube.com/watch?v=9_oy4owGtPI&t=302s)
Ranganathan's proposed context has three properties. Agents can work against the same context, which addresses the lost-context problem. Contributions can be rejected or promoted through a supervised process, like changes to code, so untrusted information does not become durable knowledge. Every retained piece should also be traceable to its source, such as a data source, person, or conversation. This lets a team ask where a fact came from and gives it a way to improve the context instead of treating the knowledge base as an unexamined pile.

### Yugabyte's first infrastructure attempts failed in different ways
[05:42](https://www.youtube.com/watch?v=9_oy4owGtPI&t=342s)
The team first built a large shared knowledge base and a distributed RAG pipeline, but it did not produce useful results. It then tried giving every agent a small PostgreSQL database. That made repeatable workflows get reinvented on the fly. A backend that processed everything without a user interface created another problem: no human could see what was happening. Ranganathan says the absence of a human in the loop produced bad results. The team also found that assembling strong-looking RAG components did not guarantee a good system.

### Tracing individual variables improved RAG while shrinking the context
[06:37](https://www.youtube.com/watch?v=9_oy4owGtPI&t=397s)
Yugabyte initially measured 14% faithfulness on an MD benchmark, 20% on a PDF, and 57% context precision. The team then traced the pipeline, experimented, and tuned one variable at a time. The reported faithfulness moved through 65 and 74 before reaching 82. At the same time, the context went from more than 7,000 chunks to about 1,000 chunks. Ranganathan connects the smaller context with higher precision and lower token spend. The lesson is practical: inspecting the pipeline and changing its parts produced a better result than simply adding more data or more scale.

### Meko separates private agent memory from promoted shared data
[07:27](https://www.youtube.com/watch?v=9_oy4owGtPI&t=447s)
Ranganathan introduces Meko as an agent-native persistence layer built from Yugabyte's mistakes and successful techniques. Its data packs store different aspects of context, including knowledge, memories, conversations, and observability. An agent can put context into a private space and later promote selected pieces into a shared space. Other agents and people can then retrieve the promoted material. The design supports repeatable handoffs while keeping sharing controlled. Ranganathan says the goal is to turn durable, repeatable workflows into infrastructure.

### Promotion lets one agent's discovery become another agent's starting point
[11:25](https://www.youtube.com/watch?v=9_oy4owGtPI&t=685s)
In Heather Downing's demo, a session records that signup emails failed because the team used an SCS sandbox instead of production. After the session is stopped, a fresh session retrieves the incident through Meko without relying on a project or the agent's built-in memory. The same private memory is invisible to a different coding agent, Codex, until it is promoted into shared knowledge. After promotion, Codex can retrieve it. Downing says the promotion can be fine-grained, so a maintainer can share one fact, a best practice, or part of an ongoing process without opening the entire data pack.

### Human promotion is an early training signal for future orchestration
[16:45](https://www.youtube.com/watch?v=9_oy4owGtPI&t=1005s)
Downing describes each human decision to keep a piece of context as a labeled example of what good promotion looks like. She suggests that a future agent could learn an individual user's taste and preferences from these choices. The current system still keeps the human in the loop. Meko also stores language traces and decision traces down to tool calls, which lets a user inspect how a result was produced and whether the system burned tokens retrieving information. The team uses shared data packs for troubleshooting, writing in a user's voice, and helping new people learn tribal knowledge.

## Notable quotes
- Karthik Ranganathan: "Agent memory is a solved problem, but agent learning is not." (00:01)
- Karthik Ranganathan: "I'm only able to give the output. The output being an MD file, a PDF, a document, a something. But I'm not able to give the reasoning behind it." (02:51)
- Karthik Ranganathan: "No human in the loop equals really bad results." (06:16)
- Heather Downing: "Human promotions today kind of equal the training signal for self-improving orchestration tomorrow." (16:48)

## Tools & references mentioned
- Yugabyte DB
- Meko
- Hagen
- Growth Vector
- Perf Advisor
- Voyager
- Claude
- Codex
- ChatGPT
- PostgreSQL
- MCP
- Discord

## Who should watch
- You are building several agents that hand work to one another and want to understand why passing files or answers leaves too much work for the next agent.
- Your RAG system keeps getting larger without improving faithfulness, and you need an example of tracing and tuning individual pipeline variables.
- You need controlled sharing between coding agents, chat agents, and people, with private memories, explicit promotion, and a record of how information was retrieved.

## Editor's note

Karthik Ranganathan says a handoff usually passes an output while leaving the reasoning, dead ends, and failures with the first agent. Kitaru records every model call and tool result in a session, so the team can inspect the path behind a result and replay a failed run after changing the agent's model, prompt, or code.

Written by the AIE Talks editors (the Kitaru team), not by the speaker.

## Related talks

- [No Memory, No Harness: Why the Database Is the Last Line of Defense](https://aietalks.com/talks/no-memory-no-harness-why-the-database-is-the-last-line-of-defense) (Kay Malcolm, Oracle, 21:37)
- [From Context to Memory: Your Agents Need a Real Memory Layer](https://aietalks.com/talks/from-context-to-memory-your-agents-need-a-real-memory-layer) (Anders Swanson, Oracle, 18:20)
- [How We Solved Context Management in Agents](https://aietalks.com/talks/how-we-solved-context-management-in-agents) (Sally-Ann DeLucia, Arize AI, 16:17)
- [Architecting Agent Memory: Principles, Patterns, and Best Practices](https://aietalks.com/talks/architecting-agent-memory-principles-patterns-and-best-practices) (Richmond Alake, MongoDB, 17:37)
- [Stop Using RAG as Memory](https://aietalks.com/talks/stop-using-rag-as-memory) (Daniel Chalef, Zep, 07:02)
