Hollow at the Header: What Happens When You Give a Model 19 Trillion Parameters and Nothing Else

By Vicktor Moberg

This past week I published a model to Hugging Face called leviathan-19t. According to the platform, it is a 19.0-trillion-parameter model — roughly 15% larger than the previous record-holder in its category. It also does nothing. It contains no trained weights, no learned behavior, no capability of any kind. Every one of those 19 trillion declared parameters is a zero.

I built it to make a point, and the point turned out to be more interesting than the joke.

How It Works

Hugging Face computes a model's parameter count by reading the headers of its safetensors files — the format most models are now distributed in — and summing the declared shape of every tensor. It does not evaluate whether the numerical values contain trained information, useful structure, or anything meaningful. It just does the arithmetic on what the header says should be there.

So I gave it a header to do arithmetic on. leviathan-19t declares 4,422 tensors of shape [65536, 65536] at 4 bits per parameter, plus one enormous position-embedding tensor, spread across 444 shards. Multiply it out and you get 18,996,640,350,208 declared parameters — enough to edge out the previous record, a project called vacuum-16t, which this one builds directly on.

The safetensors format won't let you fake the underlying structure. It requires the file's total length to equal the header size plus the data size exactly, and it requires every tensor's byte range to tile the data section without gaps or overlaps. So every declared byte genuinely exists on disk. Nothing about the file is corrupted or malformed. It's simply all zeros — 9.5 terabytes of them, declared as "storage consumed" even though the actual shards are sparse files: holes on disk that report their full size to anything that asks, read back as zero, and take up almost no real space. On the wire, deduplication collapses the whole thing to a few hundred kilobytes, because every chunk of zeros is byte-identical to every other chunk of zeros and only has to cross the network once.

Nineteen trillion parameters. No capabilities. Total cost to produce: 3 hours of my time and a $9/month Hugging Face Pro Subscription.

So, What’s the Point?

I didn't build leviathan-19t because I think Hugging Face's counter is broken in some scandalous way — it's doing exactly what it was designed to do, which is read a header and trust it. I built it because "parameter count" has quietly become one of those numbers the field treats as a proxy for something it doesn't actually measure — capability, training investment, the scale of the bet a lab was willing to make — and I wanted a clean, undeniable demonstration of the gap between the number and the thing the number is supposed to stand for.

This is Goodhart's Law, and it's older than any of us working in this field: when a measure becomes a target, it stops being a good measure. Parameter count was useful shorthand for a long time because you genuinely couldn't produce a large one without doing the expensive thing it implied. leviathan-19t breaks that coupling on purpose, in public, with the mechanism fully documented in the model card. No one has to take my word for what it demonstrates. Anyone can go verify it themselves.

Where Else This Shows Up

Once you've built something like this, you start noticing the same shape everywhere in how the field talks about its own progress:

• Context window figures describe what a model can technically accept, not the length over which it actually attends reliably.

• Training token counts describe volume, not distinctness or quality — ten trillion tokens of repetitive scraped text is not ten trillion tokens of signal.

• Compute figures describe resources expended, not whether every unit of computation produced useful learning.

• Evaluation scores describe performance on a particular test suite, not the totality of a system’s behavior.

None of these are lies. Each is an honestly computed number describing a real artifact — same as my 19 trillion parameters. The problem isn't dishonesty. It's that we keep substituting the number that's easy to declare and hard to verify for the number that's hard to declare and hard to verify, and then building leaderboards, funding decisions, and public trust on top of the easy one.

What This Experiment Demonstrates

The point of leviathan-19t is not that parameter count is meaningless. It is that parameter count means less than people often assume.

It can describe the scale of a tensor layout. It can suggest storage requirements. Within comparable architectures and training regimes, it can be a useful shorthand. But it cannot tell you whether a model was trained, whether its weights contain useful information, or whether it can do anything at all.

Leviathan makes that distinction unusually difficult to ignore. It is structurally valid, correctly counted, and entirely empty.

The obvious response may be to exclude non-functional checkpoints from size rankings. That would be reasonable. But doing so would not invalidate the experiment; it would confirm its result. A leaderboard based solely on declared parameter count cannot distinguish a frontier model from 9.5 terabytes of zeros without adding some further standard of functionality or substance.

That is the lesson I wanted to make visible.

A metric is useful only within the limits of what it actually measures. Once those limits are forgotten, the number begins to carry claims it never earned.

leviathan-19t is not intelligent, useful, or impressive in the way a trained model is impressive. It is simply very large, technically valid, and completely hollow.

And for that reason, it says something worth hearing.