You ran ollama pull qwen3:32b and got a model file of about 20.2 GB, or 18.8 GiB. A nominal 32-billion-parameter model needs 64 GB for bf16 weights alone. The downloaded model file is about 31.6% of that nominal baseline, not one-fifth. The tag says 32b, but it does not spell out the quantization recipe.

You can check the registry’s declared quantization and file sizes before downloading model-weight blobs. An Ollama manifest lists layers and byte sizes; its small config blob supplies file_type. Turning those bytes into bits per weight takes another step: the parameter count must describe the tensors in the same file.

Correction, November 9, 2026: The original version confused ideal four-bit storage with a mixed-quantization file, used mismatched denominators for DeepSeek, Gemma and one Mistral tag, and treated an unsupported ±3% rule as an integrity check. This revision corrects the arithmetic, checks the tensor counts, and separates advertised file sizes from actual network and disk use.

The download that looks broken

For qwen3:32b, the manifest’s model layer is 20,201,240,160 bytes:

  • 20.201 decimal GB, using 1 GB = 1,000,000,000 bytes.
  • 18.814 GiB, using 1 GiB = 1,073,741,824 bytes.

Those are two representations of the same file. Unit conversion accounts for that difference; it cannot by itself explain a much larger gap such as 18 GB versus 48 GB.

The idealized four-bit calculation is 32,000,000,000 × 4 / 8 = 16,000,000,000 bytes, or 16 GB. Real Q4_K_M files use a mixture of tensor types plus block scales, other quantization data, GGUF metadata and alignment. They need not average exactly four bits per parameter.

Using this artifact’s exact 32,762,123,264 tensor elements, the ideal four-bit payload would be 16.381 GB and a bf16 payload would be 65.524 GB. Its 20.201 GB model file is therefore about 30.8% of that exact bf16 baseline, with a file-level average of 4.933 bits per stored tensor element. These are weight-storage comparisons, not estimates of total inference RAM or VRAM.

The November 3 snapshot recorded manifest SHA256 030ee887880fc378860c2dd35101da424377520441ae4bfe7be6deff8ade7840. The November 9 recheck returned the same hash. Tags can move; a digest identifies the bytes referenced by that particular snapshot.

What the manifest tells you

A tag name is a label. Some names include a quantization suffix, such as qwen3:32b-q8_0; others leave it out. Resolve the tag and inspect these fields:

  1. config.digest points to a small JSON blob. For qwen3:32b, the 488-byte config declares file_type: Q4_K_M and model_family: qwen3. This is a file-level label, not a promise that every tensor has one storage type.
  2. layers[] lists each layer’s mediaType, size and digest. This audit uses the complete application/vnd.ollama.image.model file for its numerator. That includes the GGUF container’s metadata and alignment as well as tensor data.
  3. Other layers have separate roles. Templates, parameters and licenses are small in this sample. Multimodal Gemma also has an application/vnd.ollama.image.projector layer. On gemma3:4b, that layer is 851,251,104 bytes, about 34.1% of the 2,499,012,288-byte language-model file. Their sizes must be kept separate when calculating language-model bpw.
  4. The model-layer digest identifies the advertised artifact. Checking a downloaded blob against that digest verifies its bytes against the manifest. Reading a matching size or quant label alone does not do that.

The sum of layers[].size is useful capacity information. It is not an exact network-transfer or incremental-disk figure: it excludes the config and manifest, downloads can reuse or resume cached blobs, and several tags can share one stored blob. HTTP overhead and filesystem allocation are separate concerns. Ollama’s pull implementation handles config downloads, cache reuse and digest verification separately.

Method: match the file and the denominator

The table calculates:

file_bpw = model_layer_bytes × 8 / stored_tensor_elements

For the denominator, count the elements represented by the model file’s tensor metadata: for each unique tensor name, multiply its dimensions, then sum across tensors. The tensor-count links in the table point to Ollama’s tensor listings for the exact model blob. The correction recheck parsed those listings, rejected duplicate tensor names, and counted the tensors without downloading their weight data.

