Every word and phrase you meet in the chat gets tracked, with a status — automatically, from conversation, never hand-authored. A read-only web page lets you see everything you've picked up and where each item stands. It's Anki's memory model with Anki's worst tax removed. This is the spine of V1 — the teaching layer that builds on V0 onboarding.
7 minOnboarding hooks them. The Anki backbone is what makes it a learning tool and not just a charming chat. Underneath the conversation runs a quiet ledger: every word and phrase the user meets, each with a status — have they just seen it, are they wrestling with it, can they use it cold? The user never fills out a card. They just talk, and the ledger fills itself. Then a web page hands it back to them: here's everything you've picked up.
This is the same bet Anki makes — catch a memory right before it fades — but with the two things that make Anki a chore deleted: you don't author cards (the conversation extracts them) and you don't self-grade (the conversation reveals the status). It tracks your own life's words, not a downloaded deck.
The backbone is the data-and-timing spine: it tracks every item, grades it from the chat, and runs FSRS over it to decide what's due. The themed-clusters doc is the reference layer on top — grouping due items into themes so the agent has related words on hand when it resurfaces one. Both are V1. What's deferred past V1 is only a skill rating and other languages.
The backbone is a reference, not a director. It tells the agent what the user knows, what's gone shaky, and what's worth reusing — but it never grabs the wheel. The agent owns conversation flow. Its objective is to consult the ledger and work its items in where the chat gives a natural opening — never to robotically throw a tracked word in out of nowhere because something is "due."
久しぶり as shaky, so the agent shoehorns it into an unrelated message. That's a flashcard popping up mid-conversation — the exact feel the whole backbone exists to kill.久しぶり falls in on its own.Holds whether the agent is reading status mid-chat to pick what to reuse, or opening a themed proactive message — it surfaces an FSRS-due item only when the thread opens a door, never as a drill. FSRS decides what's due; the agent's judgment still decides when it actually lands, always.
The unit is an item: one word, phrase, or small grammar pattern the user has met. Kept per learner, alongside the existing profile.
| Field | Example | Why |
|---|---|---|
surface | っぽい | The form as it appears. |
reading | っぽい · 日本（にほん） | Kana reading — so the page is always readable, same rule as the chat. |
gloss | "kinda / -ish / seems like" | A short meaning, in their native language. |
status | learning | Where this item sits — the state machine below. |
firstSeen / lastSeen | Jun 21 / Jun 23 | When it entered, when it last came up — inputs to FSRS. |
encounters | 4 | How many times it's surfaced — exposure count. |
fsrs | due Jun 25 · stability 4.2 · difficulty 0.3 | The live FSRS schedule — next-review date, memory stability & difficulty. Recomputed each time the chat grades the item. |
context | "talking about being tired" | Where it came from — the your own life hook. Not a dictionary line. |
nearMiss | ボダリング → ボルダリング | The almost-right version, if there was one. |
This is the Progress store made real — the one genuinely domain-specific memory store. Profile stays flat facts; Voice stays a small descriptor.
Four states, lifted from Anki's New → Learning → Review → Relearning loop but renamed for what they mean here, and — crucially — inferred from the conversation, not chosen by the user pressing a button.
| Status | Means | How the agent infers it |
|---|---|---|
| new | Just introduced | The agent (or the user) used it for the first time; user hasn't produced it yet. |
| learning | Wrestling with it | Seen a few times; followed it with help, or produced it with a near-miss / gloss. |
| known | Owns it | Produced it correctly, unprompted, more than once. No gloss needed. |
| shaky | Slipping | Was Known, but recently missed it, needed the gloss again, or hasn't used it in a long while. |
No four buttons. Anki's weak point is the honest self-grade — garbage-in self-grading corrupts every interval. Here the grade is the conversation: did they follow it, produce it, fumble it, fall back to English? The agent reads that and moves the status. The user never rates anything.
The status is the human-facing label; underneath, that same inferred read becomes an FSRS grade (again / hard / good / easy) that updates the item's stability and next-review date. So the friendly four-state badge and the real scheduler are driven by one thing — how the user actually handled the word. FSRS is exactly Anki's scheduler; we've only swapped the button-press for the conversation.
After a turn, the agent notices vocab events and writes them to the store — the single most differentiated move, because it deletes the work Anki dumps on the user.
っぽい naturally → create an item, status new, with the context it came up in.疲れてるっぽい unprompted and correct → bump toward known, bump encounters, stamp lastSeen, and feed FSRS a good grade so its next review moves out.ボダリング for ボルダリング → record the near-miss, hold at learning. (Catching near-miss vs. typo is an open question, shared with the design doc.)Mechanically this is an extension of the existing remember tool (see where it lives) — a structured items write, not free text. The agent already jots facts; this gives it a typed slot for vocab.
The user-facing surface of the backbone: one page, your whole vocabulary, grouped by status. A trophy case and a progress mirror — not an editor.
Every row is something they actually said or met — readings attached (so kanji is always decodable), the gloss carries the context it came from, and the status pill shows where it stands. Filter chips slice by status. That's the entire V1 page: view, don't edit.
The web page is deliberately read-only — no "+ add word" in V1. This is a real design choice, not a missing feature, and it's load-bearing for the whole thesis.
Noted as "for now": a later milestone may let you nudge an item (mark something known, or ask the agent to start working a word in). But it routes through the conversation/agent, never a raw deck-builder form. The door's open; the form stays shut.
The backbone keeps Anki's memory machinery and drops everything Anki offloads onto the user. Side by side:
| Anki | The Anki backbone |
|---|---|
| You author notes — fields, templates, the Twenty Rules | The agent extracts items from conversation — zero authoring |
| You self-grade with four buttons each review | Status inferred from how you actually used the word |
| Cards are downloaded decks / abstract facts | Items are your own words, with the context they came from |
| Decks & queues are the retrieval UI | Status groups on one read-only page |
| You go to the app to review | Review comes to you in the thread (themed proactive sessions — V1) |
| FSRS scheduler picks the next review date | The same FSRS, in V1 — fed by inferred grades instead of button presses |
The scheduler is the easy, borrowable part; FSRS is open-source and battle-tested. The differentiated work is everything above it — capture and grading without the user lifting a finger.
Today memory is a flat free-text notes blob in core/.memory.json, keyed by handle. The backbone adds a structured store next to it:
learner = {
profile: { … }, // unchanged: name, level, scripts, goal…
items: { // NEW — the Anki backbone
"っぽい": {
surface: "っぽい", reading: "っぽい", gloss: "kinda / -ish",
status: "learning", encounters: 4,
firstSeen: "2026-06-21", lastSeen: "2026-06-23",
fsrs: { due: "2026-06-25", stability: 4.2, difficulty: 0.3 },
context: "talking about being tired",
nearMiss: null
},
…
},
history: [ … ], summary: "…" // unchanged
}The agent writes items through an extended remember tool (a typed vocab slot beside the existing note/profile fields). The web page reads the same JSON. Single-user dogfood scale — a JSON file is fine; swap for SQLite/Supabase if it grows, same as the rest of memory. This is the Progress store — the load-bearing memory store.
items store per learner.remember).疲れてる the same item as 疲れる? Do we lemmatize conjugations, or track surface forms? Over-splitting bloats the page; over-merging loses nuance.〜っぽい) — one items store or typed kinds?