Legal & financial language, learned from nothing.

Everything we built, at a glance

Three origins — a 125M we pretrained from noise, the mentor's 500M we adopted, and Google's Gemma 2 2B off the shelf — each run through the same five-phase pipeline: pretrain, SFT, RAFT, DPO, and RLAIF. Twenty-two models in all. Everything below is live.

Complete the passage

Give it the opening of a brief, a filing, or an opinion, then watch the model continue it, one token at a time. These are the real 125M model weights, generating live.

Now ask it a question

Fine-tuned on 5,846 grounded legal & financial Q&A pairs, the same 125M model stops rambling and starts answering. It is a separate model, legal-slm-125m-sft ↗, that streams its reply as you watch.

Now ground it in your context

One more layer. legal-slm-125m-raft ↗ was RAFT-tuned (Retrieval-Augmented Fine-Tuning) to answer from context you provide, quote the exact source, and ignore unrelated distractor text. Paste a passage, add some noise, and ask.

Preference-tuned: DPO and RLAIF

After SFT and RAFT, one more layer: align the model to preference. Pick a method — direct preference optimization (DPO), or a reward model plus GRPO (RLAIF) — a base stage to build on, and a size. Twelve real models, live on the GPU.

Same data, two very different models

We ran the identical SFT and RAFT datasets through a real pretrained model — Gemma 2 2B ↗ — using QLoRA (4-bit base, only 0.79% of weights trained). Pick it in the model selectors of the Chat, RAFT, and Alignment panels above, next to our 125M and 500M. Here is exactly what each phase costs and trains.

The trade is the whole lesson. Our 125M was built from a random init for ~$36 and is small enough to run in a browser tab — but it is a toy. Gemma borrows a $millions Google pretraining for free, trains 20.8Madapter weights instead of all 2.6B, and answers far more fluently — but it needs a GPU to serve, and every token it "knows" came from someone else's pretraining, not ours.

Every model, one scoreboard

Every model on the same held-out sets, in two views. Quality is an independent LLM judge (DeepSeek-V3, which made none of our training data) scoring each answer out of 10 against a gold reference and its evidence — reference-grounded, so it is checkable rather than vibes, and it finally makes the DPO/RLAIF work visible. Capability is the tokenizer-fair side: bits-per-byte language modeling plus exact-match accuracy. Both include Gemma 2 2B off the shelf, so you can see what a real pretrained model scores with zero legal training.

Two things jump out. Grounded accuracy climbs at every stage — our tiny model goes 1.4% → 7.1% → 24.3% across base → SFT → RAFT, and Gemma lands highest at 37%. But watch the faithful-refusal column: Gemma off-the-shelf already declines 90% of unanswerable questions, our SFT step destroys that instinct (it learns to always answer, 0%), and only RAFT with abstention examples brings it back — to 100% for Gemma. And you can watch abstention emerge with scale: the 125M RAFT never learns to refuse (0%), the 500M RAFT starts to (20%), Gemma nails it (100%). Faithfulness isn't a prompt trick — past a point it's a capability that costs parameters.

The + DPO and + RLAIF rows are a full preference-optimization sweep on top of every SFT and RAFT model (DPO on ~4.7k AI-labeled pairs; RLAIF = a Bradley-Terry reward model then GRPO). Read them honestly: these methods tune response quality and style— helpfulness, structure, and, where the pairs teach it, faithfulness — which strict exact-match accuracy barely registers. So the capability columns hold roughly steady (they mostly don't regress), faithful refusal is preserved (Gemma RAFT stays at 100% through both), and where a model over-optimizes you can see it: Gemma RAFT + DPO's bits/byte balloons to 1.59 as it leans hard into the preferred abstain-heavy style. Quantifying the quality gain itself would need an LLM-judge win-rate — the natural next column.

What the whole thing cost

Every model on the board, every dataset, every GPU-hour — tracked. Building a base model from scratch is the expensive part; adapting one is cheap. Here is the honest ledger.

Making generation fast

Two optimizations every real serving stack uses, running live on GPUs. The first is exact and free; the second is exact but only pays off when a small model can guess what a big one will say.

The lesson in both: throughput is not one number. The KV cache turns a quadratic cost linear, and its payoff grows with how many users you batch together. Speculative decoding trades extra draft compute for fewer expensive target steps, and only wins when the draft agrees often enough — try a numbered list versus a poem and watch the acceptance rate, and the speedup, move together.

Small model, honest accounting

Perplexity, falling

Held-out perplexity measured on a 20.6-million-token validation set the model never trained on. Two epochs, 7,778 optimizer steps, from a random start to 9.13.

A Llama, in miniature

Two billion tokens, hand-cleaned

Streamed from public datasets, then run through a deterministic pipeline: rule-based cleaning, an OCR-garble gate, MinHash-LSH near-duplicate removal, and 13-gram decontamination against the CaseHOLD and LexGLUE benchmarks.

What this is, and is not