weights.zip Load

Models serving sooner on every scale-up.

Models start serving sooner when a new GPU node comes up. Fewer bytes cross the network, and they unpack on the GPU faster than the network delivers them.

For inference platforms that autoscale across many models Pilots open

Compressed model blocks race from a model store along a raised link into a new GPU node whose lights come on.

~20%faster cold start for a 31 GB FP8 model over 10 Gbps (calculated from the measured 20.5% size reduction)

21%less egress per FP8 model load

34%fewer bytes per bf16 model load

1.29xfaster load from host memory into an H100 than an uncompressed copy (whole 27B FP8 model, bit-exact, measured; new decoder, next release)

On a $1 billion inference budget, Load saves an estimated $6M a year of idle GPU time during cold starts and $4.2M of egress, $10.2M in total.

Example: a 31 GB FP8 model fetched over a 10 Gbps link arrives as about 24.5 GB and is ready to serve about 20% sooner, on every scale-up event.

What you get

Faster scale-up when traffic spikes, so fewer requests wait.
Lower egress bills for every model pulled from object storage.
Even from host memory, where there is no network to wait on, a compressed model reaches the GPU faster than the raw one: 0.49 s instead of 0.64 s for a 31 GB model on an H100 (measured; new decoder, next release).
The served model is identical to the one you trained.

Good fit when

Models load from S3, GCS or another network store.
You scale nodes up and down many times a day.
Not a fit if every model is already sitting in local RAM on every node.

Benchmarks

Fewer bytes on every load, unpacked faster than they arrive.

Bytes per model load · size vs original, lower is better

Model	Format	Original	zstd	weights.zip
Qwen2.5-1.5B	bf16	3.09 GB	0.785	0.658
Qwen2.5-0.5B	bf16	0.99 GB	0.774	0.659

Unpack and load speed on the GPU · measured

Measurement	Hardware	Result
Whole Qwen3.8-27B-FP8, unpack in GPU memory (new decoder, next release)	NVIDIA H100	45 ms (682 GB/s)
Host memory to GPU, whole model (new decoder, next release)	NVIDIA H100	0.49 s vs 0.64 s uncompressed
Single large FP8 tensor (current release)	NVIDIA H100	43.3 GB/s
2 GB of the 27B model (new decoder, next release)	RTX 4060	58 GB/s

What it means for a cold start · Qwen3.8-27B-FP8, 0.795 of original size

31 GB FP8 model over a 10 Gbps link	Bytes fetched	Ready to serve
Standard load	31 GB	~25 s
weights.zip load	24.5 GB	~20 s

An H100 unpacks the whole 27B model in 45 milliseconds (new decoder, next release), so load time is set by the bytes on the wire, and fewer bytes means a faster start. Every load was compared bit for bit with the original model.

Integration

Compress once at publish. Every node loads faster after that.

Compress each model once when it is published to your model store. Serving nodes fetch the smaller file and expand it on the GPU as part of the normal load, so your serving engine receives exactly the model it always did.

Supported

S3, GCS, Azure Blob and any other network store.
bf16, fp16, fp32 and FP8 models.
Per-tensor access, so loading can begin with the first tensor.
Standard safetensors output for any serving engine.

Tooling

# command line
weightzip compress    model.safetensors  model.wzst
weightzip decompress  model.wzst         model.safetensors
weightzip verify      model.safetensors  model.wzst

# Python
from weightzip import compress_file, decompress_file, verify_file
compress_file("model.safetensors", "model.wzst")
assert verify_file("model.safetensors", "model.wzst")

Verify it yourself

Don't take our word for it. Check every tensor.

Run verifyweightzip verify restores the file and compares every tensor with the original, bit for bit, and reports any difference.
Check with your own codeLoad both files with the standard safetensors library and compare the raw bytes of every tensor. The script below does it in a few lines.
Benchmark your filesSend us a sample or run our benchmark in your own account. You get bytes saved, decode speed on your GPUs and a byte for byte match report.

import torch
from safetensors.torch import load_file

a = load_file("model.safetensors")        # the original
b = load_file("restored.safetensors")     # after weightzip decompress
assert a.keys() == b.keys()
for name in a:
    x, y = a[name], b[name]
    assert x.dtype == y.dtype and x.shape == y.shape
    assert torch.equal(x.reshape(-1).view(torch.uint8), y.reshape(-1).view(torch.uint8))
print("identical:", len(a), "tensors")

Start with your own data

Free benchmark on your files and hardware.

Send a sampleA few models, a checkpoint series or a KV cache dump, or run our benchmark inside your account.
Get your numbersBytes saved, restore speed on your GPUs, and a byte-for-byte match report.
PilotRun on one workload for 30 days. Pricing is per terabyte managed or a share of the measured saving.

Request a pilot

The product line

Ten products for the data inside AI models.

How these numbers were measured

All figures are measured on public models (Qwen2.5 0.5B and 1.5B, Llama-3.1 8B and 70B, Pythia-160M, GPT-2 and a 27B FP8 model) on NVIDIA H100 SXM, H200 and RTX 4060 GPUs. Every restore was checked byte for byte against the original. zstd comparisons use zstd level 19 or NVIDIA nvCOMP Zstd on the same files. Dollar figures assume S3 Standard-class storage at about $24 per TB-month and typical cloud egress pricing. Results depend on the model and data type, so the free benchmark measures yours.