hippocampus | SM-2 vs FSRS

hippo-campus.io is a bring-your-own-repo flashcard/studying webapp for reinforcing the working memory of one's own fields of interest. If you're working with an agentic coder (say doing several literature reviews), you may find yourself wanting to be able to remember important technical information or say important historical dates (e.g. Cybenko published in 1989; the Protestant Reformation was in the 16th century; etc.) on your own, especially nowadays with an extreme acceleration of expanding the frontiers of the sciences. The human may be out of the loop when letting agentic coders run free on several projects, but hippocampus aims to help, having the agent make flashcards about information gleaned from or about those projects. That's the main goal, but it can be used for regular studying as well; in fact you could interface with an agentic coding session to create decks for hippocampus.

The thing that makes flashcard apps like Anki or Quizlet effective is spaced repetition, which has one practical job: estimate when memory of some info is becoming fragile, then spend a review at a useful moment. There are two algorithms, SM-2 and FSRS, which have very different solutions to that estimation problem.

SM-2 is a compact heuristic from the late 1980s. FSRS is a trainable model of memory state. Both are trying to keep recall high without burying the learner in reviews, but only one of them explicitly models the thing we care about: the probability that a card can still be recalled.

A tl;dr for hippocampus is FSRS is the better default. The interesting part is not that it is newer. It is that its internal representation matches the scheduling problem more closely, and its recall predictions are much better calibrated on a large public benchmark.

SM-2: an elegant multiplier

The original SM-2 algorithm associates each item with an easiness factor, initially (EF=2.5). Successful reviews grow the interval according to a simple recurrence:¹

$$I_1 = 1,\qquad I_2 = 6,\qquad I_n = I_{n-1}EF \quad (n>2).$$

After a review graded (q) on a scale from 0 to 5, the easiness factor changes by

$$EF' = \max\left(1.3,\; EF + 0.1 - (5-q)\left(0.08 + 0.02(5-q)\right)\right).$$

A failed review restarts the interval sequence, while the floor at (1.3) prevents difficult cards from appearing with absurd frequency.

There is a lot to admire here. The rule is transparent, cheap to compute, and was designed when personal computers were extremely constrained. It also introduced an important idea: cards should not all grow at the same rate.

The limitation is what the easiness factor has to stand in for. One number is asked to summarize item difficulty, the learner's current memory strength, and the effect of time. The interval is then produced by multiplying the previous interval rather than by asking, “What is the probability of recall on day (t)?” The original formula was explicitly constructed heuristically.¹

One naming caveat matters: Anki's legacy scheduler is commonly called “SM-2,” but it is a descendant with its own rules. The benchmark below evaluates the implementation labeled SM2 in the open SRS benchmark; it is not a claim that every historical or app-specific variant behaves identically.

FSRS: model the memory, then choose the date

FSRS represents a card with three distinct ideas:

• Difficulty (D): how hard the item tends to be for this learner.
• Stability (S): how long the memory can remain durable.
• Retrievability (R): the estimated probability of recalling it now.

As time passes, (R) falls along a forgetting curve. A review changes (D) and (S) according to the grade and the card's prior state. The scheduler can then choose the interval (t^*) that reaches a desired retention (r^*):

$$R(t^*) = r^*.$$

That inversion is the conceptual leap. Instead of growing yesterday's interval by a fixed ease multiplier, FSRS predicts recall and schedules against a target. Its optimizer learns parameters from a learner's review history, fitting the model to the person and material rather than assuming one universal set of multipliers.²

Concretely, a simple forgetting curve captures the idea — recall decays from 1 and crosses the 90% target exactly when elapsed time equals stability:

$$R(t) = \frac{1}{1 + t/(9S)}, \qquad R(S) = 0.9.$$

Inverting it turns a retention target into a date: to study at desired retention (r), wait (t^* = 9S\left(\tfrac{1}{r} - 1\right)) days. FSRS-6 generalizes the curve with a learnable decay parameter, so its flatness can vary per user, but the logic is identical — predict (R(t)), then invert to schedule. Drag the sliders to watch stability and the retention target move the interval:

{ "id": "forgetting-curve", "stability": 8, "retention": 0.9 }

The underlying work frames review scheduling as an optimization problem under a model of memory dynamics.³⁴ Modern FSRS versions refine the forgetting curve, short-term behavior, and personalization, but the central structure remains legible: estimate memory state, predict recall, and choose an interval.

What the benchmark says

The open SRS benchmark uses review histories from 10,000 Anki users and evaluates predictions on later reviews after training on earlier ones. Its current no-same-day evaluation contains 349,923,850 reviews.⁵ The interactive figure compares the published FSRS aggregates with the benchmark's per-user SM-2 results.

{ "id": "sm2-fsrs-benchmark", "metric": "logLoss" }

The three controls expose different questions:

• Log loss penalizes bad probability estimates, especially confident wrong ones.
• RMSE (bins) asks whether predicted recall rates match observed recall rates in comparable groups.
• AUC asks whether the model can distinguish likely recalls from likely lapses.

For calibration metrics, lower is better. For AUC, higher is better. On this evaluation:

