Harvard MadSys Lab · Storage systems

Storage for AI models and the content they generate.

Model hubs now hold tens of petabytes of weights, and generative platforms add billions of images a year. We study how this data is stored and used, and build systems that keep it in a fraction of the space.

We also look ahead to the media this data will live on: dense QLC flash and ceramic archives. The goal is storage that stays affordable and sustainable as AI keeps producing more.

  1. 01 Large model storage Tensor deduplication and delta compression for model hubs.
  2. 02 AI-generated content Store the latent, not the pixels, and decode on read.
  3. 03 New storage hardware Systems for QLC flash and ceramic archives.
  4. 04 Caching Eviction algorithms, simulators and traces at cachemon.org.
01

Large model storage

Model hubs are now among the largest storage systems in the world. Public models on Hugging Face took 0.28 PB in 2023 and more than 76 PB by the end of 2025.

More than 99% of those bytes are fine-tuned variants of a much smaller set of base models. Generic deduplication and compression treat model files as opaque bytes and miss most of this redundancy. We studied every public LLM repository on Hugging Face and found structure that a storage system can use:

  • Fine-tuned models differ from their base in sparse, structured ways, so the XOR between the two compresses very well.
  • Bit-level similarity is enough to group models into families. The model card is not needed, which matters because most repositories don’t say what they were fine-tuned from.
  • Whole tensors are the right unit for deduplication. They match how models are saved and loaded, and they keep metadata small.
Illustration · tensors in a model family
Each fine-tune shares most of its tensors with a base model. A tensor-aware store keeps one copy of each identical tensor and encodes changed tensors as a compressed XOR against the closest base tensor.
NSDI ’26

ZipLLM

Efficient LLM storage via tensor deduplication and delta compression

ZipLLM groups models into families by bit-level similarity, deduplicates identical tensors, and compresses the rest with BitX, a fast lossless codec for the XOR between a fine-tuned tensor and its base.

Model storage saved
54%
Gain over prior dedup + compression
> 20%
Delta codec
BitX, lossless
SOSP ’26Distinguished Artifact Award

TensorDex

A compact, tensor-centric storage system for modern AI models

Model cards are unreliable: only about a quarter of Hugging Face repositories name their model family. TensorDex pairs every tensor with its best base by content, using small sketches to estimate similarity without reading whole tensors, and keeps clusters up to date as new models arrive.

Storage saved, 2,890 HF models (40 TB)
≈ 70%
Ingest / retrieval throughput
22.9 / 28.4 GB/s
Metadata overhead
≈ 0.015%
02

AI-generated content storage

AI image generation reached 15 billion images in about a year and a half; photography took 149 years to get there. Adobe Firefly alone passed 24 billion images by mid-2025, and Midjourney makes more than 34 million a day.

Stored as 1024×1024 PNGs, 100 billion images take about 150 PB, and the pile grows every day. Today’s photo stores keep each one as an opaque blob.

An AI image is different from a photo because it can be recreated exactly. Diffusion spends seconds producing a small latent tensor, and that work happens once. Turning the latent back into pixels is a deterministic decode that takes tens of milliseconds on a GPU. A storage system can therefore keep the latent and rebuild the image when someone asks for it.

The same trade-off applies to music, video and text: when is it cheaper to keep what a model made, and when is it cheaper to make it again?

Where to cut the pipeline
Input Text prompt
20–50 denoising steps
Diffusion Generate latent seconds · ≈ 2,100 TFLOP
output
Store this Latent tensor ≈ 5× smaller than the PNG
on read
VAE decode Rebuild pixels tens of ms · ≈ 10 TFLOP · bit-identical
Compute figures are for a FLUX-class image model. Decoding costs about 1/200 of generating, so a miss that decodes a stored latent is cheap. A miss that regenerates from the prompt is not.
NSDI ’27

LatentStore

A latent-first storage system for AI-generated images

