Cortex Layer

MVP · early access

Memory for your agent that's persistent, cost-efficient, and reliable.

Your agent remembers what matters, at a fraction of the token cost, with answers you can trust.

Get startedRead the docs
# Step 1 — install (in your terminal):
# pip install cortexlayer
 
# Step 2 — save as hello_cortex.py, then:
# python hello_cortex.py
import os
from cortexlayer import CortexClient
 
client = CortexClient(
    api_key=os.getenv("CORTEX_API_KEY", "sk-..."),
)
 
client.add("I moved to Lisbon in March.")
 
results = client.search(
    "Where does Alice live?",
    limit=5,
)
print(results)

tokens sent to your agent

−99%
raw passages752 tok
compressed answer7 tok

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

Store

Memory becomes linked pages

Conversations and facts are chunked into pages, with entities extracted for linking.

Link

Pages connect by shared entities

A linking pass graphs pages that mention the same people, places, or things — no manual tagging.

Retrieve

Vector search, then follow the graph

Seed pages come from similarity search; linked neighbors join in only when a query needs more.

Compress

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.

queryanswer

seed match → linked neighbor → answer page

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

What reaches your agent

Naive RAGRaw passages, top-k, whatever fit the window

CortexA cited answer, compressed by a cheap model

Related context

Naive RAGMissed, unless it matched the query directly

CortexPulled in by following links from the match

Cost per call

Naive RAGScales with how much you retrieve

CortexScales with the answer, not the corpus

Isolation

Naive RAGDepends on the store you wire up yourself

CortexPrivate layer per account, by default

Measured results

Measured on LOCOMO

Retrieval finds what's relevant, then a cheap model compresses it down — so accuracy holds up at a fraction of the tokens it takes to paste a whole conversation into context every time.

−97%

tokens retrieved per question (719–796) vs. 26,031 to paste an average LOCOMO conversation into context with no memory layer at all.

−99%

again on top of that: a cheap model compresses 719–796 retrieved tokens down to ~7.4 tokens before it reaches your agent.

Answer quality

F1, higher is better

Single-hop

Cortex
0.357

Multi-hop

Cortex
0.273

Temporal

Cortex
0.480

Open-domain

Cortex
0.170

Tokens per question

lower is better

Single-hop

719 retrieved → 7.5 compressed

Cortex
719

Multi-hop

796 retrieved → 7.6 compressed

Cortex
796

Temporal

740 retrieved → 8.2 compressed

Cortex
740

Open-domain

751 retrieved → 6.3 compressed

Cortex
751

No memory layer at all

tokens per question, to scale

What if you skipped retrieval entirely — just pasted the raw conversation (or an Obsidian vault of notes) into the prompt every time? An average LOCOMO conversation runs about 26,000 tokens, whether or not any of it is relevant to the question.

Cortex
752
No memory layer
26,031

Cortex fetches only what's relevant to each question, so this cost stays flat as memory grows. Pasting everything in doesn't — it scales with everything you've ever written down, not with what the question needs, and stops fitting in context at all once memory outgrows one conversation. (LOCOMO dataset average, Maharana et al. 2024.)

  • Tokens read “retrieved → compressed”. Counted with tiktoken cl100k over the answer context.
  • All 1,540 non-adversarial LOCOMO questions, raw engine (ONNX MiniLM + spaCy, ranked link-expansion), Qwen3.5 9B as answerer locally, k=4. Deterministic token-F1, no LLM judge.

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

Hermes

Nous Research's agent framework

Claude Desktop

official MCP client

Cursor

MCP-enabled editor

Any MCP client

generic config, no SDK

Just the link, not an SDK rewrite

Paste this URL into your agent's MCP settings and approve over OAuth. No API key to create, copy, or rotate. The Setup screen has the exact steps for your client.

mcp.json
{
  "mcpServers": {
    "cortex": {
      "url": "https://mcp.cortexlayer.net/mcp"
    }
  }
}

Your memory stays yours

Long-term memory is personal by nature. Here is what we commit to.

Isolated per account

Your private layer is scoped to your account. 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 early-access 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 account and is never shared across users or used for training. The shared layer only holds public knowledge you opt into.

Why early access?

Cortex is an MVP. We're validating retrieval quality and cost with a limited number of early users, so signups are capped for now.

How is this benchmarked?

On LOCOMO, Cortex retrieves 719–796 tokens per question and compresses that down to ~7 before it reaches your agent — versus the ~26,000 tokens it takes to paste a whole conversation into context with no memory layer at all. Full setup is in the Benchmarks section above.

How do I get access?

Create an account, then use the Setup screen. Claude connects through your account with one click. Other agents use an API key you create there.

Give your agent memory that scales with the answer, not the corpus.

MVP, early access. Create an account to try it against your own agent.

Get startedRead the docs