weights.zip Resident

About 1.5× more models on every GPU.

Keep models compressed in GPU memory and fit about 1.5× as many bf16 models on each card (1.26× for FP8). Switching to a resident model takes well under a second instead of a reload from disk.

For multi-model hosting, batch inference and mixture-of-experts serving Pilots open · selected workloads

One GPU holding six compressed green models where four raw ones would fit; one lifts and lights up as it switches into service.

33%less GPU memory for bf16 weights

20%less GPU memory for a whole FP8 model (1.26x as many per card)

45 msto unpack a resident 31 GB model on an H100 (Qwen3.8-27B-FP8, measured; new decoder, next release)

On a $1 billion inference budget, holding bf16 models in a third less memory saves an estimated $100M, $66.7M or $33.3M a year if 30%, 20% or 10% of GPUs host many models or run batch jobs.

What fits on one card

GPU	Memory	Holds bf16 models totalling
H100	80 GB	~120 GB
H200	141 GB	~210 GB
B200	180 GB	~270 GB

What you get

More models per GPU for multi-tenant and long-tail hosting.
Fast switching between models already on the card.
For batch jobs (evals, data generation, batch APIs), the saving applies at full batch throughput.
Outputs identical to the uncompressed model.

Good fit when

You host many models with uneven traffic.
You run large offline or batch workloads.
Not yet suited to low-latency chat on a single dense model.

Benchmarks

A third more room on the card, measured on H100.

Resident in GPU memory · NVIDIA H100 SXM

Measure	Result
GPU memory saved, bf16 weights	33.2%
Whole-model unpack, H100 (27B FP8 with bf16 embeddings; new decoder, next release)	682 GB/s
Tensors identical to the original	all

Against zstd on the same weights · size held in memory

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

Switching to a resident model on H100 · calculated from measured whole-model speed (682 GB/s, new decoder, next release)

Model	Expanded on the GPU in
15 GB model	~0.02 s
40 GB model	~0.06 s

Switching between models already on the card avoids a reload from disk or the network entirely. Every resident model was compared bit for bit with the original.

Integration

Same models, more of them on every card.

Models are compressed once with the standard weights.zip tooling and placed in GPU memory in that form. When a request needs a model, it is expanded on the GPU and served exactly as trained.

Supported

bf16, fp16 and FP8 weights.
Multi-model hosting with uneven traffic.
Batch inference: evals, data generation and batch APIs.
Mixture-of-experts models, with experts held compressed.
NVIDIA data center GPUs, measured on H100.

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.