Previously Docs
The User Card
Slices record what happened. The user card records who you are. It is a single Markdown file — memory/episodic/current-previously.md — that distills the entire timeline into one compact brief: your identity, a rolling profile, what is happening right now, and what you have committed to.
But the card is only a product. What actually learns is the evolution loop around it — the card is where the loop's output becomes visible; memory/evolution/ is where the loop itself lives. The loop's mechanics get their own page: The Evolution Loop.
The card is injected into every turn's system prompt, right after the identity constitution. Because it changes only on evolution — never while a slice is open — the prompt prefix stays byte-stable and the provider's prompt cache keeps hitting. The stored card keeps raw ISO dates; the injected copy is annotated with relative times ("3 days ago") computed on your local clock, so the model never does date arithmetic itself.
The card's format
The card has four sections, making your time axis explicit — Past, Now, and Horizon:
# Previously On
_Active slice: 2026-08-10-2130 | Format: user card v2 | Updated: 2026-08-10T21:47:12Z_
## Identity
- Address them as: you
## Past
You are a knowledge worker in your late twenties who spent early 2024
coasting, then started building: a CSV-merge side tool that grew into a
weekly-review product, and a running habit that went from winded on the
stairs to a finished half-marathon in July 2026. Alex — met at Priya's
dinner back in October 2024 — is your partner and the closest
relationship in your life.
- Finished a first half-marathon 2026-07-16; Alex was at the finish line — refs: [2026/07/16/0915]
- Since Mom's health scare (2025-07), weekly calls are non-negotiable — refs: [2025/07/30/2040]
## Now
- Final pass on the best-man speech for Marcus — reading it aloud to Alex tonight — refs: [2026/08/10/2110] | since: 2026-08-09
## Horizon
- Deliver the speech at Marcus's wedding — by: 2026-08-12 — refs: [2026/08/09/2000]Identity — a structured, machine-parsed head: Name, Address them as, Pronouns, Alias (up to 8 lines). This is what lets Previously greet you in the arrival briefing, and how it knows how to address you.
Past — durable memory, in two parts:
- A single rolling profile paragraph — third person, rewritten in place as the picture of you sharpens, hard-capped at 2,400 characters (~600 tokens).
- Anchor facts — bullet-point dates, decisions, and red lines, each with evidence refs. The admission test: "almost certainly still true in 3 years?" Cap: 8.
Now — a semantic compression pool of what is currently alive: hooks, not narratives. Each item carries refs to its evidence slice and a since date. Cap: 5. Items older than 7 days are flagged to the evolution agent, which decides per item: promote durable substance to Past, or drop the hook. Nothing is silently deleted by code.
Horizon — future-facing open loops: commitments, deadlines, awaited replies. Every item carries an explicit by: date. Horizon items never age out — they leave the card only by being resolved. Overdue items are kept and flagged: the next turn's brief tells the agent to proactively ask you how they turned out.
Note what the card does not carry: no rules, no analysis, no operating lessons. Patterns about who you are — "wants honest critique before reassurance" — live in the evolution direction's Portrait, not on the card (see The Evolution Loop). The card is a pure memory pool: what you did, are doing, and will do.
The card answers who you are, not what was said. Every entry carries refs — pointers like 2026/08/10/2110 back into the slices, which remain the lossless source of truth. Before citing specifics from a past event, the agent asks the recall colleague, who quotes from the slices themselves.
How the card itself changes
The card is never rewritten wholesale. The Previously Agent holds an in-memory copy of the card and edits it through fine-grained, validated mutation tools:
| Tool | What it does |
|---|---|
setIdentity | Set or update one Identity field in place |
updatePastProfile | Rewrite the Past profile paragraph |
addPastAnchor / removePastAnchor | Add or remove a durable anchor fact |
addNow / removeNow | Add or remove a Now hook |
promoteNowToPast | Graduate a Now hook to a Past anchor, keeping its refs |
addHorizon / resolveHorizon | Open or resolve a Horizon loop |
Validation lives inside the tools, not in a post-hoc pass. An over-limit or malformed write is rejected with specific feedback — "2630 chars, limit 2400 — compress and retry" — and the agent itself decides what survives the cap. Refs are required: no evidence, no write. Untouched parts of the card are preserved by construction; a mutation session cannot silently drop a line it never looked at.
The result is written back only when the card's substance actually changed (header stamps refresh on every pass and are ignored in the comparison). Both the live card and a per-slice snapshot (memory/episodic/slices/YYYY/MM/DD/HHMM/previously.md) are written together — so every slice on the timeline carries the card as it stood when that conversation ended, and the "Previously On" dialog in the UI can show it.
When the card evolves
The card gets an evolution check every turn, but most of the time nothing happens — no trigger, no evolution. The triggers (fitness signals, your explicit requests, forced upgrades of legacy cards) and the single merged evolution run are covered in The Evolution Loop.
Progress streams to the client as it happens, and when the card moved, an evolution indicator shows a one-sentence account of what changed plus the line-level diff. A skipped run is reported too, with the reason — a silent skip would read as "it never runs".
You wonder what these recent conversations will make it change about you:
11:47 PM
Yes — the portrait keeps evolving. The newest entry sits under Traits & cognitive style: you systematically undervalue your own progress. After the half-marathon you reflexively discounted the achievement, and you were already discounting the wedding speech before giving it. The entry is anchored to two slices: the finish-line night, and your post-race reflection.
No. Every turn, five fitness buckets — card, recall, search, thinkdeep, interaction — accumulate evidence-anchored scores, and a score without your own words attached counts as zero. Only when a bucket's net drops to −5 does an evolution run actually fire; when it succeeds, that generation settles and the count restarts from zero.
Experimental: evolution is model judgment all the way down — what to record, what to promote, what to change in a playbook. The rails (caps, refs, structural evidence-anchoring, deterministic triggers) keep it well-formed, not correct. Because everything is plain Markdown in git, you can always read the diff, edit the card by hand, or roll it back.
Related
- The Evolution Loop — the Darwinian loop that drives the card's changes
- The Memory Model — where the card and the evolution layer sit in the memory stack
- The Timeline — slices, the lossless source of truth the card points into
- Recall — the colleague who quotes from the slices the card's refs point to