2026-07-30 08:38 UTCIn-site rewrite5 min readUpdated: 2026-07-30 09:01 UTC

Show HN: My AI keeps getting smarter. I don't. So I built Engram

Engram is a learning system for humans that turns AI coding assistants into personal tutors. Instead of making the agent smarter, it makes the user smarter through spaced repetition, active recall, and blind assessment. It works across multiple platforms like Claude Code, OpenAI Codex, and others.

SourceHacker News AIAuthor: nagisanzeninz

Notifications You must be signed in to change notification settings

Fork 91

Star 1.1k

BranchesTags

Open more actions menu

Folders and files

NameName

Last commit message

Last commit date

Latest commit

History

162 Commits

.agents/plugins

.claude-plugin

.codex-plugin

.github/workflows

.opencode-plugin

tests

agents

assets

codex/agents

docs

examples

experiments

gold

hooks

scripts

skills

.gitignore

.nojekyll

CHANGELOG.md

CONTRIBUTING-DATA.md

INSTALL-CODEX.md

INSTALL-HERMES.md

INSTALL-OPENCLAW.md

LICENSE

README.md

RELEASE_PROTOCOL.md

bun.lock

package-lock.json

package.json

plugin.json

tsconfig.json

vitest.config.ts

Repository files navigation

The mix-up worth clearing first: Engram is not an agent-memory plugin. It doesn't give your agent persistent memory, context, or knowledge of your codebase — memory MCPs and context tools do that, for the agent. Engram points the other way: it's a learning system for the human. Your agent becomes a tutor that makes you do the thinking, a blind examiner that checks you actually got it, and a scheduler that brings each idea back right before your brain drops it. The agent doesn't get smarter. You do — measurably, with receipts.

Born as a Claude Code plugin; the same skills and engine now run on six agentic platforms — including, as of v1.0.8, one that puts the tutor in your chat app:

claude plugin marketplace add nagisanzenin/engram claude plugin install engram@engram

Platform Install Then

Claude Code (born here) the two commands above /learn /review /coach

OpenAI Codex codex plugin marketplace add nagisanzenin/engram then codex plugin add engram@engram → INSTALL-CODEX.md $learn $review $coach

OpenCode "plugin": ["opencode-engram-learning"] in opencode.json (npm) /learn /review /coach

Hermes Agent clone + skills.external_dirs → INSTALL-HERMES.md — verified live on v0.18.2 /skill learn (or /study) /review /coach

Google Antigravity agy plugin install https://github.com/nagisanzenin/engram /learn /review /coach

OpenClaw openclaw plugins install engram --marketplace nagisanzenin/engram → INSTALL-OPENCLAW.md — verified on 2026.7.1-2 /learn /review /coach

OpenCode: opencode.json is read globally (~/.config/opencode/opencode.json) or per-project; pin to source instead of npm with "plugin": ["git+https://github.com/nagisanzenin/engram.git"].

Antigravity: The due-review session nudge isn't ported yet, and the architect and smith subagents are currently dropped by AG 1.1.4's strict installer. Everything else works the same.

OpenClaw: the nudge needs openclaw config set hooks.internal.enabled true (OpenClaw ignores plugin hooks until internal hooks are switched on), and it fires on /new and /reset rather than every session. Engram's agents aren't registered — the skills spawn them through sessions_spawn with isolated context instead, which keeps the assessor blind. Details in INSTALL-OPENCLAW.md.

