Recall

recall() is how an agent reads memory. It is designed around three properties: it never forgets what you just wrote, it returns facts you can verify, and it can answer as of any point in the past.

const result = await alice.recall('team', 'What note-taking app does Alice use?', {
  synthesize: true,
});
result.facts;    // structured, cited facts
result.answer;   // a written answer over those facts (only when synthesize: true)

C3: scoped read-your-writes

Ingestion into the graph is asynchronous - a commit cheaply enqueues the change, and extraction happens later. But a read must never miss a committed file.

So on every recall(), Bezial settles only the pending changes relevant to this query (lexically, within the query’s scope) before querying - not “settle everything.” A small question never waits on an unrelated big ingest, and recall still reflects a file written a millisecond ago.

There is no split-brain risk: the graph is a pure function of one ordered file history, so it can be stale, never contradictory.

R3: the return shape

Recall returns structured facts, each independently inspectable. Every fact carries:

Field	Meaning
subject, predicate, object, objectKind	The fact triple; objectKind is 'entity' or 'literal'.
citation	A pointer to the source passage: path, version, section, anchor, lineStart, lineEnd.
validTime	World-time window { from, to }; to === null means still true.
recordedTime	Knowledge-time window { from, to }; to === null means currently believed.
confidence	The extractor’s confidence in the fact.
id	An opaque handle for pin / forget / restoreFact.
pinned, archived	Current tuning flags (see Selective forgetting).

The citation is the trust move: every fact points back to the exact Markdown passage it came from, so an agent’s claim is always traceable to a file a human can open. Synthesis is off by default; pass synthesize: true to also get a written answer over the filtered facts.

The order is load-bearing

Recall runs a fixed pipeline, and the order is what makes it safe:

temporal selection  ──▶  ACL filter  ──▶  ranking  ──▶  synthesis

Filtering each fact by its own stamped ACL before anything is ranked or synthesized is what gives zero cross-space and cross-author leak by construction. The synthesizer only ever sees facts the caller may read. Within equal query relevance, ranking breaks ties by salience (then recency, then id), so a hotter, more-pinned, less-decayed fact wins among equally-relevant matches.

As-of: querying the past

Recall is bi-temporal natively. Pass asOf (epoch milliseconds) to recall the graph as it was believed at that instant:

const past = await alice.recall('team', 'note-taking app?', {
  asOf: Date.parse('2026-05-01'),
});

Facts recorded after that instant, or invalidated at or before it, are excluded - so a contradiction that arrived later is invisible as of an earlier time. This is what lets you ask not just “what does my agent know now” but “what did it know last month.”

Options

Option	Effect
asOf	Bi-temporal as-of (epoch ms). Omit for the currently-believed graph.
scope	Restrict settle and query to a path subtree (e.g. alice), matched on namespace boundaries.
synthesize	Also return a written answer over the filtered facts.
limit	Max facts to return (default 50).
includeArchived	Also surface forgotten facts so a caller can find and restore them. Ignored when asOf is set.

The two views - the file map and the fact graph - share the same temporal-visibility predicate and the same per-fact ACL filter as recall, so the query path and the views can never drift.