nagisanzenin/engram: a learning engine that makes your coding agent quiz you
Evidence-based learning engine — first-principles curricula, free-recall verification with receipts, FSRS-scheduled memory, and explorable artifacts. Learn anything; keep it.
At a glance
- What is it?
- Engram is an MIT-licensed, Python-based learning engine that runs inside nine agentic coding platforms. It turns your assistant into a tutor and a blind examiner, then schedules each idea with FSRS-4.5. Here is how to install it, what it actually does, and where it stops.
- Who is it for?
- Adopt Engram if you already work inside one of the nine supported agentic platforms, you want free-recall verification rather than another explainer chat, and you accept that the repository does not document a rollback path for the state folder.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 23 days ago.
- What is it written in?
- Mainly Python, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 19, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The problem Engram picks: you understood it, and it is already leaving
Ask a coding assistant to explain Kalman filters and you get a clean explanation. The README states the failure mode plainly: a chat has no memory of you, no test of whether you really got it, and no plan for the forgetting that starts when you close the terminal. Engram is aimed at that gap, and at the human on the other side of it, not at the agent.
The README spends its first paragraph ruling out a misreading. Engram is not an agent-memory plugin. It does not 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: 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 before you drop it.
That framing decides who the project is for. It fits an engineer who already lives in Claude Code, OpenCode, Codex or one of the other six platforms and wants a study loop attached to that environment. It does not fit someone shopping for a general-purpose flashcard app, and it does not fit a team looking to give an agent more context about a repository.
First-principles curricula, a blind assessor, and FSRS-4.5 on the back end
The engine splits into three jobs, and the repository layout shows where each lives. The skills/ directory holds the tutoring and review flows the platform invokes; agents/ holds the assessor and the subagents the README names as architect and smith; hooks/ holds the session nudge; scripts/ holds the engine that runs on stock python3. The README says the engine has no network code, and that this is enforced by a permanent selftest rather than asserted in prose.
The verification step is the part worth examining. The examiner is blind: it does not see the material you studied, so it cannot grade you against the explanation you were just given. On platforms without a subagent tool, the README says the skills spawn the assessor as a fresh process instead, which is isolation by process boundary. On OpenClaw, the agents are not registered at all; the skills spawn them through sessions_spawn with isolated context, which the README gives as the reason the assessor stays blind. On ZCode, the assessor runs as a fresh-context generic Agent child.
Scheduling is FSRS-4.5, per the version badge and the topics list. FSRS is a spaced-repetition scheduler family, and Engram's contribution is not the algorithm. It is the pairing: a free-recall check whose result feeds the schedule, plus the claim that the engine adapts from your own data. The README also points at gold/assessor-gold.jsonl and a grader-inflation count, with a note that the number was earned on an 86-item set and that a stale-gold check forces a re-audit. That is a self-imposed measurement discipline, and it is more than most learning tools publish. It is still the project grading its own grader, which is a weaker form of evidence than an outside evaluation.
Installing Engram in Claude Code and running a first review
The README gives the Claude Code install as two commands, and calls that the whole onboarding: no config, no account, no cards to write. The only runtime requirement stated is python3, with the stock macOS or Linux interpreter described as sufficient because the engine is stdlib only.
claude plugin marketplace add nagisanzenin/engram
claude plugin install engram@engramAfter the second command completes, the plugin is registered and the slash commands become available. The README lists /learn, /review and /coach for Claude Code, and notes that the command spelling differs per platform: Codex uses $learn, $review and $coach, and Hermes Agent uses /skill learn or /study.
/learn kalman filtersThe README uses exactly that line, with music theory, Rust lifetimes and "anything" offered as substitutes. Running it starts a tutoring session on the topic. The README does not describe the session's internal steps, so the honest expectation is: your agent teaches, then examines you by free recall, and the result goes into the schedule.
For OpenCode, installation moves to the plugin array in opencode.json. The README says that file is read globally at ~/.config/opencode/opencode.json or per-project.
{
"plugin": ["opencode-engram-learning"]
}The npm package is opencode-engram-learning, and the README gives a source pin as an alternative: "plugin": ["git+https://github.com/nagisanzenin/engram.git"]. The package.json declares a peer dependency on @opencode-ai/plugin ^1.4.3 and an engines field of opencode >=1.0.0 || >=0.0.0-0. OpenCode 2.0 beta uses a new plugin API; the README says the same package name works there and the V2 adapter is selected automatically.
State is the part that matters after the first session. The README says there is one state folder shared across every platform, so you can learn in one tool and review in another on the same schedule. It does not document where that folder lives, what its file format is, or how to roll it back. Back it up before you accumulate weeks of review history, because the README gives you no recovery path.
Nine platforms, and the nudge that does not always fire
Porting Engram to nine agentic platforms is the project's most distinctive engineering choice, and also where the sharpest limitations sit. Each port is documented in its own INSTALL file, and the README's footnotes are unusually candid about what is missing.
On Google Antigravity, the due-review session nudge is not ported yet, and the architect and smith subagents are dropped by AG 1.1.4's strict installer. Everything else reportedly works the same. On OpenClaw, the nudge needs internal hooks switched on, because the platform ignores plugin hooks until then, and it fires on /new and /reset rather than every session. On Pi, there is no subagent tool by design, so the assessor runs as a separate pi -p process, and the nudge is one TUI notice at session start plus one injected message on your first prompt, with the next prompt as the worst case. On ZCode, the shared hook script detects ZCODE_PLUGIN_ROOT and emits JSON, because ZCode discards plain SessionStart stdout and logs non-JSON runs as failed.
Two ports carry an explicit caveat that a live model-driven session is not yet recorded: DeepSeek Harness and ZCode. The README asks for first-run reports. That is a fair way to ship a preview, but it means the end-to-end path through a real model is unverified on those two platforms, and anyone adopting them is doing the last mile of testing. DeepSeek Harness also needs a DeepSeek API key, and its port is described as developer preview, relying on stock dsh capabilities so that harness drift degrades a surface rather than crashing.
The pattern is consistent: the deeper a platform departs from Claude Code's plugin surfaces, the more the nudge and the subagent isolation get reshaped, and the more platform-specific the failure modes become.
Where Engram is the wrong tool
The first wrong fit is anyone who wants the agent to know more. Engram deliberately does not do that. If your problem is that your assistant forgets your architecture decisions between sessions, this project does nothing for it, and the README says so before it says anything else.
The second is portability. State is shared across platforms through one folder, but the entry points are platform plugins. There is no documented CLI that runs a review outside an agentic coding tool, and the repository's top-level entries are plugin manifests, skills, hooks, agents and install documents. If you want to study on a phone during a commute, Engram's surfaces do not cover that.
The third is the unverified paths. On DeepSeek Harness and ZCode, the README states that a model-driven session has not been recorded. Adopting either as your primary platform means you are the one who finds out. On Antigravity, two subagents are dropped by the installer and the nudge is absent, so the loop is thinner than the table implies.
The fourth is measurement. The grader-inflation figure is the project auditing its own assessor against its own gold set. The README notes it was earned on an 86-item set and that a stale-gold check enforces re-audit, which is a real control. It is not an independent benchmark, and it should not be read as one.
How it differs from Anki and from agent-memory plugins
Anki is the obvious comparison, and the difference is where the cards come from. Anki is a scheduler with a manual authoring step: you write the front and back, or import a deck, and the review is self-graded. Engram generates the curriculum from a topic prompt inside your coding agent, then verifies with free recall rather than a card flip, and feeds the result into FSRS-4.5. The trade is control for convenience. Anki gives you a durable, portable, offline collection you own in a documented file format; Engram gives you a low-friction loop whose state folder the README does not document at all. If you already maintain a large Anki collection, Engram does not read it, and nothing in the repository suggests an import path.
The second comparison is the one the README raises itself: memory MCPs and context tools. Those make the agent more capable by giving it persistent context. Engram makes you more capable by testing you. They are not substitutes, and running both is coherent, because they act on different parties. The confusion the README is trying to prevent is a user installing Engram expecting agent memory and concluding it is broken when the agent learns nothing new.
Licence, maintenance and what an upgrade actually costs
The licence is MIT, declared in the LICENSE file, in package.json, and on the README badge. MIT is permissive: reuse, modification and redistribution are allowed with the copyright notice retained. That is a statement about the licence text, not legal advice, and it says nothing about the npm package's transitive dependencies, which are not enumerated in the repository.
On maintenance, the last push to the default branch was on 2026-08-27, and the repository is not archived. The three most recent releases land on the same days: v1.15.1 and v1.15.0 on 2026-08-27, v1.14.0 on 2026-08-18. Release titles are descriptive rather than numeric, which tells you the project ships in themed increments: v1.15.0 added ZCode as a ninth platform, v1.14.0 added what it calls the sense-making layer.
Upgrade cost has two components, and only one is cheap. The plugin code upgrades through the platform's own mechanism, and for OpenCode that means the npm package or the git source pin. The expensive component is the state folder. Because one folder serves every platform, a change to its format would touch every environment at once, and the README does not document a migration procedure or a version field. The release note for v1.15.1, described as what the post-release review caught, suggests the project does review its own releases, but a review note is not a migration guarantee. Copy the state folder before upgrading if you have review history you care about.
Editorial conclusion
Adopt Engram if you already work inside one of the nine supported agentic platforms, you want free-recall verification rather than another explainer chat, and you accept that the repository does not document a rollback path for the state folder. Do not adopt it if you need a portable, platform-neutral study system, if you expect the engine to remember your codebase for your agent (it does not), or if you need a recorded model-driven session on DeepSeek Harness or ZCode before you commit. Verify first that python3 resolves on the same machine as your agent, that the two Claude Code marketplace commands install cleanly in your environment, and that the state folder lands somewhere you are willing to back up yourself.
Frequently asked questions
How to install engram?
In Claude Code the README gives two commands: claude plugin marketplace add nagisanzenin/engram, then claude plugin install engram@engram. Other platforms use their own installers, documented in per-platform files such as INSTALL-CODEX.md, INSTALL-PI.md and INSTALL-ZCODE.md. The only stated runtime requirement is python3.
What is an example of an engram?
The README does not define the term or give an example; it uses the name for a learning engine that turns a coding agent into a tutor and a blind examiner. The repository contains no definition of engram as a memory trace.
What is an engram in psychology?
The repository does not answer this. The README describes Engram as an evidence-based learning engine with first-principles curricula, free-recall verification and FSRS-4.5 scheduling, and never discusses the psychological concept.
How do I use engram points?
Engram has no points system. The documented surfaces are slash commands such as /learn, /review and /coach, an FSRS-4.5 schedule, and a shared state folder. Anything about points refers to a different product.
How do I use engrams in Destiny 2?
The repository does not cover Destiny 2. Engram here is an MIT-licensed learning engine for agentic coding platforms, installed as a plugin in Claude Code, OpenCode, Codex or one of six other platforms.
Community notes