We designed LatentStore from the first large-scale study of how people access AI images: a 35-month, 2-billion-request trace from a production generative-content platform. Popular images stay cached as pixels for fast hits. Colder images are kept as compact latents, and the split between the two caches adapts as popularity shifts.

Persistent storage saved
78.7%
Mean / P99 read latency vs. PNG store
−17% / −18%
Projected 20-year cost saving
> 60%
arXiv 2026

To Store or To Regenerate?

A cost model for AI-generated content at scale

Our model covers corpus growth, HDD and tape prices, drive replacement, electricity, request skew, caching, and falling GPU cost. Regenerating images from the prompt stays more expensive than storing them until around 2040. Keeping a compact intermediate representation and decoding it on a miss is cheaper than both today.

Prompt regeneration vs. storage, 2.07 B requests
> 100× cost
Latent + decode vs. full-image storage
≈ ½ cost
03

New storage hardware

Active work

The media under storage systems are changing. Dense QLC flash is starting to take over read-heavy capacity from hard disks, and ceramic archives can keep data without power for far longer than tape or disk. Both break assumptions that today’s storage software was built on.

QLC flash

Voltage levels per cell Voltage levels per flash cell: SLC 2, MLC 4, TLC 8, QLC 16 SLC 1 bit · 2 levels MLC 2 bits · 4 levels TLC 3 bits · 8 levels QLC 4 bits · 16 levels cell threshold voltage →
Each extra bit per cell doubles the number of charge levels the drive must tell apart. QLC gets its density from 16 levels, which leaves narrow margins between them. That is why it wears out after fewer writes and programs more slowly.

QLC stores four bits in every cell. That density puts more than 100 TB in one SSD at a lower cost per terabyte than TLC flash, but write endurance and write speed pay for it. Most AI data is written once and read many times: model weights, checkpoints, generated media. That makes it a good match for QLC, if the storage system above it shapes writes carefully.

Questions we’re working on

  1. Which AI workloads can move from hard disks to QLC, and what does that save in cost, power and rack space?
  2. How should deduplication, delta compression and caching lay out writes to stay within QLC’s endurance budget?

Builds on our flash caching work: Kangaroo (SOSP ’21, best paper) caches billions of tiny objects on flash within a strict write budget.

Ceramic archives

Ceramic storage writes bits with a laser into a ceramic coating a few nanometers thick on a glass carrier. The medium is write-once, needs no power or climate control to keep data, and is designed to last far longer than tape or hard disks. That makes it a candidate for the data we never want to lose: base models, training corpora, and scientific records.

Writes
Once, by laser. Data can’t be overwritten in place.
Power at rest
None
Lifetime
Centuries or more, compared with years for disks and decades for tape
Role
The bottom tier: archives that are read rarely and must never be lost

An archive that never needs migrating changes how storage systems should be built. Today’s archives copy data to new media every few years. Ceramic archives would skip those copies, but they rule out updates and deletion in place.

Questions we’re working on

  1. What should a storage system look like when its bottom tier is write-once and effectively permanent?
  2. Which AI data is worth keeping forever, and in what form: full objects, deduplicated tensors, or latents?
  3. Over decades, how do cost and carbon compare with migrating data across generations of disk and tape?
04

Caching

Caching is our longest-running line of work, and it has its own home. Eviction algorithms such as SIEVE and S3-FIFO, the libCacheSim simulator, and our open collection of production cache traces all live on cachemon.org.

Visit cachemon.org ↗
§

Storage publications

Large model storage

AI-generated content

Storage media and earlier work

§

People

Harvard MadSys Lab

  • Juncheng YangAssistant Professor, Harvard SEAS
  • Yunjia ZhengPh.D. student
  • Haoran NiUndergraduate researcher

Collaborators

  • Yue ChengUniversity of Virginia
  • Zirui Wang, Tingfeng Lan, Zhaoyuan SuUniversity of Virginia

Teaching and joining

Our storage course is COMPSCI 2640: Modern Storage Systems, first taught in Spring 2026.

We are looking for students who want to work on storage systems. Read the notes for prospective students on the lab homepage before you get in touch.