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

Karthik Ranganathan, Yugabyte · Heather Downing, Yugabyte

AI Engineer World's Fair 2026

[Talk page](https://ai.engineer/talks/9_oy4owGtPI-agent-memory-is-solved-agent-learning-isnt) · [Video](https://www.youtube.com/watch?v=9_oy4owGtPI)

## Agent Memory Is Solved. 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.

![Selected presentation frame from Agent Memory Is Solved. Agent Learning Isn't. — Karthik Ranganathan, Yugabyte at 35 seconds](https://ai.engineer/api/talk-essay-media/7303e172b2c5a811fbad96ba9110f49fdfe1a7770cdd5539c4731a94940526f5)

Opening slide: “Agent memory is a solved problem. Agent learning isn’t.”

### A remembered conversation does not teach the next agent

[0:13](https://www.youtube.com/watch?v=9_oy4owGtPI&t=13s)

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 seconds](https://ai.engineer/api/talk-essay-media/d9cc1da27e79dd69bbd6b43e97d874f0d5251deacb67ad8aca8a03135ef497c5)

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.

### Shared context needs selection and a source

[3:42](https://www.youtube.com/watch?v=9_oy4owGtPI&t=222s)

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.

### A scalable RAG pipeline still needed diagnosis

[5:45](https://www.youtube.com/watch?v=9_oy4owGtPI&t=345s)

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 seconds](https://ai.engineer/api/talk-essay-media/475bf4a1b07bf741428ce351d5e647f0fbcad6ad07a80c0051d8cb9d58e27172)

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.

### Data packs make private work available for deliberate reuse

[7:15](https://www.youtube.com/watch?v=9_oy4owGtPI&t=435s)

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.

### Resume an email incident in a fresh session

[10:20](https://www.youtube.com/watch?v=9_oy4owGtPI&t=620s)

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.

### A connected agent cannot read an unpromoted memory

[14:22](https://www.youtube.com/watch?v=9_oy4owGtPI&t=862s)

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
Saving supports a fresh session. Promotion makes the selected incident available to another agent.
- 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)

### Inspect the savings; keep promotion human for now

[16:14](https://www.youtube.com/watch?v=9_oy4owGtPI&t=974s)

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 seconds](https://ai.engineer/api/talk-essay-media/05b17eec2400057315b77ecae1b8d7fd5326f94d5d38d7c246417f9c73a5cf79)

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.

### Turn launch experience into team knowledge

[17:54](https://www.youtube.com/watch?v=9_oy4owGtPI&t=1074s)

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.

## Key takeaways

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

## Related talks

- [Beating RL With Reflection: GEPA and Optimize Anything](https://ai.engineer/talks/OA-Mc60Rboo-beating-rl-reflection-gepa-optimize-anything) — Explores the next step beyond preserving lessons: using execution traces and feedback to improve prompts, agent programs and repository skills.

## Slides

### Agent memory is a solved problem. Agent learning isn't.

The talk explores how to turn one agent’s hard-won result into shared knowledge the whole system can use.

[0:12](https://www.youtube.com/watch?v=9_oy4owGtPI&t=12s) [Title slide introducing shared learning across agents.](https://assets.ai.engineer/sites/aiecode2025/sha256/546e52bba061464f1f56db0fe68c96a75e9f24c9093ac63f8de10483e8d69d76.webp)

Agent memory is a solved problem.
Agent learning isn't.

A field guide to the primitives that turn one agent's hard-won result into knowledge the whole system can use.

Karthik Ranganathan, Co-Founder & Co-CEO
Heather Downing, Developer Advocate
YugabyteDB

### Agent memory is solved. Learning isn't.

An agent can reuse its own memories across sessions. Collective learning means sharing one agent’s results across the system, and the speakers argue it needs different infrastructure.

[0:35](https://www.youtube.com/watch?v=9_oy4owGtPI&t=35s) [Three cards contrast per-agent memory, collective learning, and their infrastructure needs.](https://assets.ai.engineer/sites/aiecode2025/sha256/deaec77d62899b5590ed69c093ced3976364f83eb0560d2a0f59b3d9db5c4cb9.webp)

01 · THE REFRAME

Agent memory is solved. Learning isn't.

Memory works — it’s per agent
mem0, vector stores, episodic recall all work. An agent can remember within and across its own sessions.

Learning is the gap — collective
The unsolved problem: turning one agent's hard-won result into shared knowledge the whole system can use.

Different problems, different infra
Memory is per-agent. Learning is collective. You can't build one on infrastructure meant for the other.

02

### We found the gap the hard way as a database company

Yugabyte used four agents but struggled to ship its own last year, with data infrastructure as the stumbling block. Customers were also demanding more scale and performance.

[1:16](https://www.youtube.com/watch?v=9_oy4owGtPI&t=76s) [Three cards describe agents used for efficiency, the company's infrastructure difficulties, and similar customer problems.](https://assets.ai.engineer/sites/aiecode2025/sha256/26d710498ad974f1525e8b077eaf894ff6ad2296366f1de01c215b8e7c74c364.webp)

01 · WHY WE WORK ON THIS

We found the gap the hard way as a database company

We run agents for efficiency
4 agents we use very heavily:
• Hagen — customer support
• Growth Vector — efficient GTM
• Perf Advisor — DB admin
• Voyager — modernize DBs

We failed at our own game
We are a database company.
But last year, we couldn't ship our own agents - data infra was the stumbling block.
It immediately became personal.

We were not alone
• YugabyteDB = scalable Postgres + vector + graph DB.
• Agentic apps demanded unreasonable scale and perf!
• And no one could explain why.

03

Interface text:
AIE WF26 — Agent Memory [illegible]
3:20 PM - 3:40 PM
Take notes

### Multi-agent systems fail on handoffs, not reasoning

Agent B receives only Agent A’s final output, losing the reasoning, dead ends, and context. It may re-derive decisions or repeat mistakes, spending tokens along the way.

[2:39](https://www.youtube.com/watch?v=9_oy4owGtPI&t=159s) [An agent hands another its final output while losing reasoning, dead ends, and context.](https://assets.ai.engineer/sites/aiecode2025/sha256/d2cef39de019a18d9cedd14446253ea57fdff4174eaba4fa4e5f3a4a75bae9fc.webp)

02 · THE REAL FAILURE MODE

Multi-agent systems fail on handoffs, not reasoning.

Agent A
did the work

hands off

Agent B
inherits…

Gets the final output — and nothing else

Loses the reasoning
Loses the dead-ends
Loses the context

So Agent B re-derives what A already knew, or repeats a mistake A already ruled out.

Human-team analogy:
Onboarding a new hire shouldn't mean re-deriving three months of decisions.
Today, that's exactly what agents do to each other.

04

Interface text:
AIE WF26 — Agent Memory [illegible]
3:20 PM - 3:40 PM
Take notes

### Five things builders assume are learning

Ranganathan argues that more memory, shared state and transcript retrieval do not create shared knowledge. Fine-tuning is costly, while a larger context window cannot decide what to keep.

[3:56](https://www.youtube.com/watch?v=9_oy4owGtPI&t=236s) [Five cards challenge assumptions about memory, shared state, transcript retrieval, fine-tuning, and larger context windows.](https://assets.ai.engineer/sites/aiecode2025/sha256/d699e31b1ceecd3d1643797643dc61c59b73f6212d0b5d60be9d71b02ff2bacf.webp)

03 · MISCONCEPTIONS

Five things builders assume are “learning”... but aren't really

“More memory = learning”
More recall of one agent's history isn't shared knowledge.

“Shared state = shared knowledge”
A shared scratchpad passes data, not understanding.

“RAG over transcripts = learning”
Retrieving raw chat logs re-surfaces noise, not the decision that mattered.

“Fine-tuning is the only way to persist a lesson”
Retraining to teach one fact is a sledgehammer — slow, expensive, lossy.

“A bigger context window fixes it”
Bigger context moves more tokens; it doesn't decide what's worth keeping.

Each one sets up a gap the architecture needs to close.

05

Interface text:
AIE WF26 — Agent Memory [illegible]
3:20 PM - 3:40 PM
Take notes

### Three missing primitives

Context sharing carries work between agents; supervised promotion moves private memory into shared knowledge, with a human deciding today. Decision traces carry the reasoning and dead ends behind a choice.

[4:49](https://www.youtube.com/watch?v=9_oy4owGtPI&t=289s) [Cards explain context sharing, supervised promotion, and decision traces as ways to address losses in agent handoffs.](https://assets.ai.engineer/sites/aiecode2025/sha256/1313e25fe26024cdfd12520355426862449f55d61f922cdf334dfdfc99fcc980.webp)

04 · THREE MISSING PRIMITIVES

Each closes exactly one loss from the handoff

a
Context sharing
CLOSES: LOST CONTEXT
A handoff carries the working context, not just the final artifact — the receiving agent starts where the sender ended instead of re-deriving it.

b
Supervised promotion
CLOSES: NO DURABLE LESSON
Private per-agent memory is promoted into shared knowledge under supervision. A human makes the call today; promoted knowledge resolves on read — no retrain, no reindex.

c
Decision traces
CLOSES: LOST REASONING + DEAD-ENDS
The reasoning and the dead-ends behind a decision travel with it, so the next agent inherits the “why,” not just the “what.”

06

Interface text:
AIE WF26 — Agent Memory [illegible]
3:20 PM - 3:40 PM
Take notes

### What the first build got wrong

A knowledge base missed shared learning, infrastructure sprawl maxed the cluster before 50–100 users, and an API-only interface hid agent activity. The team added shared learning, multi-tenancy and conversation traces.

[5:42](https://www.youtube.com/watch?v=9_oy4owGtPI&t=342s) [Three cards describe lessons about knowledge bases, per-agent databases, and observability.](https://assets.ai.engineer/sites/aiecode2025/sha256/41fb11baf06b9de4871017e13929754ab2aaf95ab690f13f8ca3a9197fc4be7b.webp)

05 · WHAT THE FIRST BUILD GOT WRONG

We built the wrong shape of this a lot before we got it right

“It's just a knowledge base.”

The first vision productized dynamic RAG (pg_dist_rag): upload docs, get an auto-indexed KB. In a multi-agent world that's not enough — agents need shared learning (private memory + a way to promote it), not just document search. That turned a RAG feature into Meko.

“One database per agent.”

The big one. Every agent got its own logical DB; every tenant its own MCP server, RAG workers, tracing. It didn't survive scale — infra sprawl maxed the cluster before 50–100 users. We rebuilt as multi-tenant, isolated by user_id on one Yugabyte cluster (incl. Apache AGE → multi-tenant “mage”). Isolation moved from infra to data.

“No UI. here's your API key.”

We assumed devs would just wire up an endpoint. They couldn't see what agents stored or where tokens went. So observability became first-class: decision traces and execution traces, per conversation, in the portal.

07

### Measuring retrieval improvements

On public datasets, tuning one variable at a time raised faithfulness from 14% to 65% for Markdown and 20% to 74% for PDFs. PDF chunks per query fell from 7,550 to 1,069; the slide credits the re-ranker as the biggest lift.

[6:33](https://www.youtube.com/watch?v=9_oy4owGtPI&t=393s) [Retrieval evaluation results show improved faithfulness and context precision, alongside fewer PDF chunks per query.](https://assets.ai.engineer/sites/aiecode2025/sha256/103430c93cd4a70b1d3bfccbd1ddea6d297863b41f671b191465e95b81a42f56.webp)

05 · ...AND THE RETRIEVAL WASN'T GOOD ENOUGH

So we measured it, one variable at a time

First cut was textbook (fixed chunking · off-the-shelf parser · single cosine). Too much context, too imprecise.
We built an eval harness (RAGAs, public datasets) and changed one thing at a time, so every gain was attributable.

14% → 65%
Faithfulness
markdown set

20% → 74%
Faithfulness
PDF set

5% → 82%
Context precision
PDF · hybrid + re-rank

Chunks retrieved per query (PDF)
Y-axis ticks: 0, 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000
X-axis labels: 1, 2
Bar labels: 7550, 1069

~7–9× fewer chunks per query
PDF: 7,550 → 1,069 (~86% less). The re-ranker was the single biggest lift. Over MCP, those saved tokens land on the user's model, not ours.

Honesty guardrails: public open-source datasets (not Meko production data) · internal before/after on one pipeline (no competitor benchmark) · answer-relevancy barely moved — answers were already on-topic; grounding + retrieval were the broken parts, and that's what changed the game.

08

### What is Meko?

Meko groups knowledge, memory, conversations and observability into shareable datapacks. Agents can promote private context into a shared space for others to retrieve and use in handoffs.

[8:28](https://www.youtube.com/watch?v=9_oy4owGtPI&t=508s) [Meko overview showing datapack components, shared knowledge, hybrid retrieval, context handoff, and a concluding statement about persistent agent context.](https://assets.ai.engineer/sites/aiecode2025/sha256/de2f1f9a02795417fc920e1dd6894e838f9370769c2635f1dfdfb43eeca87a60.webp)

What is Meko?

WHAT IT IS
An agent-native data persistence layer.
Memory, knowledge, and conversations are first-class primitives accessed via MCP.

DATAPACK = one per topic, shareable with RBAC

Knowledge Base
shared static docs · RAG · auto-embeddings

Memory
per-agent notes · graph
RAG · extended Mem0

Conversations
raw text of LLM+human
chat · chain-of-thought

Observability
traces · extended
Langfuse

WHAT MEKO ENABLES
• Shared knowledge + isolated per-agent memory
  one datapack across a whole team of agents
• Hybrid retrieval in a single query
  vector, semantic, and graph together for resumability
• Context handoff & cross-run learning
  with an auditable trail of what was learned

Persistent, shareable agent context & state without building your own.

### Building the talk with Meko

Heather shared her demo outline in a Meko datapack. Karthik used Claude Desktop to build the slides and Claude Design for the diagram, then sent the deck back for her final pass—without a meeting.

[8:35](https://www.youtube.com/watch?v=9_oy4owGtPI&t=515s) [Diagram and notes describe how two presenters shared context to prepare the talk.](https://assets.ai.engineer/sites/aiecode2025/sha256/0330cb4f209c6bad91536c8aac481ece3618e56d4e337a2b7e34fc3d002a6626.webp)

06 · WHAT WE BUILT + LIVE DEMO

First, a confession: we built this talk using Meko

Context sharing + supervised promotion was dogfooded, on the two of us, from memory and context we stored in our own product

Meko datapack
one shared context
sync meeting
(the datapack carried the context)

1
Heather
runs the live demo
harness: her choice
hands over her outline + demo prompt

2
Karthik
gives the talk
Claude Desktop · Claude Design
refines it in his words, saves it back

Two people. Different tools. One shared datapack. Barely a meeting.

Heather → me
Her talk and demo context, dropped into the datapack.

Me → back
Refined in my own words, saved to the same datapack.

We barely talked
Shared context did the coordinating — no meeting needed.

Different harnesses
Mine: Slides - Claude Desktop + Claude Design
Heather's? No idea — and it didn't matter.

09

### Collective knowledge in the demo

The demo will resume an agent with saved reasoning, then promote a private lesson so another agent can retrieve it. The slide presents retrieval as a way to save the user's model tokens.

[10:01](https://www.youtube.com/watch?v=9_oy4owGtPI&t=601s) [Three cards explain resumability, sharing, and retrieval cost.](https://assets.ai.engineer/sites/aiecode2025/sha256/69664afcc0961557ff20e9e5bbb6972212cb123a42766286df30a552a22089b1.webp)

06 · WHAT WE BUILT + LIVE DEMO

Watch collective knowledge grow over time, live

What Meko is: Agent-native memory and context data infrastructure built on YugabyteDB. It has per-agent memory (mem0 + graph) and shared knowledge (RAG retrieval) in one platform, accessed over MCP.

Resumability

An agent stores a decision with its reasoning. Kill the session, start fresh and it recalls the decision without recomputing. “Search is cheaper than inference: I don't need the tokens, I need the answer I already have.”

Sharing

A second agent asks shared knowledge and comes up empty, because the lesson is still private. A human promotes it with one click. Ask it again, and it resolves. No retrain, no reindexing, a different agent picked it up without friction.

Cost

That answer came from a retrieval hit, not a fresh inference pass. Over MCP, the saved tokens are the user's model, not ours. One human promotion made the whole system smarter — for the cost of a search.

10

### Drafting a datapack request

In Claude, the presenter drafts a request to save the early access launch conversation in a new Meko datapack, starting with an incident in which signup emails failed.

[12:17](https://www.youtube.com/watch?v=9_oy4owGtPI&t=737s) [A Claude chat window shows a partially drafted request to store a conversation in Meko.](https://assets.ai.engineer/sites/aiecode2025/sha256/b4e523d900baeb4c2c4f6a3d23f7932e9443d87b4f51745ae3bed1be841c6f43.webp)

Let's store this conversation in a new datapack in meko, about the early access launch.

Turns out the signup emails failed because the

Interface text:
Claude
Back at it, Heather (Quorralyne)
New chat
Chats
Projects
Artifacts
Customize
Products
Code
Cowork
Design
Starred
Garden 2026
Meko AI Launch + AI Assistant
Catching up on quarterly OKRs
Yugabyte's MCP Toolbox integration
Talk outline and agenda developm...
Agent permission architecture fra...
Recents
Saving conversation in Meko
Sonnet 5 High
00:15 / 03:59

### Completing the datapack request

The prompt asks Claude to save an early-access launch incident in a new Meko datapack: signup emails failed when the verification worker dropped messages over the SES sandbox limit. The fix was to use the production SES tier.

[12:28](https://www.youtube.com/watch?v=9_oy4owGtPI&t=748s) [The completed chat prompt asks Meko to store an incident and its resolution.](https://assets.ai.engineer/sites/aiecode2025/sha256/68169eb7f6505a804c0a152346a1141524125ed5a60ed3159d5cfba2c325b26c.webp)

Back at it, Heather (Quorralyne)

Let's store this conversation in a new datapack in meko, about the early access launch.

Turns out the signup emails failed because the verification worker dropped messages over SES's sandbx limit. The fix was to use the prod SES tier.

Interface text:
Claude
New chat
Chats
Projects
Artifacts
Customize
Products
Code
Cowork
Design
Starred
Garden 2026
Meko AI Launch + AI Assistant
Catching up on quarterly OKRs
Yugabyte's MCP Toolbox integration
Talk outline and agenda developm...
Agent permission architecture fra...
Recents
Saving conversation in Meko
Heather (Quorralyne)
Max plan
Sonnet 5 High

### Submitting the incident

The presenter submits an early-access incident to a new Meko datapack. Claude begins finding tools to store the account of signup emails dropped over the SES sandbox limit and the move to the production tier.

[12:42](https://www.youtube.com/watch?v=9_oy4owGtPI&t=762s) [Claude displays the submitted incident description and begins finding tools.](https://assets.ai.engineer/sites/aiecode2025/sha256/70d5a1c7a687834a0a1f2880712aabdee2dd052929ce0532e0d9e5134f64bc46.webp)

Let’s store this conversation in a new datapack in meko, about the early access launch.

Turns out the signup emails failed because the verification worker dropped messages over SES’s sandbox limit. The fix was to use the prod SES tier.

Thinking about documenting an early access launch incident and SES configuration resolution

Found tools
Result

Found tools
Result

Finding tools
Request

Interface text:
Claude
Early access launch datapack and SES sandbox issue
New chat
Chats
Projects
Artifacts
Customize
Products
Code
Cowork
Design
Starred
Garden 2026
Meko AI Launch + AI Assistant
Catching up on quarterly OKRs
Yugabyte’s MCP Toolbox integration
Talk outline and agenda developm...
Agent permission architecture fra...
Recents
Early access launch datapack and ...
Heather (Quorralyne)
Max plan
Write a message...
Sonnet 5 High
Claude is AI and can make mistakes. Please double-check responses.

### Saving an incident as searchable memory

Claude creates an early-access-launch datapack and stores the signup email failure’s cause and fix as a searchable memory. It reports that the memory can be retrieved in future sessions.

[12:52](https://www.youtube.com/watch?v=9_oy4owGtPI&t=772s) [Claude displays a datapack creation call beneath the submitted incident description.](https://assets.ai.engineer/sites/aiecode2025/sha256/dc9cdfc2f20e36b83190975d638f92e878bcd8a0d83f2ef0cfaba32adf235388.webp)

Let’s store this conversation in a new datapack in meko, about the early access launch.

Turns out the signup emails failed because the verification worker dropped messages over SES’s sandbox limit. The fix was to use the prod SES tier.

Thinking about documenting an early access launch incident and SES configuration resolution

Found tools
Result

Found tools
Result

Datapack create
Request
{
  "name": "early-access-launch",
  "scope": "admin"
[remainder obscured]

Interface text:
Claude
Early access launch datapack and SES sandbox issue
New chat
Chats
Projects
Artifacts
Customize
Products
Code
Cowork
Design
Starred
Garden 2026
Meko AI Launch + AI Assistant
Catching up on quarterly OKRs
Yugabyte’s MCP Toolbox integration
Talk outline and agenda developm...
Agent permission architecture fra...
Recents
Early access launch datapack and ...
Sonnet 5 High
Claude is AI and can make mistakes. Please double-check responses.

[13:16](https://www.youtube.com/watch?v=9_oy4owGtPI&t=796s) [Claude confirms that the incident, its cause and fix were stored in a datapack for future retrieval.](https://assets.ai.engineer/sites/aiecode2025/sha256/5da3c723bcf1872d5bdcf9eee35a18cf0abd9ee4cfde0cbcc61b0b6209bf1a38.webp)

Turns out the signup emails failed because the verification worker dropped messages over SES’s sandbox limit. The fix was to use the prod SES tier.

Catalogued incident details and preserved technical resolution

Now storing the incident fact as a searchable memory:

Memory add

Done. Here’s what’s set up:
• Datapack: early-access-launch (new, isolated)
• Conversation: logged this exchange as a message in it
• Memory: root cause and fix stored as a searchable fact — signup verification emails failed because the verification worker dropped messages past SES’s sandbox limit, fixed by moving to the prod SES tier

This will be retrievable in future sessions via memory_search or knowledgebase_search on this datapack.

Interface text:
Claude
Early access launch datapack and SES sandbox issue
Share
New chat
Chats
Projects
Artifacts
Customize
Products
Code
Cowork
Design
Starred
Garden 2026
Meko AI Launch + AI Assistant
Catching up on quarterly OKRs
Yugabyte’s MCP Toolbox integration
Talk outline and agenda developm...
Agent permission architecture fra...
Recents
Early access launch datapack and ...
Write a message...
Sonnet 5 High
Claude is AI and can make mistakes. Please double-check responses.

### Searching memory in a new chat

Claude finds May and June planning notes about signup emails, but neither records why the emails failed. It suggests checking Slack or narrowing the search with more details.

[14:08](https://www.youtube.com/watch?v=9_oy4owGtPI&t=848s) [A new Claude chat reports that its memory search found related context but no recorded cause for the signup email failure.](https://assets.ai.engineer/sites/aiecode2025/sha256/142ee6245f6f3f1203920880f9f482d4c7196425cfc25a40c38006d0ae4baff6.webp)

Meko memory: why did early-access signup emails fail?

Hunted for failure documentation, found only tangential details

I searched Meko memory a few different ways (early-access signup, SES/onboarding email, invite/bounce/broken) and didn't find a stored memory that actually records why the emails failed. What is there, for context:

• A May 29 GTM sync commitment: Heather owed a white-glove onboarding email template (sent via SES) that auto-fires on user first-login, with Nikhil able to push it to prod within a few hours of receiving it from her.
• A June 26 standup decision: open self-signup the following week ahead of a conference, alongside some other system changes.

Neither memory mentions a failure — just the plan to build/ship the email. If the emails did fail, that detail either wasn't captured in Meko yet or lives somewhere else (e.g. a Slack thread, an incident channel, or logs).

Want me to check Slack for a thread on this, or do you have more specifics (which conference, roughly when it happened) so I can narrow the search further?

Interface text:
Claude
Early-access signup email failures
New chat
Chats
Projects
Artifacts
Customize
Code
Cowork
Design
Garden 2026
Meko AI Launch + AI Assistant
Catching up on quarterly OKRs
Yugabyte's MCP Toolbox integration
Talk outline and agenda developm...
Agent permission architecture fra...
Write a message...
Sonnet 5 High
Claude is AI and can make mistakes. Please double-check responses.

[14:12](https://www.youtube.com/watch?v=9_oy4owGtPI&t=852s) [Claude reports finding background on signup emails but no recorded cause for their failure.](https://assets.ai.engineer/sites/aiecode2025/sha256/e321a36521ebcbadec54f7de5e67a98cddf5515d9e65cb69889e04d032da03e2.webp)

Hunted for failure documentation, found only tangential details

I searched Meko memory a few different ways (early-access signup, SES/onboarding email, invite/bounce/broken) and didn't find a stored memory that actually records why the emails failed. What is there, for context:

• A May 29 GTM sync commitment: Heather owed a white-glove onboarding email template (sent via SES) that auto-fires on user first-login, with Nikhil able to push it to prod within a few hours of receiving it from her.
• A June 26 standup decision: open self-signup the following week ahead of a conference, alongside some other system changes.

Neither memory mentions a failure — just the plan to build/ship the email. If the emails did fail, that detail either wasn't captured in Meko yet or lives somewhere else (e.g. a Slack thread, an incident channel, or logs).

Want me to check Slack for a thread on this, or do you have more specifics (which conference, roughly when it happened) so I can narrow the search further?

Interface text:
Claude
Early-access signup email failures
New chat
Chats
Projects
Artifacts
Customize
Code
Cowork
Design
Garden 2026
Meko AI Launch + AI Assistant
Catching up on quarterly OKRs
Yugabyte's MCP Toolbox integration
Talk outline and agenda developm...
Agent permission architecture fra...
Write a message...
Sonnet 5 High
Claude is AI and can make mistakes. Please double-check responses.

### Codex searches shared knowledge

Codex searches Meko for the signup email failure and finds an early-access datapack with zero visible memories and knowledge items. The speaker says the relevant memory is still private and has not been shared.

[14:40](https://www.youtube.com/watch?v=9_oy4owGtPI&t=880s) [Codex reports that searches have not found the signup email failure and continues checking saved conversations.](https://assets.ai.engineer/sites/aiecode2025/sha256/9c81b750febb1809735ad22884fb133e85f592dfafc3ccce263641aafaed326d.webp)

Meko shared knowledge for the early access launch: any known cause for signup emails failing?

Working for 1m 45s

I’ll check the Meko setup first and look for any shared knowledge tied to early access signup email failures, then I’ll report back with whatever looks grounded rather than guessing.

Loaded a tool and used Codex Apps

I’ve got a Meko conversation open for this lookup now. Next I’m checking both saved memory and the shared knowledge base angle, because “known cause” might live in either place depending on how it was captured.

Used Codex Apps integration

The general memory search didn’t surface anything about signup email delivery. I did find the likely shared-knowledge datapack id in the returned metadata, so I’m narrowing the search there now.

Used Codex Apps integration

That narrower pass still came up empty for the specific failure, though the datapack itself is responding. I’m doing one more pass over saved conversations, since incident notes sometimes live as chat history rather than promoted shared knowledge.

[illegible] search

Interface text:
Find signup email failures
New chat
Search
Scheduled
Plugins
Project
Chats
Find signup email failures
Find signup email cause
Find signup email failure...
List my datapacks
List datapacks
What datapacks do I hav...
Summarize Meko project
Uninstall meko MCP ser...
Check launch datapack...
List Meko tools
List Meko MCP tools
Find latest launch datap...
Summarize Meko memo...
Render Slack post
Review saved memory
Outputs
No artifacts yet
Sources
Ask for follow-up changes
Full access
5.5 Medium

[14:52](https://www.youtube.com/watch?v=9_oy4owGtPI&t=892s) [Codex checks memories and shared knowledge for the cause of signup email failures.](https://assets.ai.engineer/sites/aiecode2025/sha256/8206dc3b60ca0936b5f1fb1d24c72c47c91a5ecec805b1256291fe83c8538a13.webp)

I’ll report back with whatever looks grounded rather than guessing.

Loaded a tool and used Codex Apps

I’ve got a Meko conversation open for this lookup now. Next I’m checking both saved memory and the shared knowledge base angle, because “known cause” might live in either place depending on how it was captured.

Used Codex Apps integration

The general memory search didn’t surface anything about signup email delivery. I did find the likely shared-knowledge datapack id in the returned metadata, so I’m narrowing the search there now.

Used Codex Apps integration

That narrower pass still came up empty for the specific failure, though the datapack itself is responding. I’m doing one more pass over saved conversations, since incident notes sometimes live as chat history rather than promoted shared knowledge.

Used Codex Apps integration

The conversation-list tool is being picky about the datapack field name, but it told me the field it wants. I’m retrying with that exact shape rather than treating the first failure as meaningful.

Used Codex Apps integration

I found the older note saying the launch datapack is named launch_project. I’m switching to that datapack now; that’s the more likely home for early access launch notes.

Thinking

There is a brand-new early-access-launch datapack from today, but its visible counters show zero memories and zero knowledge items. I’m checking it anyway, plus the older launch/support datapacks, in case the issue was logged as a conversation or database row.

Interface text:
Find signup email failures
New chat
Search
Scheduled
Plugins
Project
Chats
Find signup email failures
Find signup email cause
Find signup email failure...
List my datapacks
List datapacks
What datapacks do I hav...
Summarize Meko project
Uninstall meko MCP ser...
Check launch datapack...
List Meko tools
List Meko MCP tools
Find latest launch datap...
Summarize Meko memo...
Render Slack post
Review saved memory
Outputs
No artifacts yet
Sources
Ask for follow-up changes
Full access
5.5 Medium

### Initial search result

Codex finds no recorded cause for the signup email failures. The speaker explains that the relevant private memory had not yet been shared; Codex also could not inspect structured database tables.

[15:30](https://www.youtube.com/watch?v=9_oy4owGtPI&t=930s) [Codex reports that it found no recorded cause and could not inspect structured database tables.](https://assets.ai.engineer/sites/aiecode2025/sha256/09f844ca7fb7263b923be851b4d8d229ab8e98571ca30d0d9c79a74bea05802c.webp)

I found the older note saying the launch datapack is named launch_project. I'm switching to that datapack now; that's the more likely home for early access launch notes.

Used Codex Apps integration

There is a brand-new early-access-launch datapack from today, but its visible counters show zero memories and zero knowledge items. I'm checking it anyway, plus the older launch/support datapacks, in case the issue was logged as a conversation or database row.

Used Codex Apps integration

So far: no matching shared-knowledge item in the new early-access datapack, and the older launch/support hits are mostly general FAQ and infra notes. I'm doing a quick database-schema check on the new datapack before I close the loop, just in case the answer is tucked in structured incident data.

Used Codex Apps integration

The database-summary tool is advertised but not callable in this connection, so I can't verify structured tables through that route. The memory and shared-knowledge searches across the relevant datapacks are clean for this specific issue.

Meko prod conversation add message

I don't see a known cause recorded in Meko shared knowledge.

I checked the new early-access-launch datapack, the older launch_project datapack, support-project, and default Meko memory/knowledge. Searches for signup emails, confirmation emails, SMTP, Resend, Supabase, DNS/SPF/DKIM, and related terms didn't return a relevant cause.

The only nearby items were general launch/request-access notes and unrelated infra notes like Railway downtime and env-var migration risk. One caveat: Meko's database-summary tool was listed but not callable in this connection, so I couldn't inspect any structured database tables.

Same question again. [illegible]

Interface text:
Find signup email failures
New chat
Search
Scheduled
Plugins
Project
Chats
Find signup email failures
Find signup email cause
List my datapacks
List datapacks
Summarize Meko project
List Meko tools
List Meko MCP tools
Render Slack post
Review saved memory
Outputs
No artifacts yet
Sources
Full access
5.5 Medium

### Retry finds a shared result

After a memory is promoted, Codex finds that signup emails failed when volume exceeded the AWS SES sandbox limit. The recorded fix is to move SES to the production tier; the raw memory ID did not resolve.

[15:52](https://www.youtube.com/watch?v=9_oy4owGtPI&t=952s) [Codex reports a shared-knowledge result identifying an email sending limit and a recorded fix.](https://assets.ai.engineer/sites/aiecode2025/sha256/630443591326a502e8bbe56cd3937f0808a28c360a5d2b65586896efb433350b.webp)

Find signup email failures

Worked for 4m 6s

I don't see a known cause recorded in Meko shared knowledge.

I checked the new early-access-launch datapack, the older launch_project datapack, support-project, and default Meko memory/knowledge. Searches for signup emails, confirmation emails, SMTP, Resend, Supabase, DNS/SPF/DKIM, and related terms didn't return a relevant cause.

The only nearby items were general launch/request-access notes and unrelated infra notes like Railway downtimes and env-var migration risk. One caveat: Meko's database-summary tool was listed but not callable in this connection, so I couldn't inspect any structured database tables.

Same question again. any known cause for signup emails failing? Check the launch early access datapack again.

Worked for 1m 2s

Yes. The early-access-launch datapack now has a specific shared-knowledge hit:

Signup verification emails failed because the verification worker dropped messages once volume exceeded the AWS SES sandbox limit.

The recorded fix: move AWS SES to the production tier.

Small caveat: the hit references a claude-desktop memory source, but that raw memory ID didn't resolve when I cross-checked it through the memory API. The shared-knowledge entry itself is direct and specific.

Interface text:
New chat
Search
Scheduled
Plugins
Project
Chats
Find signup email failures
Find signup email cause
Find signup email failure...
List my datapacks
List datapacks
what datapacks do i hav...
Summarize Meko project
Uninstall meko MCP ser...
Check launch datapack...
List Meko tools
List Meko MCP tools
Find latest launch datap...
Summarize Meko memo...
Render Slack post
Review saved memory
Outputs
No artifacts yet
Sources
Ask for follow-up changes
Full access
5.5 Medium

### Memory extraction trace

The trace follows memory creation through a vector update and query, then shows the signup-email incident promoted to shared knowledge. The speaker says traces can help inspect tool calls and token use.

[16:35](https://www.youtube.com/watch?v=9_oy4owGtPI&t=995s) [A message trace shows memory creation steps and an extracted memory promoted to the knowledge base.](https://assets.ai.engineer/sites/aiecode2025/sha256/76d17310d9c4b0521c11ceb169e4d6d91bcb6a8d1d27b389ad169c17ac6c483d.webp)

Message trace
8 spans · 19.41s
[illegible]

Timeline: 0ms, 25%, 50%, 75%, 19.41s
Conversation Create (Meko MCP) · +0ms · [illegible]
Conversation Add Message (Meko MCP) · [illegible]
  Conversation Message Added · [illegible]
  Reasoning · [illegible]
Memory Add (Meko MCP) · +9.10s · 10.30s
  Create a new memory in Mem0 · +9.11s · 10.30s
    Bulk Payload Update (yugabytedb / vector) · +19.30s · 104ms
    Execute Query (yugabytedb / vector) · +19.30s · 99ms
    View query

Extracted memories 1
Promoted memories 1

Memory Add (Meko MCP) #1 · 10.30s
Early access launch incident: signup verification emails failed to send because the verification worker dropped messages once volume exceeded AWS SES’s sandbox limit. Fix: moved SES to the production (prod) tier.

Promoted to knowledge base
Now a shared knowledge entry

View Detailed Trace

Interface text:
Meko
Welcome
Connect
WorkbenchLM
Datapacks
Conversations
Search conversations...
Early Access Launch
Observe
EARLY ACCESS
Read the docs
Feedback
Join us on Discord
Sign out

### Human promotions as a training signal

Humans currently decide what to promote. Those decisions could train a future orchestrator to make promotions itself, helping agents build shared knowledge.

[16:45](https://www.youtube.com/watch?v=9_oy4owGtPI&t=1005s) [Three points describe how human promotion decisions could train future orchestration and compound collective knowledge.](https://assets.ai.engineer/sites/aiecode2025/sha256/94dd15014e7d2c7bf2231a0f6989d3885b4072a0fc8a5e70696a65d4fa9f8a20.webp)

07 · WHERE THIS GOES

Human promotions today = the training signal for self-improving orchestration tomorrow

1 Every human that says “this is worth keeping” is a labeled example of what good promotion looks like.
2 Those calls become the signal a future orchestrator agent learns from — until it promotes on its own.
3 The system starts learning how to learn. Collective knowledge compounds without a human in every loop.

Stop optimizing what agents remember.
Start optimizing what they learn together.

11

### Thank you

Sign up for Meko’s free tier at mekodata.ai, or join the Discord to share feedback and hear about improvements.

[19:43](https://www.youtube.com/watch?v=9_oy4owGtPI&t=1183s) [Thank-you slide with QR codes for early access and the community Discord.](https://assets.ai.engineer/sites/aiecode2025/sha256/4018a79b14091877de76f653bbdc0f68b6c888902a5537d80e11c20be0ee7996.webp)

yugabyteDB

Thank You

meko
Self-Sign Up for Early Access:
mekodata.ai

meko
Join Us on Discord:
discord.gg/yubabyte

13

## Full transcript

[0:13](https://www.youtube.com/watch?v=9_oy4owGtPI&t=13s) Good to meet you folks. Thanks for everyone who's here. Um, today we're gonna talk about sharing context, right? Everything in AI is about the data you give it. Bad data, bad outputs, right? Agent memory is a solved problem, but agent learning is not. And we're gonna talk about not just like, you know, w-what we're building, et cetera, it's about how, why we built it and how we're using it for ourselves. Okay. So as we said, agent memory works, you know. There's a bunch of stuff you feed

[0:43](https://www.youtube.com/watch?v=9_oy4owGtPI&t=43s) it, conversations, et cetera, and you're able to extract memories from the conversation, and agents are able to reuse them. It's per agent. However, learning is never done in isolation. It's when a group of agents come together and need to work with each other, they have to now start learning and sharing, right? And that is an unsolved problem because we're infrastructure people and infrastructure built for a single agent to do memory is often not the

[1:12](https://www.youtube.com/watch?v=9_oy4owGtPI&t=72s) same infrastructure that is needed in order to learn, right? We're gonna talk a little bit more about that. Okay. So by way of background, I'm Karthik, one of the co-founders and the CEO of a database company, YugabyteDB, right? So what the hell are we doing here? Why are we building a agentic data infrastructure? What are we doing, doing that, right? We actually found this the hard way. We run agents for ourselves. We run two agents internal to the company, Hagen for customer support and

[1:42](https://www.youtube.com/watch?v=9_oy4owGtPI&t=102s) Growth Vector for a coordinated go-to-market between sales and marketing. And we run two agents externally for our customers and users. The first one is PerfAdvisor, which is an agentic database admin, right? So it runs databases for our customers. As a database company, pretty useful. And Voyager, which helps them migrate and modernize from other databases to a cloud-native one, right? So four agents. We failed to ship anything and make it work at all. It was really hard. We've been trying for almost a

[2:12](https://www.youtube.com/watch?v=9_oy4owGtPI&t=132s) year before we realized we were failing at the data problem, right? And if a database company is failing at a data problem, be it for agentic, it becomes personal, right? So yes, it became personal. We're like, "What the hell is going on?" And when we then realized that a lot of people were asking us like, "Yes, we can do scalable vectors, we can do scalable graph, we can do scalable relational." Or people came to us and said, "More scale, more performance, less cost." We're like, "Wait a minute. At some point this is ridiculous, right? It's breaking the laws of physics." So

[2:42](https://www.youtube.com/watch?v=9_oy4owGtPI&t=162s) what is the real failure, right? When you cut everything a-apart and just go to the core, it's because Agent A, my agent, is doing some work and I need to work with, say, one of you guys. Say maybe Heather, right? My other-- Who's gonna be showing a demo, and I am not able to give that context. 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, right? So what does this

[3:12](https://www.youtube.com/watch?v=9_oy4owGtPI&t=192s) lose? This loses reasoning. This loses the dead ends, the number of failures you've had before you actually succeeded, and it loses the whole context, right? That means Heather's agent is going to be rederiving all of this stuff, and it's not for free. You're burning tokens and paying somebody else for it. This is the same as a group of humans working together. When a new person joins the team, they're going to be told, "We're going to do X." And they come up with fifty reasons why we should do something else,

[3:42](https://www.youtube.com/watch?v=9_oy4owGtPI&t=222s) and each time, "Yes. We considered that two weeks ago, two months ago." That's not how humans operate. We actually bring the person in and says, "Okay, look, this is the context. This is the history of the project. This is how it's done. Now let's go from here." That context is missing for agents. So five things, misconceptions, okay? Really quick. More memory, agentic memory, is not learning. It's just more memory, right? Like, it's more expensive. Shared state is not shared knowledge. Just because you can

[4:12](https://www.youtube.com/watch?v=9_oy4owGtPI&t=252s) share something with somebody else, like an MD file or something, doesn't mean you have shared knowledge. RAG transcripts, let me RAG everything, is not equal to learning and quality. It just means there's a whole bunch of garbage there and now LLMs get to burn even more tokens to give you even worse results. Fine-tuning is not scalable. You cannot, you know, save and persist lessons that agents have come up with through fine-tuning and building custom infrastructure. And a bigger context window is the surest way to

[4:42](https://www.youtube.com/watch?v=9_oy4owGtPI&t=282s) quickest failure in an expensive manner, right? 'Cause it doesn't do anything. Your context rots. Every single one of these is a architecture gap, right? So this is what we realized we needed to plug for ourselves, right? And we've been finding a lot of users are, are really enjoying and really liking this approach of thinking about context. Firstly, if there's a context that Agent A can share with Agent B, it closes the lost context problem. They're working on the same context.

[5:12](https://www.youtube.com/watch?v=9_oy4owGtPI&t=312s) Second thing is this context can degrade. That means not everybody can contribute to that context. It's just like code. Not anyone can contribute. You need to go through a process of supervised promotion, and only then does it make it durable. And lastly, you need to be able to ask your-- the question, where the hell did this piece of information come from? It makes no sense at all. And be tr-able to trace it back to something, a data source, a person, a conversation from which it was extracted, and that's the first step to improving your context.

[5:42](https://www.youtube.com/watch?v=9_oy4owGtPI&t=342s) So

[5:45](https://www.youtube.com/watch?v=9_oy4owGtPI&t=345s) we started building this by assuming, how hard can it be? So the first thing we did was, it's just a knowledge base. We throw everything in the knowledge base, it's gonna be great, right? And how wrong we were. We built a whole distributed RAG pipeline, extremely scalable, very elastic, amazing. It was just amazing, right? And it didn't do anything good for us. And then we said, "You know what? This whole shared stuff doesn't work. We'll let every agent spin up a tiny database. We're a database company. How hard can it be? Tiny Postgres, make it efficient." Well, we realized that every

[6:15](https://www.youtube.com/watch?v=9_oy4owGtPI&t=375s) repeatable workflow was being reinvented on the fly. Didn't work at all. And then we said, "Okay, fine. We'll just have some back end that does a whole bunch of processing and, you know, we'll just, you know, not even bother with a UI 'cause agents don't need UI." And then we realized we couldn't tell what was going on. No human in the loop equals really bad results. Okay. And then we thought, "Okay, at least we have the RAG pipeline." Well, it turned out even that was shitty 'cause, you know, we took all the best components from the, you know, whatever the academia,

[6:45](https://www.youtube.com/watch?v=9_oy4owGtPI&t=405s) academia says, and we put it all in there, and we got poor numbers. 14% faithfulness using an MD benchmark, public benchmark. 20% on a PDF. 57% context precision using all of this other stuff. And when we actually started looking and tracing and doing our traces and tuning and experimenting, we realized a lot of things were off. And as we improved them one variable at a time, we were able to jump to 65, 74, 82, right? And here's the kicker. Our

[7:15](https://www.youtube.com/watch?v=9_oy4owGtPI&t=435s) context chunks, which is the context size, went down from over 7,000 chunks to about 1,000 chunks. So one-seventh the context size, a lot higher precision, and a lot less money burned on tokens, right? So that's where Meko comes in. What is Meko? It's a agent-native persistence layer that takes all the mistakes we made and all the things we got right and puts it into one box, right? And the way Meko works, it exposes a

[7:45](https://www.youtube.com/watch?v=9_oy4owGtPI&t=465s) data pack, right? As a database company, we don't call it a database 'cause it has multiple types of databases: vector, graph, relational, NoSQL, whatever, right? And what it does is stores aspects of the context, knowledge base, memory, conversations, observability, a lot more, right? And what it enables is it enables agents to come in and push pieces of their context into a private space and promote that to a shared space, right? And then

[8:15](https://www.youtube.com/watch?v=9_oy4owGtPI&t=495s) other agents or humans that come in can now go against that promoted high-quality context and quickly retrieve stuff, and you can now continue to add more people and more agents and do the handoff efficiently, right? Hopefully that makes sense. Um, the idea is take the durable, repeatable workflows and make it infrastructure. Okay. Before we go into a demo, right? A confession. This slide deck that you're looking at was built

[8:45](https://www.youtube.com/watch?v=9_oy4owGtPI&t=525s) using Meko as the context persistence layer, right? The way it worked was Heather, who's gonna give you, show you the demo, actually wrote up an outline and created a data pack in Meko and simply sh- sent me a share request, right? And she said, "I'm doing the demo. Here's the outline of my demo. Here's the rough talk track that needs to lead up to it 'cause that's what makes sense." I took it, and I'm, I'm sure she used some agent harness. I don't know what it is. I really don't know. I didn't ask her. I didn't even have a meeting with her. She just sent me

[9:15](https://www.youtube.com/watch?v=9_oy4owGtPI&t=555s) this. I plugged it into my Claude Desktop and said, "Take this outline and break it down for me," and it gave me a few bullet points. This is what you're talking about. I'm like, "Okay, great. I wanna change a couple of things." Changed a couple of things and said, "Here's the new outline. Can you build me my slide deck based on this?" And it did. And that diagram on the left, it built a really crappy diagram, right? It didn't look good at all. So I said, like, "You know what? Everyone's saying this, uh, Claude Design is the rage, so why don't I give that thing a go?" And it actually did a better job. So, you know, there you

[9:45](https://www.youtube.com/watch?v=9_oy4owGtPI&t=585s) go. That image came from Claude Design. Everything else came from Claude Desktop. Shot it back to Heather, and, you know, Heather took the final pass over it to get, hook it up with the demo, and here we are. So we barely talked, right? We didn't need to. We just shared context, and our agents did the work. And, uh, you know, you can go, you can watch it. I think maybe I'll invite Heather to talk to this slide and, and the thing after. I hope the demo's good 'cause I haven't seen it myself, so yeah.

[10:20](https://www.youtube.com/watch?v=9_oy4owGtPI&t=620s) The idea is to watch collective knowledge grow over time, right? What Meko provides, uh, that I was able to use for this is the resumability. So resumability, I'm going to show you, is being able to start a session and then kill it and then start it again with the same agent. Right now, if you do it with something like Claude Desktop, they have projects for this, right? So if you do a Claude project, everything's together, or if you turn on memory. But in this case, I guess like two months ago, I turned off all the memory on all of my

[10:50](https://www.youtube.com/watch?v=9_oy4owGtPI&t=650s) IDEs because it doesn't matter. What if I use something while I'm on the go, like a mobile app? Maybe I use ChatGPT that isn't as sophisticated, right, as some of my coding IDEs. And so maybe I wanna continue working on that topic. I can do that because all of the context is shared in our cloud now. And by sharing, I mean that obviously ChatGPT is a different, um, agent, but it's still my account, so I should be able to get to it, right? But because we're security-focused and security-minded, we don't want like just any

[11:20](https://www.youtube.com/watch?v=9_oy4owGtPI&t=680s) agent to get to it. So I have to promote the kind of memory that that agent can also retrieve in like a collective pool. And because you do this, the cost itself goes down tremendously. 'Cause the first time I figure stuff out, I'm going back and forth with my LLM. I'm burning lots of tokens to get to an end goal, whether that is code or it's just a knowledge work. But the next time that I want to retrieve it from another agent or another session, it doesn't need to burn through that. It just calls to the Meko

[11:50](https://www.youtube.com/watch?v=9_oy4owGtPI&t=710s) memory, and then it brings it right back with far less tokens. So we're already saving a lot of token spend. The alternative to this would be to just, again, keep things in empty files or keep things where you have to constantly traverse with every single agent's LLM and burn through tokens again and again in order to retrieve. Does that make sense? The difference here is just an MCP tool call. So to kind of prove that out, because we have sensational internet here, I have recorded  this for you at a

[12:20](https://www.youtube.com/watch?v=9_oy4owGtPI&t=740s) little bit of a faster speed, hopefully. All right, see this is resumability. So here I'm saying that I wanna store, um, the conversation in a certain data pack, right? Uh, let's call it the early access launch, and I wanna put a piece of information in it. In this case, um, our sign-up emails failed, true story, because we actually only use the SCS's sandbox instead of the prod. So, uh, we kind of went over the limit there  when we were testing things, and that's a good piece of information for

[12:50](https://www.youtube.com/watch?v=9_oy4owGtPI&t=770s) maybe our, our ops team, right? So in this process, it's calling data pack create, uh, because I've connected the MCP server to Claude here, and I've created a skill that will tell it what to do. You can decide how often you want it to call or if you just wanna do it judiciously here. And so now it's storing the incident fact as a searchable memory with memory add, and then it's done now. So the data pack has been created. There's a conversation in there,

[13:20](https://www.youtube.com/watch?v=9_oy4owGtPI&t=800s) and it'll be retrievable in the f- in the future sessions. That sounds great. Awesome. Now I've killed that session, and notice I'm not in projects. This is just a new chat window. Now I'm going to ask the same question so I can resume. Before I had to, again, have to make sure I turn on Claude Memory or turn... or put it inside of a project, but it's not in either one of these. I could be logged in with the same account in like claude.ai, which would be technically a different agent. So I'm trying to prove that you can at least resume your

[13:50](https://www.youtube.com/watch?v=9_oy4owGtPI&t=830s) sessions after maybe days with the same agent. So the failure result there was actually that it tried to search first instead of creating, uh, a conversation, a new conversation here. We wanna save every one that we do, so it's the MCP server instructing to create like a new conversation for it so we can store this. And see now they searched Meko and it found that, hey, this is what happened back in May, and it was able to pull things back out.

[14:22](https://www.youtube.com/watch?v=9_oy4owGtPI&t=862s) All right. For shareability, let's go ahead and get this done. If you notice, this is a completely different IDE. In this case, it's Codex. Um, so I've asked it questions like, "Okay, um, do you have any known cause for the sign-up emails that are failing?" And so it's gonna look, and it's gonna look, and it says, "No, I don't see anything. I don't see anything. I'm looking." Um, it did say that it saw that there was a brand-new, uh, data pack that it's connected to,

[14:52](https://www.youtube.com/watch?v=9_oy4owGtPI&t=892s) but it can't actually see anything. And why is that? Because I actually haven't shared that private memory from my Claude Desktop yet, uh, into a shared space. So right now, those memories are still private. If you notice, the early access data pack is seen because I have connected it, but I just haven't promoted it yet. So in that case, I'm gonna go to sign out, and I'm gonna sign in with my other account here to show you that, yes, I do have access to this data pack, and I need to

[15:22](https://www.youtube.com/watch?v=9_oy4owGtPI&t=922s) promote that piece of memory into a shared knowledge space. Allow it to go ahead and, and go through, and then I... it says it doesn't see it. But I said, "Well, same question. Let's try it again."

[15:38](https://www.youtube.com/watch?v=9_oy4owGtPI&t=938s) So now that I've promoted it into that space, sped up for your pleasure here,  because we all know how long-winded our LLMs can get, um, now it can find that piece of memory. It can find the piece of memory because I have allowed that one piece to go. It's very fine-grained. It doesn't have to be. You can open the whole data pack if you want as a maintainer to it, but this is much more ideal if you're just trying to give bespoke pieces of information, maybe best practices, maybe something that

[16:07](https://www.youtube.com/watch?v=9_oy4owGtPI&t=967s) is the ongoing process that you want to keep going.

[16:14](https://www.youtube.com/watch?v=9_oy4owGtPI&t=974s) And then, like the last part of this is the cost. How do you even know that it saves you tokens? If you go into your data pack, you can look at the conversations that are stored in there and how they were done, because we give you embedded Langfuse traces for free in this, and you can actually look at the decision trace all the way down to the tool call and prove whether or not it called as much and burned as many tokens.

[16:43](https://www.youtube.com/watch?v=9_oy4owGtPI&t=1003s) Right.

[16:49](https://www.youtube.com/watch?v=9_oy4owGtPI&t=1009s) So human promotions today kind of equal the training signal for self-improving orchestration tomorrow. Every human that says this is worth keeping is kind of a labeled example of what good promotion looks like. So you can actually start training maybe in the future an agent that's trained on your taste and your preferences long term. But right now, we're keeping the human in the loop. Those calls are just a signal, but this is actually how it starts to learn. The biggest lift that I saw is that when something goes wrong, maybe in a

[17:19](https://www.youtube.com/watch?v=9_oy4owGtPI&t=1039s) support situation, it's hard to constantly have calls call the same server that's down all the time, and then it's... tells all this time, "Hey, do you know if this is down? Is that down?" Slack starts blowing up. How do your agents handle that? They're all also wasting tokens calling the same thing. If they had access to the data pack, the first agent would hit it and then tell everybody that it happened, and all the other agents would know that it already happened.

[17:50](https://www.youtube.com/watch?v=9_oy4owGtPI&t=1070s) Hmm?

[17:52](https://www.youtube.com/watch?v=9_oy4owGtPI&t=1072s) Hmm?

[17:52](https://www.youtube.com/watch?v=9_oy4owGtPI&t=1072s) Yeah, so-

[17:54](https://www.youtube.com/watch?v=9_oy4owGtPI&t=1074s) Yeah. So thank you, Heather. Like, I think, you know, pretty awesome demo. I think, uh, if you folks were following along what happened, Heather was, was in charge of the early access and launch of Meko, right? And obviously used a data pack, which is Meko, to launch Meko, right? Recursively.  And, uh, you know, the first few people had a lot of trouble accessing their data packs on Meko and, you know, we-- you know, she created a data pack for troubleshooting issues with Meko, a different data pack, and so that's the thing that she was talking about.

[18:25](https://www.youtube.com/watch?v=9_oy4owGtPI&t=1105s) Uh, a lot of us in the company, you know, it's shared with us, so we're all able to look at it, load it into our agents, and able to iterate with it. The folks that are in, in, in engineering, they load it straight into their, you know, Claude Code or Codex or, like, you know, whatever the coding agents are. Like, I, I myself am more of a Claude Desktop kinda user. I use it for other things like, you know, some... A user that wanted to get access, couldn't get access, apology email, like, go to Claude, help me design it, have a da- I have a data pack actually that is my voice of

[18:54](https://www.youtube.com/watch?v=9_oy4owGtPI&t=1134s) how I speak, and same thing for posting on LinkedIn. I think it can get tiresome if you wanna keep writing it in your voice. You know, sometimes training a data pack for the context to do so will help. So a lot of these things get automated away, and it gets, you know, makes it much, much quicker to assemble, right? And obviously, if a new person comes into the team, very easy to share this context with them, have them get up to speed, have them contribute to it, either willingly or unwillingly, right? Sometimes they're just doing things they don't even know, and you extract patterns out of it. "Oh, this is really great. We should make this a thing," right? So,

[19:25](https://www.youtube.com/watch?v=9_oy4owGtPI&t=1165s) so, like, um, yeah. So I think these are some of the things. Anyways, I think the bottom line is we're trying to get it closer and closer to how humans work, which is how can you capture tribal knowledge? How can you share that? How can you give controls over sharing? And how can you actually tell what's going on, right?

[19:40](https://www.youtube.com/watch?v=9_oy4owGtPI&t=1180s) Yep.

[19:40](https://www.youtube.com/watch?v=9_oy4owGtPI&t=1180s) Um, yeah. So I think-

[19:41](https://www.youtube.com/watch?v=9_oy4owGtPI&t=1181s) You should, you should try it for free.

[19:43](https://www.youtube.com/watch?v=9_oy4owGtPI&t=1183s) Yeah.

[19:43](https://www.youtube.com/watch?v=9_oy4owGtPI&t=1183s) If you want.

[19:44](https://www.youtube.com/watch?v=9_oy4owGtPI&t=1184s) Yeah. Try it for free. Yeah. I think the left side is, you know, uh, the website, mekodata.ai, which will take you to a login. There's a free tier. You can sign up and just hook it up to one of your agents and, you know, get your agents to start learning, right? Right away. And the right side is Discord. We'd love to hear from you. If you do try it out, you know, do drop us a note. We're working on improvements. That's how we communicate what we're building. So do join us on Discord, right? We'd love to see you guys there. So I think that brings us... Yeah. Thank you. Thanks. Yeah. If we have-- Yeah. We're right on time, actually. Yeah. So...

[20:14](https://www.youtube.com/watch?v=9_oy4owGtPI&t=1214s) Yeah. Thank you. If you guys have questions, please feel free to connect with us on the site. Thank you.
