Why Some Downloadable AI Models Are Broken on Arrival, and How a Small Text Model Learned to See Like a Vision Model
AI in Detail -- Daily News & Research. An independent researcher tested every eligible coding-capable model file in fifteen families on Ollama's official library. Seven small, two- and three-bit files streamed fluent text but solved almost none of a Python test. Rebuilding them from the original weights showed they were exact copies of an uncalibrated compression recipe; adding an importance matrix rescued most of them, while the same recipe left a smaller sibling working. We cover the thirty-second screen that catches these failures, what perplexity can and cannot flag, and the limits of the study. Then Randall Balestriero and Yann LeCun's proof that JEPA encoders trained on different modalities learn the same representation up to a rotation when their training pairs are different observations of one scene, why next-word prediction behaves like the weaker kind of pair, a 109-million-parameter text encoder that aligns with DINOv2 better than language models up to 72 billion parameters, and the image-captioner caveat behind that result.
Listen on Spotify · Watch on YouTube · Pocket Casts
Broken on Arrival: Non-Functional Quantized LLM Artifacts in Public Model Registries and How to Catch Them
Eris: An independent researcher, Aditi Patodiya, tested every eligible coding-capable model file in fifteen model families on Ollama's official library, the place many people download AI models to run on their own computers. Seven of those roughly three hundred files don't work. Six solved none of a standard set of Python programming problems, and the seventh solved only a handful. The surprise is the cause. None of the broken files was corrupted. Each was an exact, faithful copy of a compression recipe that simply doesn't work for that particular model.
Vestra: The files in question are quantized models. A model's weights are normally stored as sixteen-bit numbers. To make it small enough for a laptop or a gaming graphics card, someone rounds those numbers down to fewer bits, often four, sometimes three or two. Ollama stores these in a format called GGUF, which comes from the open-source llama.cpp engine it's built on. Registry volunteers or operators produce these smaller versions, and the study found no registry page or file recording whether anyone had checked that the result still works.
Eris: What does a broken one look like when you run it?
Vestra: It doesn't crash or refuse. It streams text at normal speed. Asked to write a one-line function that returns the length of a string, the two-bit version of Qwen2.5-Coder with three billion parameters produced gibberish, words like "program," "demon," "Audi," repeated until it hit the length limit. One of the three-bit versions of the same model wrote a polite preamble, a function name and a description of what the function would do, and then no code at all. It looks like an answer until you try to use it.
Eris: How did she find the seven without running hundreds of files through the whole test?
Vestra: With a cheap screen. She picked fifteen easy problems that every healthy version of Qwen's coding model had solved in an earlier evaluation, so a working file should pass nearly all of them. That takes about thirty seconds of generation per file on one consumer graphics card. Any file that scored far below the high-precision version of the same model was rerun on the full problem set of a hundred and sixty-four tasks. All seven failures were small models, four billion parameters or fewer, compressed to two or three bits. They came from three models: four compression levels of the three-billion-parameter Qwen coder, one of Microsoft's Phi-3.5-mini and two of Meta's one-billion-parameter Llama 3.2.
Eris: And the claim that the files weren't corrupted comes from rebuilding them?
Vestra: Yes, and that's the strongest part of the study. For the five Qwen and Phi failures, she downloaded the original weights from the model makers and compressed them herself using the recipe the files' own metadata pointed to. Then she compared her rebuild with the registry's file, piece by piece across every stored tensor, the blocks of numbers that make up the model. They matched exactly. The registry served precisely what that recipe produces. She also ruled out the obvious alternatives. The failure appeared on Nvidia graphics cards, on an Apple chip and on an ordinary processor, and an outside user reproduced it on their own machine with a newer version of Ollama. So it isn't the software running the model. Her calibrated rebuilds, which do work, use the same tokenizer settings and prompt format, which rules those out as well.
Eris: Then what is missing from the recipe?
Vestra: A calibration step. When you round millions of numbers down to two or three bits, every block of weights picks a scale, and some rounding error is unavoidable. Calibration runs some sample text through the model first and records which weights actually carry strong signals. llama.cpp calls that record an importance matrix. With it, the compressor spends its limited precision protecting the weights that matter most. The registry files were built without one. When she rebuilt the three-billion-parameter Qwen files with an importance matrix, keeping the same weights, software and mix of formats, the two-bit version went from solving nothing to solving about two thirds of the full set. Two of the three-bit versions went to about half. One three-bit level stayed weak under every calibration she tried, and Phi was only partly rescued.
Eris: Wait, the two-bit version did better than the three-bit ones?
Vestra: After calibration, yes, and the paper doesn't explain it. The calibrated three-bit builds still had much worse scores on a standard measure of how well the model predicts ordinary text, and she says she hasn't found the cause. She also notes that supplying an importance matrix switches on a different scale search in llama.cpp, so the test credits the whole calibrated procedure, not just the sample text.
Eris: It sounds like the fix is to always calibrate, but you said the recipe isn't enough to predict failure.
Vestra: Right, and the comparison with the smaller sibling shows why. The one-and-a-half-billion-parameter Qwen coder was compressed with exactly the same uncalibrated recipe at the same levels, and those files still work. The same recipe breaks the three-billion model and spares the smaller one. File size isn't the explanation either. The registry's uncalibrated four-bit version of the three-billion model is about the same size as one of the broken three-bit files, and it passes. And llama.cpp itself refuses to produce its very lowest-bit formats without an importance matrix, but exempts these two-bit and three-bit formats by design. So nothing in the toolchain stops a broken file from being published.
Eris: There's a correction inside this paper, too. The first version reached a different conclusion.
Vestra: It did. The first version compared the failing registry files with calibrated files from a different uploader on Hugging Face, saw that those worked, and concluded the registry's conversions were defective. Rebuilding with the matching recipe showed they weren't defective at all. She also found that the Phi file on Ollama has the same contents as three uploads on Hugging Face under unrelated names. So a file can look like an independent second opinion when it's really the same file under another name. Only comparing the contents tensor by tensor exposes that.
Eris: Could you spot a broken file without running a coding test at all?
Vestra: Partly. Simple signs, like an answer that runs into the length limit or keeps repeating phrases, caught the gibberish cases but missed the fluent, empty answers, and a threshold low enough to catch those also flags a noticeable share of healthy files. A better signal was perplexity, which measures how surprised a model is by ordinary text. Every broken file she measured was dozens to thousands of times more surprised than the full-size model, while the four-bit versions stayed close. But she picked that threshold after seeing the results, it needs a full-size version to compare against, and it can't tell a corrupted file from an uncalibrated one.
Eris: So how confident can someone be that the files which passed the screen really work?
Vestra: She sampled sixty-six files that passed and ran them on a separate set of problems. None was broken. That supports the screen for catching near-total failure, not for catching files that are merely worse. The one-and-a-half-billion Qwen two-bit file passes the screen while solving far fewer of the extra problems than its four-bit sibling. The count of seven is also a floor. One small DeepSeek coding model scored poorly at every precision, including the full-size file, so a test that compares a file with its own full-precision version can't flag it. Those files are missing tokenizer information, but a larger DeepSeek model with the same gap works, so the paper leaves that group unexplained. And two community files on Hugging Face failed only because they lacked the model's instruction format. Given the right format, they worked.
Eris: That last case matters for anyone running these files at home. The same file can pass or fail depending on how you call it.
Vestra: Which is why her advice to users is to test a downloaded file with the same software and prompt format you'll actually use, especially a two-bit or three-bit file of a small model. The scope is limited. Only Python code generation was tested, on one registry's coding-capable files of eight gigabytes or less, and the easy screening problems were chosen using the same Qwen family where four of the seven failures occurred. The rule for calling a file rescued by calibration was added after the first results, and the plan was recorded locally, not registered publicly in advance.
Eris: It also changes how to read other research. A paper that ran the two-bit Qwen file through Ollama on a code-completion test got zero and blamed the low precision. Calibrated files at that same level solve about two thirds of these problems.
Vestra: Although she notes she can't confirm which file that earlier study used. Her recommendation for registries is concrete. Screen every low-bit file before publishing it. If one fails, rebuild it to find the cause, then publish a calibrated version or withhold that level. Record the recipe, any calibration text and the effective number of bits per weight. The broken files were still being served unchanged two months after her census, with no warning on the pages. Qwen's own compressed releases of that model are labeled as calibrated and offer only two of the four low levels the registry carries. The screening tool, called quantcheck, and all the test transcripts are public.
Proving and Improving the Platonic Representation Hypothesis with JEPAs
Eris: Randall Balestriero of Brown University and Yann LeCun of New York University, both also at AMI Labs, trained a small text model, about a hundred and nine million parameters, that organizes the meaning of sentences more like a vision model organizes photographs than any large language model they tested, including models over six hundred times larger. Their explanation is that what matters is which pairs of examples a model is taught to treat as the same thing, not just how big it is or how much it reads.
Vestra: This builds on an idea from twenty twenty-four called the Platonic Representation Hypothesis. Researchers noticed that as vision models and language models get bigger, their internal representations become more similar, even though one only ever sees pixels and the other only ever sees text. The hypothesis was that both are converging on a shared model of the same world. It was an observation, with no proof and no recipe for making it happen sooner.
Eris: How do you even measure whether an image model and a text model see things the same way?
Vestra: One common test takes pairs of images and their captions. For each image, you find its ten nearest neighbors among the other images, according to the vision model. For that image's caption, you find its ten nearest captions, according to the text model. Then you check how much the two lists overlap. If the two models organize the world the same way, the photo of a dog on a beach and its caption should have matching neighborhoods. Nothing is trained on the pairs for that test. A second test lets you fit one rotation, which turns one model's space to line it up with the other's without stretching it, and then asks whether an image lands closest to its own caption.
Eris: So what's the theorem?
Vestra: It covers a family of training methods called joint-embedding predictive architectures, or JEPAs, which LeCun has championed for years. A JEPA takes two versions of an input, called views, and trains an encoder so their internal representations agree, with a second term that stops it from cheating by mapping everything to the same point. The theorem says that if you train separate JEPAs on images and on text, and both treat the same pairs of world situations as matching, they learn the same representation, differing only by a rotation. Think of two maps of one city drawn independently, one with north at the top and one turned sideways. The streets are identical. You only need to find the angle.
Eris: And that holds in an idealized world, I assume.
Vestra: A very idealized one. The world has a finite number of states, every observation fully identifies its state, and training finds the perfect solution. Real captions only describe part of a photo, and none of the experiments meets those conditions exactly. What makes the theory useful is the distinction it draws between two kinds of training pairs. In a good view, the two examples are different observations of the same scene, like two different people's captions of one photo. In a bad view, they're two damaged copies of the same observation, like one caption with different words blanked out, or two crops of the same photo.
Eris: Why would the second kind hurt? Blanking words out is a standard way to train text models.
Vestra: Because both damaged copies keep everything particular to that one caption, its exact wording and style. To make them agree, the encoder spends some of its capacity tracking that wording. No rotation can line that up with an image model, since the photo doesn't determine which words some captioner chose. Two different people's captions of the same photo only share the scene itself, so an encoder trained to match them spends nothing on wording. The paper proves that version, and then argues that ordinary next-word prediction, the way large language models are trained, behaves like a bad view. Its pairs are a stretch of text and what follows it in the same document, which share the author's wording. That's their explanation for why language models only line up with vision as they get very large.
Eris: Did the experiments bear that out?
Vestra: In the controlled ones, clearly. They used about thirty thousand photos with five human captions each and trained the same small text encoder three ways, changing only the pairs: different captions of one photo, damaged copies of one caption, or next-word prediction. Neither model ever saw the other's data. Against a strong existing vision model called DINOv2, the good-view encoder retrieved the correct caption first about twice as often as the other two, which landed close together. Giving next-word prediction two captions of the same photo barely helped it, so the gain comes from how the pairs are used, not just from knowing which captions go together. They could also measure the wording effect directly, since each photo has five captions. The good-view encoder devoted more of its representation to the scene and less to a particular caption's phrasing, in the order the theory predicts.
Eris: The large-scale result is the headline. They trained on the text that accompanies about nine hundred and forty million web images, each with its original alt text plus two descriptions written by an automatic image-captioning model. The hundred-and-nine-million-parameter good-view encoder agreed with DINOv2 more than every language model they evaluated, up to Qwen with seventy-two billion parameters and Llama with seventy billion, and more than the text side of CLIP, which was trained directly on four hundred million image and caption pairs. On the same web text, the good-view method matched the alignment of next-word prediction with forty-two times fewer training samples. What bothers me is those descriptions written by an image captioner. That model looked at the photos.
Vestra: The authors raise that themselves, and it's the main limit of the large-scale result. The captioner saw images through CLIP, so information from image and text training is baked into the very text the small model reads. When they removed the captioner and paired the alt text with a paraphrase written by a text-only model, alignment dropped to roughly half. So the comparison with the giant language models depends on those generated descriptions. The comparisons between kinds of pairs don't, because every method there read exactly the same text, and good views still beat damaged copies without any image captioner.
Eris: Any other caveats on the headline?
Vestra: A few. A fourth training run with a stronger setting for the anti-cheating term scored well below the others, though the average of all four still beat every language model. A small share of the benchmark's captions also appear in the training text, though removing them barely moved any result. Settings were tuned only for the good-view method. And this is agreement in how meaning is organized, not general ability. Nobody is claiming this small encoder can answer questions or write code like a large language model.
Eris: What can you actually build with two models that line up?
Vestra: An image captioner without training any network on images paired with captions. They trained a decoder that turns the text encoder's representations back into sentences, using text alone. To caption a photo, they run it through a frozen vision model, apply the rotation and decode. The rotation, fitted on thirty thousand photo and caption pairs, is the only part that ever sees a pair. The decoder is trained with added noise so it tolerates imperfect alignment, and that noise level wasn't tuned. They calculated it from how imperfectly the rotation lines images up with captions, and captioning quality peaked at exactly that value. On a separate, widely used photo collection, that captioner beat several earlier text-only captioners built on CLIP, though not the best of them, which rely on CLIP's own image and caption training. A rotation also carried over to new photos better than a more flexible map fitted on the same pairs, which is what you'd expect if the two spaces really are the same up to a turn.
Eris: And it even works on video?
Vestra: Roughly. Averaging the rotated representations of a clip's frames let the same system caption videos it never trained on, above captioners built on CLIP that use no video captions, but below dedicated video systems. The most striking result needs no pairs at all. Another group's method finds the rotation from the shapes of the two clouds of points alone. With that method and its settings unchanged, the small good-view encoder beat every zero-shot classification score that group had reported, and rerun side by side, it beat their strongest language model, Qwen3 with eight billion parameters, by a wide margin on a hundred-category image test. Next-word prediction on the same text failed in about half its runs.
Eris: That's the part I'd watch. If good views give you better-aligned models for less data, the hard question becomes where good views come from outside of curated caption datasets.
Vestra: That's the open problem the authors name. Good views require knowing which texts describe the same scene. Human-captioned datasets give you that, and at web scale they relied on a captioner. For images, good views mean several observations of one scene, such as video frames, and their image model trained that way is still much weaker than DINOv2. They also fitted an empirical scaling law that predicted runs before they were trained about as well as rerunning with a different random seed, but it overestimated results once training went four times past its fitted range. The code is public. There is no independent replication yet.
Wrap-Up
Eris: That's today's research. A census of Ollama's official library found seven small, heavily compressed coding models that produce fluent text but no working code, and rebuilding them showed the files were faithful copies of a compression recipe that skipped a calibration step. A thirty-second screen catches that kind of failure before anyone downloads it. And Balestriero and LeCun showed that a small text model trained to match different descriptions of the same scene lines up with a vision model better than language models hundreds of times its size, with the caveat that much of its web training text was written by an image captioner.
Vestra: Both papers are linked in the episode description. Every story we cover is also on our news site, Ground Truth, at groundtruth dot day, updated daily.
Eris: If you run models on your own machine and this changed how you'll pick a file, follow AI in Detail so tomorrow's episode shows up in your feed.