SFM-1 is a real neural network with 4,096 parameters, trained on Wikipedia's articles about sloths. It takes one training step every 10 minutes. It runs in the browser of everyone who opens this page, and everyone gets the exact same result. Right now it cannot spell. Around February it should manage the word sloth.
Every other AI lab races. This one hangs. The chart below is the model learning, live; the sloth hangs from wherever it has got to.
| Milestone | When | Status |
|---|---|---|
| Training run starts | 19 Sep 2026 | done |
| Output stops being pure noise (spaces between "words") | ≈ 26 Sep 2026 | … |
| Has read the whole training set once (epoch 1) | 6 Nov 2026 | … |
| Learns the word the | ≈ Nov 2026 | … |
| Learns the word sloth | ≈ Feb 2027 | … |
| Writes a sentence | not projected | — |
| Human-level (Shannon, 1 bit per character) | … | projected |
0x98ec799a2e8f9e5f7d285fab71dbdf0f4863472dContemporary language models are trained as fast as capital allows. We ask the opposite question: what is the smallest, slowest model that is still, in some technical sense, training? We present SFM-1 (Sloth Foundation Model), a character-level neural language model with exactly 4,096 parameters (212; 0.000004B) that takes one gradient step every ten minutes. Training is fully deterministic and is performed in the browser of whoever is reading this paper: every visitor recomputes the entire run from step 0 and arrives at a bit-identical checkpoint, which we verify with a published weight checksum. The model is trained on the English Wikipedia articles about sloths (56,007 characters). At the time of writing the loss is … nats per character after … steps, and the model cannot spell. Under the scaling law of Kaplan et al. we project human-level character prediction in the year …. All figures and tables in this document are live and update every ten minutes. We release the weights, all 4,096 of them.
The dominant paradigm in language modelling is to make the model larger and the training run shorter, until both are limited only by the availability of electricity [1, 2]. Laboratories now report throughput in tokens per second, wall-clock in days, and compute in units that require scientific notation. A great deal of intelligence is being produced very quickly.
Sloths (suborder Folivora) have pursued a different research agenda for roughly 60 million years. A three-toed sloth moves at approximately 0.27 km/h, digests a single leaf over the course of a month, and has the lowest mass-specific metabolic rate of any mammal [5, 6]. It is not fast. It is, however, extant, which is more than can be said for most of the things that were fast in the Pleistocene.
In this paper we take sloths seriously as a source of methodological guidance. We train a language model with a fixed budget of one gradient step every ten minutes, which we term sloth time, and we intend to keep training it indefinitely. Our contributions are:
(i) SFM-1, a 4,096-parameter character-level model, the first foundation model whose parameter count is a round number in binary and a rounding error in every other unit;
(ii) a training procedure that runs, deterministically, in the browser of every reader, so that this paper reproduces itself on being opened;
(iii) live results (Section 4), live samples (Section 5), and a scaling-law extrapolation that, uniquely in the literature, we will actually be around to check.
Scaling laws. Kaplan et al. [1] observe that loss falls as a power law in compute, data and parameters, and Hoffmann et al. [2] refine the compute-optimal frontier. Both papers extrapolate their fits many orders of magnitude beyond the measured range. We do the same, but in the other direction and over a longer time.
Small models. Bengio et al. [3] introduced the neural probabilistic language model; our architecture is a strict subset of theirs. Karpathy's makemore [4] established that a character-level MLP is enough to be embarrassing in public.
Slow animals as agents. Slug Network [7] demonstrated that a four-neuron reflex arc of Aplysia californica can browse Wikipedia. SFM-1 is a different animal in every sense: it does not browse, it does not act, and it has no neurons, only weights. Its training corpus is, however, from Wikipedia, which we regard as a spiritual citation.
Sloth biology. Cliffe et al. [5] report that sloths are the only mammal that cannot regulate body temperature well enough to digest at a fixed rate; digestion speeds up when it is sunny. We considered coupling the learning rate to the weather in Costa Rica and rejected it as an unnecessary source of speed.
SFM-1 is a multilayer perceptron over a window of the previous T = 6 characters (Table 1). Each character in a vocabulary of V = 31 symbols (the 26 lowercase letters, space, full stop, comma, hyphen and apostrophe) is embedded in D = 7 dimensions; the six embeddings are concatenated into a 42-dimensional vector, passed through a hidden layer of H = 52 rectified units, and projected to logits over the vocabulary. The parameter count is
VD + (TD)H + H + HV + V = 217 + 2184 + 52 + 1612 + 31 = 4096. (1)
The dimensions were chosen by searching over (T, D, H) for a total of exactly 212. No other ablation was performed.
| Quantity | SFM-1 | Note |
|---|---|---|
| Parameters | 4,096 | 212; 0.000004B |
| Context length T | 6 | characters |
| Embedding dim D | 7 | |
| Hidden units H | 52 | ReLU |
| Vocabulary V | 31 | a–z ␣ . , - ' |
| Batch size | 8 | windows per step |
| Optimiser | SGD | no momentum, no schedule, no regrets |
| Learning rate | 0.03 | constant |
| Step interval | 600 s | sloth time |
| Training tokens / day | 1,152 | characters |
| Seed | 4096 | mulberry32 |
| Precision | FP64 | we are not in a hurry |
The corpus is the plain text of four English Wikipedia articles, Sloth, Three-toed sloth, Two-toed sloth and Ground sloth, retrieved on 18 September 2026, lower-cased and restricted to the 31-symbol vocabulary, for a total of 56,007 characters. The word sloth occurs 332 times. We make no claim that the corpus is representative of language in general; we claim it is representative of sloths.
At 1,152 characters per day, one epoch takes 48.6 days. The model is therefore expected to have seen every character in its training set once by …. We will report this as a milestone.
Let t0 be the start of the run (2026-09-19T00:00:00Z). Gradient step k is taken at t0 + 600k seconds. Each step draws eight windows of seven characters at uniformly random positions in the corpus, computes the mean cross-entropy of the seventh character given the first six, and applies one update of plain stochastic gradient descent. Nothing else happens. Between steps the model hangs.
The wall-clock schedule is the whole point. A conventional run of this model would take a few seconds on a phone; ours takes 48.6 days per epoch, and Section 4.2 estimates the time to a competitive loss in geological units. We note that this is not an efficiency result. It is an efficiency result's opposite, and we have found it clarifying.
Because the run is defined entirely by the seed and the clock, any reader can reproduce it exactly: on opening this paper, the reader's browser initialises the weights from seed 4096 and replays every step from t0 to the present (Figure 1 shows this happening). Two obstacles had to be removed. First, JavaScript's Math.exp is not required to be correctly rounded and differs by an ulp between engines, which after tens of thousands of steps would let checkpoints drift apart across browsers. We therefore evaluate the exponential with a fixed-order Taylor polynomial in Horner form using only IEEE-754 addition, multiplication and division, which are correctly rounded everywhere, and scale by an exact table of powers of two (Appendix A). Second, the random number generator must be one with integer semantics; we use mulberry32. With these, the weight checksum printed at the top of this paper is identical in Chrome, Safari and Firefox, on every device, for every reader, at every step. We believe SFM-1 is the most reproducible model ever published, and, at 4,096 parameters, the least worth reproducing.
Table 2 reports the state of the run at the moment you are reading. All quantities are recomputed by the browser; none are stored on a server, because we do not have one. The row replay time is how long your device took to reproduce the entire run from scratch, which we include as a measure of how far behind the frontier we are: as of the first day, a phone catches up with the full history of SFM-1 in under a second.
| Metric | Value | Note |
|---|---|---|
| Gradient steps taken | … | since t0 |
| Wall-clock elapsed | … | |
| Characters seen | … | 8 per step |
| Epochs completed | … | of a 56,007-character corpus |
| Loss (EMA, nats/char) | … | uniform 3.434 · unigram 2.923 |
| Loss (bits/char) | … | human ≈ 1.0 [8] |
| Best loss so far | … | single step |
| Floating-point operations | … | ≈ 1.82 × 105 per step |
| Next gradient step in | … | mm:ss |
| Replay time on this device | … | to reproduce the run |
| Weight checksum | … | FNV-1a over FP64 bytes |
Kaplan et al. [1] report that loss falls with training steps as L(S) ∝ S−αS with αS ≈ 0.076. We adopt their exponent without checking whether it applies to a 4,096-parameter model, which is standard practice, and fit only the offset and scale by least squares to the EMA loss:
L(S) = L∞ + b · S−0.076. (2)
The fit is redrawn at every step (Figure 2). Solving (2) for the step at which SFM-1 reaches the entropy of English as estimated by Shannon [8], about 1 bit (0.693 nats) per character, and converting steps to sloth time, gives a projected arrival in the year …. We consider this a lower bound, as the model has 4,096 parameters and the target may be unreachable, but we would rather publish a date than a limitation.
For calibration, GPT-2 [9] was trained on roughly 40 GB of text. At 1,152 characters per day SFM-1 will have seen as much text in approximately 95,000 years, or about 1.6 times as long as sloths have existed. This is the longest projected training run in the literature and we have already started.
We sample 160 characters from the current checkpoint at temperature 0.8 with the sampling seed fixed to the step index, so every reader sees the same text at the same step and the text changes only when a step is taken. Prompts are shown in bold. The first sample is prompted with the sloth; the second with the phrase every paper contains.
Readers arriving on the first day will find that SFM-1 produces uniformly distributed noise. We ask them to return. Our internal projections, obtained by running the same code faster, suggest that spaces appear at around one week, the word the at around two months, and the word sloth at around four months, at which point we intend to issue a press release. Whole sentences are not projected.
Sample A · step … · T = 0.8…
Sample B · step … · T = 0.8…
…
Each gradient step costs approximately 1.82 × 105 floating-point operations, or 2.6 × 107 per day. On a laptop at a nominal 10 GFLOP/J this is 2.6 millijoules per day of training, distributed across readers. A three-toed sloth expends approximately 162 kJ per day at rest [6]. SFM-1 is therefore about sixty million times more energy-efficient than a sloth, and the sloth can at least spell its own name (Table 3).
We did not use a GPU. We did not use a CPU cluster. We considered requesting a compute grant and decided that the grant would take less time to be approved than the model would take to use it.
| System | Energy / day | Can spell "sloth" |
|---|---|---|
| SFM-1 (this work) | 2.6 mJ | not yet |
| Bradypus variegatus, resting | 162 kJ | n/a |
| One frontier training run | ≈ 1012 J | yes |
| This paper's fonts, downloading | ≈ 1 J | yes |
SFM-1 cannot spell. It has no attention, no depth, no notion of a word, and a context of six characters, which means it forgets the beginning of sloths before it reaches the end. It will not be useful for any task. We have not evaluated it on any benchmark because the benchmarks would need to be lower-cased and stripped of digits, and because the result is known.
The determinism guarantee depends on every reader's clock agreeing with UTC; a reader whose clock is wrong will be shown a checkpoint from a different time, which is a form of time travel we have not otherwise addressed. Readers with very old devices will reproduce the run more slowly, and after several years of training the replay may take longer than the interval between steps, at which point the reader will never catch up. We regard this as a feature; it is the first time a paper has been able to be behind its own results.
We believe SFM-1 is safe to release. Its capabilities are known exactly at every step, its future capabilities are predictable from Figure 2, and any dangerous capability would be announced by the loss curve several centuries in advance. It has no tools. It cannot sign a transaction. It cannot, at present, produce a vowel where a vowel is expected. Should the model ever achieve a loss below 1 nat per character we will convene a review; on current projections the review is scheduled for the year …, and we ask that it be put in the calendar now.
This work is funded by $SLOTH, a token on Robinhood Chain created by hand on Pons on 19 September 2026. The token has no relationship to the model beyond paying for the paper: the model cannot sign, has no wallet, and has no opinion. The only contract address is the one printed below and the only account is @SlothLabsAI; anything elsewhere is not ours. The training run does not depend on the token and will continue regardless, because it is not possible to stop something this slow.
0x98ec799a2e8f9e5f7d285fab71dbdf0f4863472dWe thank the sloths of the Cahuita National Park for their methodological example and for declining to comment. We thank the reviewers, who have been reviewing this paper at the pace of the model and are expected to submit their reports in 2031. Reviewer 2 has already asked for more baselines.
For x ∈ [−740, 709] let k = round(x / ln 2) and r = x − k ln 2, so |r| ≤ 0.35. We compute er by the degree-13 Taylor polynomial in Horner form, whose truncation error is below 10−16, and return 2k er, where 2k is read from a table built by repeated exact doubling. Every operation is a correctly rounded IEEE-754 addition, multiplication or division, so the result is bit-identical on every conforming platform. Softmax, sampling and the loss all use this function; the gradient of the cross-entropy through a softmax does not require a logarithm, so Math.log is used only for the numbers we print.
Model. SFM-1, 4,096 parameters, character-level MLP. Intended use. Hanging. Out-of-scope use. Anything involving text. Training data. Four Wikipedia articles about sloths [10]. Evaluation. Ongoing, live, Section 4. Bias. The model is biased towards sloths. Weights. Available via the button in Section 9 as JSON; the file is 4,096 numbers and a checksum. Licence. Do what you like; it cannot be made worse. Contact. @SlothLabsAI on X.
The model is exposed as window.__sfm with {model, steps, loss, sample(prompt, n, seed, temp), checksum()} for readers who would like to verify the checksum, generate their own samples, or watch nothing happen with more precision.