MVP · invite-only
Memory that's retrieved, linked, and compressed — before it reaches your agent.
Cortex gives your agent private, long-term memory. Entries link by shared entities, retrieval follows the graph, and a cheap model compresses the result to a cited answer — exposed over MCP so any MCP-compatible agent can plug in.
> memory_retrieve("who directed the film?")
vector search
one seed page matches the query
link expansion
2 hops through the graph to the answer page
compression
a cheap model reduces the path to one answer
tokens sent to your agent
−92%sources: p_4a1, p_09e
Compressed, not dumped
A cheap model reduces retrieved pages to a direct, cited answer — your agent's context doesn't pay for raw passages.
Private by design
It's your long-term memory. Nothing is shared across users or trained on.
Drop-in for agents
Speaks MCP, so integration is a config entry, not an SDK rewrite.
How it works
Memory becomes linked pages
Conversations and facts are chunked into pages, with entities extracted for linking.
Pages connect by shared entities
A linking pass graphs pages that mention the same people, places, or things — no manual tagging.
Vector search, then follow the graph
Seed pages come from similarity search; linked neighbors join in only when a query needs more.
A cheap model writes the answer
Raw passages become a direct answer with source references, not a wall of text in your agent's context.
Where linked memory pays off
Flat search works when the answer sits in one place. These are the cases where it doesn't.
Multi-hop questions
"Who directed the film?" lives on a different page than the film's title. Link expansion follows shared entities to the answer instead of stopping at the first match.
Coding agents
Keep decisions, conventions, and past debugging sessions across projects. Your agent recalls the why without re-reading the repo.
Long-running assistants
Weeks of conversation stay retrievable. Each call costs one compressed answer, not a growing transcript.
Personal memory
People, preferences, and plans, private to your key. Nothing is pooled with other users or used for training.
Retrieval that stops at "found it"
Most RAG setups hand your agent whatever the search returned. Cortex keeps going: follow the links, then compress before anything reaches the context window.
| Naive RAG | Cortex | |
|---|---|---|
| What reaches your agent | Raw passages, top-k, whatever fit the window | A cited answer, compressed by a cheap model |
| Related context | Missed, unless it matched the query directly | Pulled in by following links from the match |
| Cost per call | Scales with how much you retrieve | Scales with the answer, not the corpus |
| Isolation | Depends on the store you wire up yourself | Private layer per API key, by default |
Early results
Measured against Mem0 on LOCOMO
Cortex uses a small fraction of the tokens. Answer accuracy is behind Mem0 in every category today, and we're showing both.
−94%
tokens retrieved per question: 105–112 for Cortex vs. 1,764 for Mem0, before Cortex compresses further.
F1 behind
Cortex scores lower than Mem0 on all four LOCOMO categories. Closing that gap is the current work.
Answer quality
F1, higher is betterSingle-hop
Multi-hop
Open-domain
Temporal
Tokens per question
lower is betterSingle-hop
112 retrieved → 3.4 compressed
Multi-hop
105 retrieved → 6 compressed
Open-domain
105 retrieved → 5.9 compressed
Temporal
107 retrieved → 7.5 compressed
- Cortex tokens read “retrieved → compressed”. Counted with tiktoken cl100k over the answer context.
- Cortex: 1,540 LOCOMO questions, Mem0 + Qwen3.5 9B with Qwen3-Embedding 8B locally, k=4. Mem0: figures from the published paper (arXiv 2504.19413, Tables 1–2, GPT-4o-mini). Different models on each side, so this is not a controlled comparison.
- F1 only. No LLM-judge scores are compared.
Speaks MCP
Drop it into the agent you already run
One protocol, no bespoke SDK. The Setup screen generates a config snippet for each client below the moment you connect a key.
Hermes
Nous Research's agent framework
Claude Desktop
official MCP client
Cursor
MCP-enabled editor
Any MCP client
generic config, no SDK
A config entry, not an SDK rewrite
Add one MCP server entry and your agent can call memory_retrieve like any other tool. The Setup screen generates this for your specific client once you connect a key.
{
"mcpServers": {
"cortex": {
"url": "https://api.cortexlayer.net/mcp",
"headers": { "Authorization": "Bearer YOUR_API_KEY" }
}
}
}Your memory stays yours
Long-term memory is personal by nature. Here is what we commit to.
Isolated per API key
Your private layer is scoped to your key. Other users can't read it, and it isn't pooled with theirs.
Never used for training
Your memory is retrieved for you and nothing else. It doesn't train or tune any model.
Shared layer is opt-in
The shared layer only holds public knowledge you choose to draw on. Private pages never leak into it.
Cortex is an invite-only MVP. We don't hold SOC 2, HIPAA, or similar certifications yet, and we'll list them here only once we do.
Questions
What is MCP?
The Model Context Protocol is an open standard for connecting agents to tools. Cortex exposes memory as an MCP server, so any MCP-compatible client can call it the same way it calls its other tools.
Is my memory private?
Yes. The private layer is isolated per API key and is never shared across users or used for training. The shared layer only holds public knowledge you opt into.
Why invite-only?
Cortex is an MVP. We're validating retrieval quality and cost against a small group of early users before opening things up.
How is this benchmarked?
On LOCOMO, Cortex retrieves roughly 105–112 tokens per question versus 1,764 for Mem0, but its F1 is lower in every category today. The comparison uses Mem0's published numbers with different models on each side, so treat it as early. Full setup is in the Benchmarks section above.
How do I get access?
Reach out for an API key, then use the Connect screen to add it and Setup to generate a config for your client.
Give your agent memory that scales with the answer, not the corpus.
MVP, invite-only. Connect a key to try it against your own agent.