Sloth Labs · $SLOTH · Robinhood Chain via Pons

An AI is training in your tab right now.
It is the slowest one ever made.

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.

● LIVE  training loss, lower is smarternext training step in --:--
Training steps
since 19 Sep 2026, 00:00 UTC
Training for
one step per 10 minutes
Can it spell "the"?
expected around Nov
Can it spell "sloth"?
expected around Feb

What it is saying right now

Fresh text from the current model. It changes only when a training step happens, and it is identical for everyone on earth looking at this page. Type your own prompt in Figure 4 of the paper below.

Roadmap

MilestoneWhenStatus
Training run starts19 Sep 2026done
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 sentencenot projected
Human-level (Shannon, 1 bit per character)projected
It is real. A 4,096-parameter character model (2¹², exactly). Plain SGD, one step per 600 seconds, nothing faked. The weights are downloadable.
Everyone sees the same thing. Your browser replays the whole run from step 0 when you open the page. Same seed, same clock, same checksum on every device.
It is a paper. The full write-up is below, in the format every AI lab uses, with live figures. Scroll past it for the token ticket, or click Buy.
Ticker
$SLOTH
Chain / venue
Robinhood Chain · Pons
Contract address · Robinhood Chain
0x98ec799a2e8f9e5f7d285fab71dbdf0f4863472d
Read the paper: "Scaling Laws for Slow Language Models"
The token pays for the paper. The model has no wallet and cannot sign; it is busy. Launched on Pons, 19 Sep 2026.
Preprint · arXiv:2609.04096 · Sloth Labs Technical Report 001

Scaling Laws for Slow Language ModelsSFM-1: a 4,096-parameter foundation model trained at the pace of a sloth

Bradypus Variegatus1   Choloepus Hoffmanni1   Megatherium Americanum2†
1Sloth Labs, Puerto Viejo de Talamanca, Costa Rica   2Pleistocene
@SlothLabsAI   extinct, c. 10,000 BCE
19 September 2026 · Training run started 2026-09-19 00:00 UTC

Abstract

Contemporary 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.

This is a live paper. Results below are computed in your tab, not fetched. Next gradient step in --:--. Weight checksum computing…. If your checksum matches a friend's on another browser, the experiment reproduced.

1Introduction

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.

2Related work

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.

3Method

3.1Architecture

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.

Table 1: Hyperparameters. Everything about SFM-1 that is fixed. Compare with the tables in [1, 2], which have the same columns and different numbers.
QuantitySFM-1Note
Parameters4,096212; 0.000004B
Context length T6characters
Embedding dim D7
Hidden units H52ReLU
Vocabulary V31a–z . , - '
Batch size8windows per step
OptimiserSGDno momentum, no schedule, no regrets
Learning rate0.03constant
Step interval600 ssloth time
Training tokens / day1,152characters
Seed4096mulberry32
PrecisionFP64we are not in a hurry

3.2Training data

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.

3.3Training in sloth time

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.

3.4Determinism and reproducibility

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.

4Results

training loss, nats / character● LIVE
Reproducing the training runInitialising 4,096 parameters from seed 4096…
Figure 1: Training loss of SFM-1, live. Per-step cross-entropy (grey) and its exponential moving average (black) against wall-clock time since t0. Dashed lines mark the loss of a uniform predictor (ln 31 = 3.434) and of the corpus unigram distribution (2.923). The sloth hangs from the most recent step and moves along the curve as training proceeds; readers who have never seen a loss curve go down in real time are invited to wait --:--.

4.1Training metrics

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.

Table 2: Live training metrics. Updated every ten minutes. A full row is added to the training history at each step; nothing is ever deleted, because the sloth has not yet learned how.
MetricValueNote
Gradient steps takensince t0
Wall-clock elapsed
Characters seen8 per step
Epochs completedof 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 farsingle step
Floating-point operations≈ 1.82 × 105 per step
Next gradient step inmm:ss
Replay time on this deviceto reproduce the run
Weight checksumFNV-1a over FP64 bytes

4.2Scaling law and extrapolation

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.

loss vs. gradient steps (log axis), with fit (2)● LIVE
Figure 2: Scaling law. EMA loss (black) against the step index on a logarithmic axis, the least-squares fit of Eq. (2) (red, extrapolated), and reference losses. Vertical marks give the wall-clock year at which each step count is reached under sloth time. The horizontal axis extends to 109 steps, i.e. the year 21,000, so that the fit has somewhere to go. The fit becomes meaningful after roughly a thousand steps (a week); before that it is included for completeness and comedy.

5Qualitative analysis

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
Figure 3: Samples from SFM-1 at the current step. Identical for every reader at the same step. If yours differ from a friend's, one of you is in the future.
Figure 4: Interactive completion. The model responds instantly; this is the only fast thing about it, and we apologise for it.

6Compute and environmental impact

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.

Table 3: Energy budget. Daily energy of SFM-1 versus reference systems. All figures approximate; the model figure is an upper bound, the sloth figure is from the literature, and the data-centre figure is from a press release.
SystemEnergy / dayCan spell "sloth"
SFM-1 (this work)2.6 mJnot yet
Bradypus variegatus, resting162 kJn/a
One frontier training run≈ 1012 Jyes
This paper's fonts, downloading≈ 1 Jyes

7Limitations

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.

8Safety

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.

9Funding and token

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.

Ticker
$SLOTH
Chain / venue
Robinhood Chain · Pons
Model
SFM-1 · 4,096 params
Status
Deployed · Pons · 19 Sep 2026
Contract address · Robinhood Chain
0x98ec799a2e8f9e5f7d285fab71dbdf0f4863472d

Acknowledgments

We 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.

References

  1. J. Kaplan, S. McCandlish, T. Henighan, T. B. Brown, B. Chess, R. Child, S. Gray, A. Radford, J. Wu, D. Amodei. Scaling laws for neural language models. arXiv:2001.08361, 2020. arxiv.org/abs/2001.08361
  2. J. Hoffmann et al. Training compute-optimal large language models. arXiv:2203.15556, 2022. arxiv.org/abs/2203.15556
  3. Y. Bengio, R. Ducharme, P. Vincent, C. Jauvin. A neural probabilistic language model. JMLR 3, 2003.
  4. A. Karpathy. makemore. github.com/karpathy/makemore, 2022.
  5. R. N. Cliffe, J. D. Scantlebury, S. J. Kennedy, J. Avey-Arroyo, D. Mindich, R. P. Wilson. The metabolic response of the Bradypus sloth to temperature. PeerJ 6:e5600, 2018.
  6. J. N. Pauli, M. Z. Peery, E. D. Fountain, W. H. Karasov. Arboreal folivores limit their energetic output, all the way to slothfulness. The American Naturalist 188(2), 2016.
  7. Slug Network. A sea slug is browsing Wikipedia. sea-slug.vercel.app, 2026.
  8. C. E. Shannon. Prediction and entropy of printed English. Bell System Technical Journal 30(1), 1951.
  9. A. Radford, J. Wu, R. Child, D. Luan, D. Amodei, I. Sutskever. Language models are unsupervised multitask learners. OpenAI, 2019.
  10. Wikipedia contributors. Sloth; Three-toed sloth; Two-toed sloth; Ground sloth. Wikipedia, The Free Encyclopedia, retrieved 18 September 2026. en.wikipedia.org/wiki/Sloth

Appendix A   A deterministic exponential

For x ∈ [−740, 709] let k = round(x / ln 2) and r = xk 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.

Appendix B   Model card

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.

Appendix C   Console

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.

Sloth Labs · Technical Report 001 · arXiv:2609.04096X ↗  ·  Read about the animal ↗
1