A Hugging Face repository’s safetensors.total can be a useful cross-check, but it is not automatically the right divisor. The source repository must match the actual model version, and its scope must match the file. A multimodal total can include a vision component stored in another blob. Tied or duplicated weights also require attention when comparing source parameters with serialized tensor elements. Both Llama 3.1 blobs here store an additional 64-element rope_freqs.weight tensor. The table includes it, so its denominator describes serialized tensor elements rather than strictly learned parameters; the difference does not affect the displayed three-decimal bpw.

Exact quant-block sizes come from llama.cpp’s GGUF constants: Q4_K stores 256 values in 144 bytes, or 4.5 bpw; Q6_K uses 210 bytes, or 6.5625 bpw; Q8_0 stores 32 values in 34 bytes, or 8.5 bpw. Those block rates include scales and other block data, but not the whole GGUF container.

Q4_K_M is a mixed quantization recipe, not a universal 4.85 bpw constant. Architecture, tensor shapes, quantizer choices and higher-precision tensors affect the file average. The quantizer source shows both tensor-specific choices and fallbacks for incompatible shapes. There is no supported universal ±3% pass/fail test here. A plausible file size cannot prove the quantization layout, model quality or download integrity.

The audit: 14 tags, 7 families

The original manifest reads ran on November 3, 2026. During the November 9 correction recheck, all 14 manifest hashes were unchanged. The byte sizes below are therefore the same artifacts; the denominator corrections change their interpretation. Each row links to its registry manifest and to its model-blob tensor listing. All 14 captured configs declare Q4_K_M or Q8_0 as shown.

“Model bytes” means the complete model GGUF file. “Layer sum” means only the manifest’s layer sizes, excluding config and manifest bytes. GB is decimal; GiB is binary. The tensor count excludes any separate projector blob.

TagDeclared typeModel bytesGB / GiBStored tensor elementsFile bpwLayer sum (bytes)
qwen3:4bQ4_K_M2,497,280,4802.497 / 2.3264,022,468,0964.9672,497,293,444
qwen3:8bQ4_K_M5,225,374,4965.225 / 4.8678,190,735,3605.1045,225,387,677
qwen3:32bQ4_K_M20,201,240,16020.201 / 18.81432,762,123,2644.93320,201,253,341
qwen3:32b-q8_0Q8_035,132,291,68035.132 / 32.71932,762,123,2648.57935,132,304,861
llama3.1:8bQ4_K_M4,920,738,9444.921 / 4.5838,030,261,3124.9024,920,752,841
llama3.1:70bQ4_K_M42,520,398,17642.520 / 39.60070,553,706,5604.82142,520,412,073
gemma3:4bQ4_K_M2,499,012,2882.499 / 2.3273,880,101,8885.1523,350,272,259
gemma3:12bQ4_K_M7,309,830,4967.310 / 6.80811,765,792,2564.9708,164,039,587
gemma3:27bQ4_K_M16,555,661,47216.556 / 15.41927,009,007,6164.90417,413,409,507
mistral:7bQ4_K_M4,372,811,7124.373 / 4.0727,248,023,5524.8264,372,823,897
mistral:7b-instruct-q8_0Q8_07,696,794,2087.697 / 7.1687,241,732,0968.5037,696,805,637
deepseek-r1:8bQ4_K_M5,225,373,7605.225 / 4.8678,190,735,3605.1045,225,375,560
qwen2.5:0.5bQ4_K_M397,807,9360.398 / 0.370494,032,7686.442397,820,829
phi4:14bQ4_K_M9,053,114,4649.053 / 8.43114,659,507,2004.9409,053,115,905

