Weights, compilers and vinyl records

I keep agents running on my own machines — small loops that don't stop, a desktop left on in a corner of the house doing the work I'd rather not send anywhere. Some of it runs on a model that lives right there, in a folder, a few gigabytes, answering with no network, no account, nothing in the cloud. It is, in the most literal sense, mine: I can copy it, move it, keep it running long after the company that made it is gone.

And yet I cannot read it. I can open the file, but there is nothing to read — only an ocean of numbers. I own the object completely and understand its inside not at all. That strange pairing — total possession, zero legibility — is where almost every conversation about AI gets tangled. A model like Kimi K3 ships, everyone calls it "open source", and hardly anyone can say what, precisely, has been handed over. We argue about whether a model is "open", whether it "wrote" the code, whether it lives in the cloud or on your laptop, without a shared picture of what the thing even is.

I've written before about software as a black box: the space between input and output we cannot see into. Large models are that black box taken to the extreme — an opacity that is no longer practical but constitutive. This is an attempt to open it, as far as it opens, and to name honestly what we find. Three old metaphors do most of the work.

The record

The picture that has helped me most is the oldest recording technology we still romanticise: the vinyl record. Let me take the mechanism apart, piece by piece.

Training is the recording session. It happens once, it is ruinously expensive, and it is the irreplaceable moment: a vast, one-time process that runs over an enormous amount of data and leaves behind a frozen imprint. You do not repeat it casually, the way you do not re-record a symphony because you want another copy. The labs are the studios; almost no one else can afford to book the room.

The weights are the pressed disc. What training leaves behind is a set of numbers — billions of them — encoding the patterns it found. They are fixed, inert, finished. The disc holds the music but explains nothing about how the orchestra played.

Inference is putting the needle down. Running the model — every answer it gives you — is playing the record. The turntable is the software that reads the groove; the model file is the groove itself. The disc doesn't think and the turntable knows no music; only together do they make a sound. A model "does nothing" until an engine loads its weights and spins them.

The output is the sound. What comes out is stored nowhere in particular. It is produced, freshly, each time the needle runs.

Most of the confusions dissolve once you hold this picture. Quantization — the thing people find mysterious — is just making an MP3 of the record: you store each number in fewer bits (eight instead of sixteen, or four) so the file shrinks and plays on humbler hardware, at some cost to fidelity. Model size is a single versus a boxed set: the disc is arithmetic, roughly two bytes per parameter, so a seven-billion model is about fourteen gigabytes and a seventy-billion one about a hundred and forty — and quantization is what squeezes the boxed set onto a shelf that shouldn't fit it.

It helps to see how literal the object is. The disc is a file — usually safetensors, or GGUF if you mean to play it at home — beside a small config.json describing the press. And the turntable comes in sizes: Ollama or llama.cpp is the deck in your living room, for an audience of one; vLLM is the club rig built to spin the same disc for thousands at once. Which is the real content of local versus API, the choice people frame as if it were about power: it isn't. The same weights give the same answers wherever they play. What changes is where the turntable sits — whose data stay home, and whether you rent the playback or own it.

None of this is metaphor for metaphor's sake. It buys us the one distinction the industry muddles most.

What they give you when they "open" a model

When a lab announces an "open" model, what it almost always releases is the disc — the weights — and nothing else. Not the recording session, not the master tapes, not the studio.

This is why open weights and open source are not the same thing, however freely the words are swapped. Here the record metaphor runs out and a sharper, more technical one takes over: the weights are a compiled binary. Releasing them is like shipping the .exe and calling your program open. You can run it. You can even patch it here and there. But you cannot read the logic that produced it, and you cannot cleanly rebuild it from scratch. The source — the training code, the data, the thousand decisions of the recipe — stays in the building. The Open Source Initiative has had to say this out loud: open weights reveal only a fraction of what you'd need to reconstruct the system. The word open carries a long, hard-won meaning — I've traced it before, from Unix to the free-software movement, in cathedrals and bazaars. Open weights borrow the warmth of that word while keeping the studio locked.

