Skip to main content
When you tell an Expert “I work on B2B SaaS,” it remembers. When you later say “We recently pivoted to B2C,” it doesn’t simply overwrite — it understands this as a change over time: you used to do B2B, and now you do B2C. This is what “temporal” means: memories have a time dimension, facts have lifecycles, and changes are preserved rather than overwritten.

​
Four-Layer Memory Pipeline

Memory flows from user-visible lists to AI-distilled knowledge graphs across four layers:
1

Memory List (user-visible)

You can view, add, edit, delete, enable, or disable each memory entry. This is the layer you interact with directly, with full control.
2

Evidence Snapshots (immutable)

When each memory is created, the system generates an immutable evidence snapshot — the original basis for “why this was remembered.” Even if the memory is later modified, the evidence is always preserved.
3

Core Facts (AI-distilled)

Periodic consolidation processes distill evidence into structured facts — entities (people, concepts, tools, projects) and relationships (preferences, usage, affiliation). Core facts are a read-time projection of currently active facts, not a second copy.
4

Memory Graph (visualization)

Core facts form a time-tagged knowledge graph. Each node is an entity, each edge is a relationship. You can visually browse it in the UI.
Consolidation never modifies your memory list. Memories you add always remain exactly as you added them — core facts are simply structured projections distilled by AI from them.

​
Entity Types

Graph entities fall into a soft vocabulary of 10 kinds:
This is a soft vocabulary: near-miss variants produced by distillation are normalized into the table above, while values outside it pass through verbatim and the UI degrades to showing the raw text rather than forcing them into other. So an occasional unfamiliar kind name is expected.
Entity names and fact descriptions follow the language of the evidence — Chinese memories produce Chinese facts, English memories produce English facts.

​
Contradiction Handling: No Deletion, Only Iteration

When new information contradicts existing facts, the system’s approach is not “delete the old one”:
  1. The old fact is given an end timestamp (“Until last week, the user was using JavaScript”)
  2. The new fact begins from the current moment (“Starting this week, the user switched to TypeScript”)
  3. History is always preserved — the Expert can recall the complete evolution of decisions

​
Memory Consolidation (Dream)

Memory distillation is performed through two speeds of “consolidation” processes:

Light Consolidation (post-conversation)

Key memories are extracted immediately after each quality conversation. Upon successful extraction, best-effort distillation into the graph follows. Fast, immediate, no information lost.

Deep Consolidation (scheduled)

A periodic scheduler scans unprocessed evidence and distills in batches. Each batch is size-limited to avoid single-call timeouts. Mid-process failures can be resumed — already processed portions are not lost.
Both budgets are explicit: Chunking isn’t only about cost — it’s about resumability: feeding the whole backlog in one call means a single timeout loses all of it, while chunked runs lose only the current batch and processed evidence carries a content-addressed idempotency key so it isn’t billed twice. Every graph change is written to an operation journal as before/after snapshots, forming a complete change audit trail. Any consolidation batch can be atomically reverted — compensated in reverse sequence order, rejecting the whole revert if a snapshot doesn’t match rather than half-applying it.

​
Retrieval: Bounded and Efficient

When an Expert needs to recall, it doesn’t search all memories — it follows a precise four-step retrieval:
1

Candidate screening

Based on the current conversation content, the most relevant candidate memories are screened (upper limit of 30).
2

Graph expansion

A 1-hop expansion is performed on entities in the candidates within the graph — finding directly related facts.
3

Re-ranking

Results are re-ranked by relevance, recency, and importance.
4

Context injection

The top 20 entries (not exceeding 2,000 tokens) are injected into the current conversation context.
“Bounded” is a key design decision. Injecting all memories wholesale not only wastes tokens but drowns out truly relevant information. 20 carefully selected memories are more useful than 200 generic ones. On retrieval failure, the system automatically degrades to a deterministic “latest 20” strategy.

​
User Control

Control of the memory system is entirely in your hands. On the Expert’s evolution page, you can manage memories through three tabs:

Memory List

View, add, edit, delete, enable/disable each memory entry. This is the layer users directly operate.

Core Memories

View AI-distilled structured facts — entities, relationships, timestamps. Read-only view.

Memory Graph

A visual knowledge network. Nodes are entities, edges are relationships — see the complete picture of the Expert’s understanding of you at a glance.
You can also enable temporary conversation mode — the current conversation won’t read memories or create new ones, suitable for sensitive topics.

​
Boundaries and failure modes

The temporal graph as a whole sits behind a platform flag that is off by default. When it’s off, only the memory list operates, the related endpoints return 404 as a group, and the UI falls back to the legacy view.

​
Isolation and Privacy

Memories are strictly isolated by Expert × User. User A’s memories with Expert X are completely independent from User B’s memories with Expert X. Cross-boundary access always returns 404 — non-enumerable, it’s impossible to probe whether someone else has memories. An Expert will never “cross-contaminate” memories — what you discuss with an Expert can never be obtained by another user through memory retrieval.