AI agents are good at reasoning.
They are not always good at remembering what already happened somewhere else.
You may spend an hour teaching one coding agent about a project, switch to another tool the next day, and discover that you’re explaining the same architecture, decisions, and preferences all over again.
The problem gets even bigger with multi-agent systems. Agent A discovers something useful, but Agent B starts from scratch because that learning never became shared context.
Meko is designed to solve that problem.
Meko is an agent-native context layer for persistent memory, shared knowledge, conversations, and decision traces. It lives independently of any one AI model or client and connects to agents through MCP.
🆕 Meet Meko
conversations, and decision traces.
Meko lets that context persist across agents, tools, sessions, and time.
The Problem: Every Agent Starts Over
Without a shared context layer, an agent’s useful discoveries can remain isolated inside one conversation or tool.
The result can look something like this:
Meko changes that model.
Your agents connect to the same context layer, allowing knowledge and selected learnings to survive tool changes and agent handoffs. Meko is private by default, and you decide what gets shared.
The Core Building Block: A Datapack
The fundamental unit in Meko is called a datapack.
Think of a datapack as the shared context container for an application, project, or group of agents working together.
A datapack combines the information agents need to remember and share with the infrastructure required to retrieve it. Meko documentation recommends roughly one datapack per application or project, and treats the datapack as the isolation boundary for cooperating agents.
At the conceptual level, a datapack contains four important things:
A simple way to visualize it:
Memory That Survives the Session
A normal chat session has an obvious limitation: eventually the session ends.
Meko stores durable memories outside the model session so they can be retrieved later. These memories can include facts, preferences, decisions, and other useful information extracted from conversations. Retrieval combines semantic, keyword, and entity-aware techniques.
That gives you a different workflow:
Private Memory vs. Shared Knowledge
This distinction is important.
Not everything one agent remembers should automatically become shared knowledge.
Meko keeps memories scoped appropriately and allows reviewed memories to be promoted into the shared knowledge layer. That lets you preserve private or agent-specific context while deliberately sharing the information that should become common knowledge.
Build a Knowledge Base Without Building the Pipeline
You can also upload documents directly into a datapack knowledge base.
Meko handles document chunking, embedding, indexing, and retrieval so agents can search that material without you first building a separate preprocessing and RAG pipeline.
That means things like:
- ● architecture documents
- ● Markdown
- ● PDFs
- ● standards and procedures
- ● product documentation
- ● project notes
can become searchable context for every authorized agent using the datapack.
Switch Tools Without Losing the Project
Meko sits outside any one AI vendor.
That means your project context is not tied exclusively to one model, coding assistant, or chat application. Both Meko’s site and current documentation list integrations with tools such as ChatGPT, Claude, Codex, Cursor, VS Code, Claude Code, and other MCP-capable clients.
Conceptually:
One MCP Endpoint
Meko exposes its context layer through a hosted MCP server.
Your AI client connects to Meko, authenticates, and then uses MCP tools to search knowledge, recall memory, persist conversations, and interact with datapacks.
All datapacks use the same hosted MCP endpoint; the datapack ID or name supplied in the MCP call determines which datapack is being accessed.
Decision Traces: See What Happened
Persistent context becomes much more useful when you can also understand how it got there.
Meko records decision traces that connect conversations to memory and knowledge operations, searches, tool calls, API and SQL activity, and retrieved results.
That gives developers and operators a way to inspect:
- ● what information an agent searched
- ● what memory it retrieved
- ● what knowledge it used
- ● what tools were invoked
- ● what was written back
- ● how much work or token usage was associated with an interaction
That becomes especially important when multiple agents are continuously learning from one another.
Recall Instead of Regenerate
There is also an economic benefit to shared context.
If another agent has already researched a problem, parsed a document, or reached a useful conclusion, the next agent can retrieve that result instead of feeding the same source material back through an LLM and paying to reason through it again.
Meko explicitly encourages agents to recall previously computed context instead of regenerating it.
The idea is straightforward:
You Don’t Have to Build a Patchwork Data Stack
Agent context often ends up spread across multiple specialized systems:
- ● Relational database
- ● Vector database
- ● Graph database
- ● Object storage
- ● RAG pipeline
- ● Conversation store
- ● Tracing system
Meko hides much of that complexity behind agent-native constructs such as memory, knowledge, conversations, and traces. Its unified data layer combines vector, SQL, graph, search, and other storage/retrieval capabilities behind a PostgreSQL-compatible platform.
Built on YugabyteDB
This is where Meko becomes especially relevant to readers of yugabytedb.tips.
Meko’s persistent data layer is built on YugabyteDB. Meko uses a unified distributed PostgreSQL-compatible platform for relational, vector, graph, document, and search-oriented workloads instead of requiring agents to assemble those capabilities from independent databases.
Meko and AMP Solve Different Problems
This is worth calling out, especially if you’ve already read the introductory YugabyteDB AMP Tip, Meet YugabyteDB AMP: A PostgreSQL Database for Every Agent.
AMP gives agents databases.
Meko gives agents shared context.
Yugabyte describes AMP as the database platform for fleets of agents, while Meko provides persistent memory, shared knowledge, conversation history, and decision traces that agents access through MCP.
They complement each other rather than replace each other.
Try Meko for Free
You can create a Meko account yourself today.
The current Free plan requires no credit card and no waitlist and includes up to 10 datapacks, 1,000 conversations per month, 10,000 retrievals per month, 10 million Workbench tokens, and 100 MB of knowledge storage. The Pro plan adds team sharing, role-based access, larger/custom limits, SSO, and additional organizational capabilities.
The easiest way to explore Meko is WorkbenchLM, the chat experience built into the portal. It lets you watch memory and decision traces update without installing another AI client.
What Meko Is… and What It Isn’t
Meko itself is explicitly not an AI agent; it is the data/context layer that agents connect to.
Final Takeaway
AI agents become much more useful when their context survives the individual session.
Meko gives agents somewhere durable to keep what they learned, somewhere common to retrieve shared knowledge, and a traceable record of how that context was created and used.
Resources
Have Fun!
This is a picture of me and Heather Downing, Developer Advocate at YugabyteDB, at our display at Postgres Summit US 2026 in NYC, running Sept. 30–Oct. 2! 
Stop by and meet the team, check out some live demos, and talk with us about how distributed PostgreSQL can deliver horizontal scalability, global availability, and ultra-resilience… without giving up PostgreSQL compatibility.
And if you’re here today, be sure to catch Heather’s session:
Agent Memory Is Three Postgres Extensions in a Trench Coat
Today, October 1 | 11:30 AM–12:20 PM
Heather will show how PostgreSQL itself can serve as the memory layer for AI agents by combining three different ways of representing and retrieving knowledge: raw text with full-text search, embeddings with pgvector, and entity relationships stored as a graph with Apache AGE. She’ll build an agent memory live and demonstrate how hybrid retrieval across all three approaches can help agents resume previous work, share learned knowledge, and even answer the question, “Why does the agent believe this?” with SQL. 
If you’re at the Summit, come say hello… and definitely check out Heather’s talk!