Model	Log loss ↓	RMSE (bins) ↓	AUC ↑
SM-2	0.7220	0.2031	0.6026
FSRS-4.5	0.3624	0.0764	0.6893
FSRS-6	0.3460	0.0653	0.7034
FSRS-7	0.3437	0.0655	0.7069

Relative to SM-2, FSRS-7 has about 52% lower log loss, 68% lower binned RMSE, and an AUC higher by 0.104. The exact ranking among FSRS versions changes slightly by metric—FSRS-6 has a marginally lower binned RMSE here—but the separation between the FSRS family and SM-2 is large and consistent.

Those numbers support a specific claim: FSRS predicts recall substantially better on this benchmark. They do not, by themselves, prove that every learner will retain more facts, that every deck will require fewer reviews, or that FSRS-7 is always the best scheduler configuration. This is an observational benchmark of prediction, not a randomized learning experiment.

Two qualifications keep those numbers honest. First, versions: the headline row pairs FSRS-7 with SM-2, but FSRS-7 is brand-new — 35 parameters, fractional intervals — and is not what most apps ship. Hippocampus will run FSRS-6, the current stable 21-parameter model, and that barely moves the conclusion: FSRS-6 still cuts log loss by roughly 52% versus SM-2 (0.346 against 0.722), while FSRS-7's extra machinery buys only a marginal gain (0.3437 against 0.3460).

Second, optimization: every FSRS score above uses parameters fit to each user's own review history. With default parameters and no personal data, FSRS-7 scores about 0.363 log loss and 0.091 binned RMSE — still far ahead of SM-2, but a reminder that part of FSRS's advantage is earned by fitting the model to you. A fresh deck starts near that default-parameter row and only approaches the headline numbers once it has collected enough honest grades to optimize on. For Hippocampus, that default operating point — not the optimized figure — is the realistic day-one experience.

Why prediction quality changes scheduling

Scheduling is a decision made from a probability estimate. If that estimate is poorly calibrated, the system pays in one of two ways:

1. It reviews too early, when the card was still secure, wasting attention.
2. It reviews too late, after the memory has already failed, increasing relearning.

A fixed interval multiplier can work surprisingly well in the middle of the distribution. It has less room to respond when two cards with similar histories have different difficulty, when a learner returns late, or when an answer changes the estimated memory state in a way that is not captured by an ease factor.

FSRS has a better vocabulary for those cases. Difficulty, stability, and retrievability can move independently. A late successful review is evidence that stability was underestimated; a lapse is evidence in the other direction. The optimizer can learn how strongly those events should matter for a particular review history.

This does not make the scheduler omniscient. The model only sees the signals it is given. In Anki, pressing Hard after actually forgetting tells FSRS that recall succeeded, corrupting the observation. The official manual therefore recommends using Again for a failed recall and treats Hard as a passing grade.² Both schedulers are ultimately driven by the same four buttons — Again, Hard, Good, Easy — so SM-2's nominal 0–5 scale is really those four grades mapped onto its recurrence, and FSRS consumes the same four directly (as does Hippocampus).

The retention dial is the real product decision

Better prediction does not remove the trade-off between memory and time. It makes the trade-off controllable.

FSRS exposes desired retention: the probability of recall the scheduler should target when a card becomes due. A target near (0.90) is the default in Anki. Raising it produces shorter intervals and more reviews; as the target approaches (1.0), workload rises sharply.²

That means “FSRS is better” should not be read as “turn every setting to maximum.” A useful scheduler should let the learner decide how much forgetting is acceptable, then spend reviews efficiently at that operating point.

For Hippocampus, I would start with a simple policy:

• use FSRS rather than a home-grown SM-2 variant;
• begin with desired retention at (0.90);
• collect honest grades and enough history before optimizing parameters;
• optimize per preset when decks represent genuinely different material;
• show the user the workload consequence before changing retention.

SM-2 remains worth studying because it is understandable in a few lines and because it shaped nearly every scheduler that followed. But if the system has review history and enough compute to fit a small model, preserving a single ease multiplier is nostalgia, not parsimony.

FSRS is better here for a plain reason: it makes a better estimate of memory, and a scheduler cannot consistently make better timing decisions than the estimates it is built on.

Next time you try out hippo-campus.io, it will by default use FSRS to help you retain information.

Footnotes

1. Piotr Woźniak, “SuperMemo 2: Algorithm”, describing the interval recurrence, easiness-factor update, and the heuristic origin of SM-2. ↩ ↩²

2. Anki, “Deck Options: FSRS”, including desired retention, parameter optimization, and grading guidance. ↩ ↩² ↩³

3. Jarrett Ye, Jinghua Su, and Yuncheng Cao, “A Stochastic Shortest Path Algorithm for Optimizing Spaced Repetition Scheduling”, Proceedings of KDD 2022, pp. 4381–4390. ↩

4. J. Su, J. Ye, L. Nie, Y. Cao, and Y. Chen, “Optimizing Spaced Repetition Schedule by Capturing the Dynamics of Memory”, IEEE Transactions on Knowledge and Data Engineering. ↩

5. Open Spaced Repetition, SRS Benchmark. FSRS figures are the repository's published no-same-day aggregate scores. The SM-2 means and 99% confidence intervals in the figure are calculated from its published result/SM2.jsonl file. ↩