The corrected rows reveal why the denominator matters:

  • DeepSeek-R1 8B: The official tag page identifies DeepSeek-R1-0528-Qwen3-8B, not the earlier Llama-based distilled model. The matching repository has 8,190,735,360 parameters, agreeing with the blob’s tensor count. That changes the result from 5.206 to 5.104 bpw. The manifest hash is unchanged, so this was an incorrect source-model match, not a later tag update.
  • Gemma 3: The language-model blobs contain 3,880,101,888, 11,765,792,256 and 27,009,007,616 tensor elements for the 4B, 12B and 27B tags. The original calculation divided those files by larger multimodal repository totals. With matching denominators, their file averages are 5.152, 4.970 and 4.904 bpw. The old 4.649 figure for Gemma 4B did not demonstrate unusually low tensor precision. The separate projector layers are 851,251,104, 854,200,224 and 857,739,168 bytes.
  • Mistral Q8_0: The 7b-instruct-q8_0 blob has 7,241,732,096 tensor elements and a 32,000-token vocabulary. The original denominator, 7,248,023,552, came from a different Mistral version. The matching blob count changes 8.495 to 8.503 bpw. Similar family names do not establish identical source models.
  • Qwen2.5 0.5B: Its 6.442 bpw calculation is unchanged, but its explanation needs more than a general claim about embeddings. The blob’s tensor listing shows Q8_0 token embeddings, many Q5_0 matrices, and a mixture of Q4_K, Q6_K and other tensor types. Its hidden width is 896, which is not divisible by the 256-value K-block size. llama.cpp’s quantizer supports fallbacks from Q4_K to Q5_0 and from Q6_K to Q8_0 for incompatible shapes. The listed layout is consistent with that mechanism; it is not evidence of a corrupt file. The 494,032,768-element total includes no separately stored output.weight tensor.

One model, two quantizations

The two Qwen3 32B blobs have the same 32,762,123,264 tensor elements. Their model files grow from 20,201,240,160 bytes at Q4_K_M to 35,132,291,680 bytes at Q8_0: 1.739 times the storage, or about 73.9% more. The file averages are 4.933 and 8.579 bpw.

That is a file-size comparison. It does not measure quality, tokens per second, runtime memory or memory traffic. Those depend on the implementation, offloading, batching, cache behavior and workload, and need their own measurements.

For a particular resolved model-blob digest, the artifact bytes do not change with your VRAM. Hardware still affects whether and how the model runs. This observation concerns the captured plain GGUF manifests; it does not assert that every tag, platform or future manifest-list selection always resolves to the same artifact.

Run it yourself

Save this as manifest_audit.py. It reads a public library manifest and config, checks the config’s declared digest and size, and reports model sizes and the layer sum. It does not download or verify the model-weight blobs. An optional parameter count produces file bpw; leave it out until you have matched the count to the blob’s tensor metadata.

#!/usr/bin/env python3
"""Read public library manifests; optional family:tag=parameter_count."""
import hashlib
import json
import re
import sys
import urllib.request
from datetime import datetime, timezone


def get(url):
    req = urllib.request.Request(url, headers={"User-Agent": "manifest-audit/2.0"})
    with urllib.request.urlopen(req, timeout=30) as response:
        body = response.read()
        return body, response.headers.get("Date"), datetime.now(timezone.utc).isoformat()