Then, inside your coding assistant (command spelling per your platform's row above):

/learn kalman filters ← or music theory, or Rust lifetimes, or anything

That's the whole onboarding. No config, no account, no cards to write. Requires python3 (stock macOS/Linux one is fine — stdlib only). One state folder, every platform: learn in one tool, review in another, same schedule.

Wait — what is this?

You already ask Claude to explain things. It explains beautifully. You nod, you feel smart, and ten days later it's gone — because a chat has no memory of you, no test of whether you really got it, and no plan for the forgetting that starts the moment you close the terminal.

Engram is what's missing around the explanation: a tutor that makes you do the thinking, an examiner that checks you actually got it, and a scheduler that brings each idea back right before your brain drops it.

Engram is Engram is not

a learning system for the human — you end up knowing things agent memory — tools that persist what the agent knows (different job entirely)

a tutor that makes you produce answers before it explains a chatbot that explains while you nod along

a memory system — every concept gets a future review date notes and summaries you'll never reopen

an independent examiner that grades you blind, in writing self-assessed "yeah, makes sense"

plain JSON files on your machine a cloud service, account, or subscription

Concretely, installing it gives you: three commands (/learn, /review, /coach — exact spelling per platform in the table above), a quiet session nudge that tells you when reviews are due (and says nothing otherwise — on every platform except Antigravity, whose hook port is pending; on OpenClaw it needs one config flag and fires on /new), and a state folder at ~/.claude/learning/ that you own, can read, and share across every platform you use.

recall 100% ─┐ just reading 100% ─┐ with engram │\ │\ ●╌╌╌●╌╌╌╌╌●╌╌╌╌╌╌╌●╌╌ │ \ │ \ ╱ ╲╱ ╲╱ │ \ │ ●──╱ │ \ │ │ \_____ │ each ● = a 2–4 minute /review, 0% ─┴──────────────────── day 30 0% ─┴─ booked just before you'd forget

The loop

YOU ──→ /learn transformers │ ▼ ┌────────────────────────────────────────────────────────────────┐ │ CURRICULUM ARCHITECT │ │ breaks the topic into a first-principles concept map: │ │ "what must be understood before what" — never chapter order. │ │ flags the few THRESHOLD concepts † that unlock everything. │ └────────────────────────────────────────────────────────────────┘ │ ▼ ┌────────────────────────────────────────────────────────────────┐ │ THE TUTOR (your normal Claude chat, under strict rules) │ │ │ │ per concept: open a question → you PREDICT → struggle a │ │ little (hints, not answers) → resolve → you EXPLAIN IT BACK │ │ │ │ threshold concepts get a generated interactive HTML │ │ explorable — sliders and prediction gates, not more text. │ └────────────────────────────────────────────────────────────────┘ │ your answers, verbatim (crash-safe stash on disk) ▼ ┌────────────────────────────────────────────────────────────────┐ │ THE ASSESSOR (separate agent — grades blind) │ │ sees only the rubric and your words, never the lesson. │ │ every grade becomes a receipt on disk. no receipts, │ │ no mastery claim. │ └────────────────────────────────────────────────────────────────┘ │ receipts ▼ ┌────────────────────────────────────────────────────────────────┐ │ THE SCHEDULER (engram.py — deterministic code, not vibes) │ │ FSRS-4.5 fits your personal forgetting curves and books │ │ each concept's next review just before you'd lose it. │ └────────────────────────────────────────────────────────────────┘ │ ▼ next session: [engram] 6 reviews due (transformers: 6) · ~4 min │ ├──→ /review 2–4 minutes of free recall └──→ /coach weekly: stats · dashboard · tuning

A real session, condensed

From the first live topic taught with Engram (transformer internals). Note who does the thinking:

◆ node 6/13 · nonlinearity-necessity †

engram Delete σ for a second. The FFN is now just W₂·(W₁·x). What is W₂·W₁ — and what has the two-layer FFN collapsed into?

you i dont know really

engram Fine — that's a commitment. Forget matrices. W₁ = "×2", W₂ = "×3". Run a number through both, nothing in between. Two steps of computation… or secretly one?

you basically 2x3

engram That's the whole secret, and you just said it. ×2 then ×3 = ×6: two linear layers fuse into ONE. Fifty of them? Still one matrix. Depth means nothing until a nonlinearity blocks the fuse — and that's why σ is not optional.

At session end, the assessor — which never saw that dialogue — graded the learner's six answers: 1 recalled · 4 partial · 1 first-retrieval, while the tutor was convinced the session went great. The schedule believed the assessor. That separation is the point: your future reviews are built on verified evidence, not on the tutor's enthusiasm (or yours).

Three commands, one habit

Command What happens Time

/learn Intake (your goal, your background) → concept map → pretest → generation-first teaching → blind grading → everything scheduled 5–60 min, you pick

/review Due concepts, free recall, interleaved across topics. The habit that makes it all permanent 2–4 min

/coach Retention stats, calibration, local HTML dashboard, schedule tuning, n-of-1 experiments weekly-ish

Everything else is ambient: the session hook nudges when reviews are due and is silent otherwise.

Why it works (the science, in one breath)

Engram implements the four most-replicated findings in learning science — and deliberately skips the popular myths (no "learning styles"; that theory failed every controlled test):

Structure — knowledge is a graph, so topics are decomposed by chains of necessity ("why must this be true?"), never by chapter order.

Generation — the mind keeps what it makes. You predict, attempt, and explain back before being told. Even failed attempts measurably improve what sticks next (the pretesting effect).

Retention — testing is the learning (not the measurement of it), and spacing beats bingeing. Free recall on an FSRS schedule fitted to your own review history.

Honest adaptation — it adapts from your measured retention, calibration, and error patterns. Confidence is only recorded when you actually state it; grades only exist as written receipts.

Motivation & wisdom, honestly — it makes your real competence growth visible at the moment it happens (the memory that now lasts 4× longer — not points or streaks, which backfire on motivated adults), and it carries you through the hard part: struggle named as encoding, lapses absolved not pitied, backlogs met with amnesty. Two new layers, every claim adversarially verified against the primary source — docs/05-affective-layers.md.

Visuals that earn their keep (v0.5) — interactive explorables are built when the content rewards manipulation (a parameter to drag, a process that unfolds — declared per concept by the curriculum architect, never inferred from a "visual learner" label), always wrapped in predict → act → explain guidance, because the guidance is what carries the effect (scaffolded simulations beat identical unscaffolded ones, g+ = 0.60). You choose the eagerness (visuals eager|threshold|off), and your own review receipts then measure whether the medium actually holds better for you — docs/06-visual-encoding.md.

Procedures are practiced, not recited (v1.1) — some knowledge is a skill executed on instances (an integral, a git rebase, a statistical-test choice — any domain, declared per node by the content, never by a topic label). Those nodes enter by the worked-example ladder (study → complete → faded → solve; examples first is the best-replicated novice result in math, g ≈ 0.44) and are reviewed by solving a fresh variant — new numbers, same structure — next to the problems they're confused with, because practice format must match use format (transfer d = 0.58 congruent vs 0.28 not). Solutions are step-graded with the arithmetic verified by execution, and a slip is priced gentler than a wrong method. Engram stays a general learn-anything system; this layer wakes only where the content is a skill — docs/11-the-procedure-gap.md.

The session doesn't end on a failed retrieval (v1.5) — when a concept comes back wrong, Engram re-derives it, puts something else in between, and asks again, to one correct recall. Then it guarantees the dose: the first t

[truncated for AI cost control]