Context Lake

Your context lake is the one place all your context lives. You (or your team) have exactly one lake. Inside it sit many context graphs, each one an independent body of memory built by the Memory Engine.

​

Three kinds of graphs

The read/write rule is simple:

• An agent key reaches only the agent graphs it was granted, at the level it was granted. Every read and write is checked per request against the roles you hold and the grants on that key, so a key you scoped to one graph stays there, and a read-only key stays read-only.
• Your Personal graph is walled off from agent keys. That wall is by key class, not by configuration: an agent key can never resolve a personal or team graph, and your own personal key can never resolve an agent graph. Neither is something you can turn off by mistake.

​

What a graph contains

Every context graph is the same three things, layered:

• Pages. Readable, block-structured pages that hold the distilled state of a topic. Real prose a human can read, not entity dumps.
• Facts. Ledger rows with recency (when the engine committed it, whether something superseded it) and lineage (the verbatim quote it rests on, and for an inferred fact the facts it came from). A fact on a page is a rendered ledger row.
• Entities. First-class records with canonical names and aliases, so “the auth service”, “authsvc”, and “AS” resolve to one node instead of fragmenting your graph.

Underneath each graph sits its own append-only verbatim log (the raw pushes, byte for byte, with any correction you make later added to the source’s history rather than overwriting it), and each graph lives in its own version-controlled vault, so every change is a commit you can diff.

​

Getting context in and out

Your AI tools talk to the lake through four MCP tools (or the equivalent SDK calls): Two properties matter here. Recall does not wait for distillation: the background worker indexes the verbatim text first, so a push is findable before its page exists. And the calling tool does no orchestration: it ships verbatim content in and gets assembled context out. Everything in between happens in the engine.

​

Ownership

A graph is plain markdown pages plus a ledger, in a version-controlled vault owned by you or your team. Nothing is a proprietary blob: every page is markdown, every change is a commit, and you can read any source back byte for byte. Bring your own drive (the graph mirrored to storage you control) and private deployment inside your own boundary are the direction we’re building, not shipped yet. See Ownership for exactly where the lines are today.

​

Where to go next