def audit(spec):
    match = re.fullmatch(r"([A-Za-z0-9_.-]+):([A-Za-z0-9_.-]+)(?:=([1-9][0-9]*))?", spec)
    if not match:
        raise ValueError("Expected family:tag or family:tag=positive_parameter_count")
    family, tag, count = match.groups()
    base = f"https://registry.ollama.ai/v2/library/{family}"
    body, server_date, read_at = get(f"{base}/manifests/{tag}")
    manifest = json.loads(body)
    if "layers" not in manifest:
        raise ValueError("Not a plain model manifest; resolve its manifest list first")
    layers = manifest["layers"]
    model_layers = [x for x in layers if x["mediaType"] == "application/vnd.ollama.image.model"]
    if not model_layers:
        raise ValueError("No model layer; do not infer a parameter ratio")
    config_ref = manifest["config"]
    if not re.fullmatch(r"sha256:[0-9a-f]{64}", config_ref["digest"]):
        raise ValueError("Unsupported config digest")
    config_body, _, _ = get(f"{base}/blobs/{config_ref['digest']}")
    if (len(config_body) != config_ref["size"] or
            "sha256:" + hashlib.sha256(config_body).hexdigest() != config_ref["digest"]):
        raise ValueError("Config size or digest mismatch")
    config = json.loads(config_body)
    model_bytes = sum(x["size"] for x in model_layers)
    parameters = int(count) if count else None
    return {
        "tag": f"{family}:{tag}", "read_at_utc": read_at, "response_date": server_date,
        "manifest_sha256": hashlib.sha256(body).hexdigest(),
        "model_family": config.get("model_family"), "file_type": config.get("file_type"),
        "model_layers": model_layers, "model_bytes": model_bytes,
        "decimal_gb": round(model_bytes / 10**9, 3), "gib": round(model_bytes / 2**30, 3),
        "all_layer_bytes": sum(x["size"] for x in layers),
        "config_bytes": config_ref["size"], "manifest_bytes": len(body),
        "parameters_supplied": parameters,
        "file_bpw": round(model_bytes * 8 / parameters, 3) if parameters else None,
    }


if __name__ == "__main__":
    if not sys.argv[1:]:
        raise SystemExit("Usage: python3 manifest_audit.py family:tag[=parameter_count] ...")
    for spec in sys.argv[1:]:
        print(json.dumps(audit(spec)))

Run python3 manifest_audit.py qwen3:32b=32762123264 phi4:14b. The Qwen row includes file_bpw: 4.933; the Phi row leaves it null because no denominator was supplied. Compare the returned hashes with your saved snapshot. A later run is not guaranteed to return the same hash because tags can move.

read_at_utc is taken after the manifest body is read. response_date is the HTTP Date header and may reflect an intermediary’s cached response; it is not a substitute for recording your own observation time. The script deliberately rejects manifest lists rather than silently choosing an artifact. It supports the plain public library/family:tag examples in this article, not every registry or authenticated model.

What this does not tell you

  • File bpw is storage accounting, not quality. Similar averages can hide different tensor layouts and quantization choices. An accuracy or perplexity claim needs an evaluation.
  • The registry declares the bytes. This correction fetched manifests, configs and tensor metadata, not full model-weight blobs. It did not independently check every advertised tensor against downloaded weights.
  • Tags move and model identities matter. Keep the manifest hash, layer digest, observation time and denominator provenance together. A family name and rounded “B” count are insufficient.
  • Fourteen tags are a sample. These observations do not establish a universal range or pass/fail threshold for a quantization recipe.
  • Storage is not runtime memory. KV cache, activations, work buffers, offloaded layers and backend choices are outside this audit.

Read file_type to learn the declared quantization recipe. Read layer sizes to plan storage. Match tensor scope before calculating file bpw, and verify blob digests when checking a download. Each step answers a different question.

Sources and correction evidence

The row links identify the primary registry manifests and digest-specific tensor listings. The November 9 recheck preserved response times, response hashes, manifests, configs and the parsed tensor names, types and dimensions in the repository’s correction evidence. The original November 3 CSV is retained as the historical record; it has not been silently rewritten to erase the corrected denominators.

For implementation details, see the linked llama.cpp constants and quantizer, and Ollama’s pull implementation. The Qwen2.5-0.5B-Instruct config documents its tied embeddings and dimensions. The Mistral-7B-Instruct-v0.1 config matches the Q8 artifact’s vocabulary and RoPE settings, but matching architecture alone does not prove the exact weight lineage; the table uses the blob’s counted elements instead.

Related reading on this site: the idealized params × bits ÷ 8 sizing formula and why real artifacts differ, the Qwen3 32B setup guide, and the deployment checklist that asks you to record quantization.