What Cortex is

Cortex is a knowledge graph that belongs to one team. You connect sources to it, it does the expensive work once while it ingests them, and after that any agent with access to that team can read it.

In the API the graph is an office, identified by an officeId. "Memory", "cortex" and "office" name the same object, and you will meet all three words in SDK signatures and in the dashboard. One office is one graph.

The work happens at ingest

A row arrives through a feed. Cortex embeds it, extracts typed entities and edges from it, and writes those into the graph with a record of how each one was derived. That is the expensive part, and it is paid once per item, no matter how many agents read the item later or how often.

const cortex = client.cortex(officeId);

const { feedKey } = await cortex.ensureFeed(officeId, 'handbook');
await cortex.pushRows(officeId, feedKey, rows, { deferEmbed: true });

ensureFeed is idempotent, and external_id on each row is the idempotency key, so re-pushing a row updates it in place. The full runnable loop, with batching, local files, the CLI and the plain-HTTP equivalents, is in ingest and query.

What a query returns

answer() is hybrid retrieval in one call: vector kNN, full-text, and a one-hop graph expansion, fused with reciprocal rank fusion.

const answer = await cortex.answer(officeId, {
  query: 'what did pricing move to?',
  limit: 5,
});

There is no LLM at query time. You get evidence, and your agent does the reasoning over it. Each result carries a score, a universal_id, its source_table and a source_url, plus signals describing how the result was found and per-source freshness telling you how stale it is.

Retrieval returns nearest matches, not a thresholded set, which is the one thing to understand before you build on it. See nearest matches, not a thresholded set.

Provenance is the spine

Every item carries a universal id:

universal_id = integration_id ":" source_table ":" sha256(natural_key)

That id is the same across the raw layer, the embedded layer and the graph layer, so a citation resolves back to the exact row it came from. Answers carry their citations as universal ids plus a cited_graph_url that opens the graph with those nodes highlighted.

Reading it from an agent

forAgent is the surface to use inside an agent loop. It attributes writes to the agent, and carries provenance from the last ask() into the next remember().

const memory = client.cortex(officeId).forAgent(officeId, 'atlas');

const evidence = await memory.ask('what did pricing move to?');
console.log(evidence.context());

await memory.remember('Solo is $19.99/seat as of July 2026.', { kind: 'decision' });

ask(), context(), contextFor() and remember() are the whole agent surface.

What has been measured

Verging Labs evaluated Cortex between 23 and 25 July 2026, building and probing it entirely through the public APIs. Across 272 scored questions it recorded 0 fabricated answers and 0 flat-wrong answers, and 97 percent correct "I do not know" responses on facts that were never stored.

Where to go next