Kimi K3 makes the gap concrete, and it hides two caveats inside the single word "open". Moonshot's model — 2.8 trillion parameters, the largest open-weight release yet, its discs due out under a permissive licence within days — is open in exactly one sense and not in several others. The first caveat is brute physics: at 2.8 trillion parameters you cannot play this record at home. It needs an industrial rig, a cluster; open in weights, but nothing that will ever spin on the desktop in the corner. Open weights and runs on your machine are simply different claims, and the announcement blurs them.

The second caveat is provenance. Earlier in the year Anthropic accused Moonshot — among others — of distillation: training on millions of a competitor's model outputs, learning from the sound of someone else's record rather than from the world. Moonshot disputed it. And here is what matters for us: with only the disc in hand, no one can settle the question by reading the source, because there is no source to read. Independent researchers can probe the weights from the outside — once they're out — for tell-tale traces, the way you might analyse a pressing to guess which master it came from. But provenance is not legible; it is only inferable. Open weights do not remove the suspicion. They are precisely what makes it permanent.

And the argument is live as I write. This same week a coalition led by NVIDIA — Meta, Microsoft, Hugging Face, Mistral, Mozilla and the Linux Foundation among the signatories — published a letter defending open weights that goes out of its way to defend distillation too: "a widely used technique" that "reflects a long tradition of learning from, building upon, and improving existing technologies… since the rise of the open-source software movement", to be separated from the "unlawful" extraction of value from closed models. Suspicion and defence arrive the same week, from opposite corners of the industry — which tells you the norms for this new object are still being written.

That is the honest shape of "openness" here. You get the disc. You can play it — if you can afford the rig — study its grooves, even suspect where it came from. You do not get the session that made it, and you cannot run it back.

The compiler, twice

Which brings me to the person who, as usual, says the deflating thing out loud.

At the Open Source Summit this year, Linus Torvalds pushed back on the fashion of announcing that AI writes most of one's code:

"AI is a great new tool, but it's a tool, and when I see people saying, 'Hey, 99% of our code is written by AI,' I literally get angry, because those same people — I can pretty much guarantee — that 100% of their code is written by compilers."

Nobody holds a press conference to announce that GCC wrote their C++. Torvalds' point isn't that AI is fake; he's convinced it's real and useful. His point is about category. AI is another layer of abstraction in a long line of them — machine code, assemblers, high-level languages, compilers — and every one was called transformative in its day. Each raised the floor of what you could build without lowering the ceiling of understanding you still need to build something that lasts. His quiet corollary, against the anxious version of the story, is that this may increase the demand for engineers rather than shrink it: new floors open new rooms.

Now notice something strange, because it is the knot this whole essay has been circling. The compiler shows up twice in the story of AI models, in opposite roles, and almost no one points it out.

In the open-weights debate, the compiler is the process that makes the model: training is the compilation, and the weights are the binary it emits. The model is the output of a compiler.

In Torvalds' remark, the AI is the compiler: a tool that emits code which other compilers then compile.

It looks like a contradiction. It isn't. In both uses the compiler does the same quiet work — it is an anti-hype device. It says: this is a layer of abstraction, not magic, not an author, not the source. Name the layer, and don't confuse it with whoever understands the system. The record gives us the warm intuition of what a model is; the compiler is the cold skeleton that keeps us honest about it. Two registers, one argument: don't confuse the tool with the authorship, or the result with the recipe.

The thing we can't yet name

I want to end where even the good metaphors fray, because that edge is more interesting than any of them.

The binary metaphor smuggles in an assumption: that somewhere there is a source, and that the source is the training data — edit the data, recompile, get a new model. But that is not how any of this works. The labs do not rebuild their models by tweaking a dataset and pressing compile; a training run is closer to weather than to a build script, only partly reproducible even by the people who ran it. Call the weights a binary and you imply a source that can be edited back. There isn't one, not in the sense the metaphor promises.

So the record explains the mechanism, and the compiler keeps the hype honest, and both are worth having. But at the far edge they agree on something humbler: this may be the first artefact we've built that is neither quite a recording nor quite a program — something we can own without reading, run without rebuilding, and suspect without ever confirming. We reached for the oldest words we had. It is worth staying alert to the possibility that none of them, yet, is the right one.