Yes — open weights make it dramatically easier to build a cheaper derivative of a model. But "clone" is doing a lot of work in that sentence. There isn't one kind of clone. There are at least four, and they sit on a cost ladder that runs from an afternoon's optimization job to something that looks uncomfortably close to training a new foundation model.
The moment a lab publishes weights, it hands the field two different things at once: a runnable artifact, and a teacher. What people do with the second one is where things get interesting.
01 Same Model, Cheaper Inference
the easiest route
This tier doesn't produce a new model at all — it produces a leaner build of the same one. Nothing about the model's knowledge or behavior changes; only its footprint does. This is the path of least resistance, and it's why a 600B-parameter release is running on modest hardware within days of launch.
- Quantize weights: BF16 → FP8, INT8, INT4, sometimes lower
- Quantize the KV cache
- Optimized attention & MoE kernels
- Speculative decoding with a smaller draft model
- Prune unused weights or experts
- Cache common prefixes
- Optimize batching and parallelism
Net effect: approximately the same model at a fraction of the memory and compute cost. Call it an optimized build, not a clone — the weights are still, in essence, the original author's.
02 Fine-Tuned Derivatives
new variants, same backbone
One layer up, anyone with the weights can start training on top of them. This is where the original model stops being "the model" and starts being raw material.
instruction tuning → shapes response style & task-following domain specialization → legal, medical, code, finance corpora preference optimization → RLHF / DPO on a new reward signal safety-policy modification → loosened or tightened guardrails language adaptation → new or underrepresented languages tool-use training → function calling, agentic workflows continued pretraining → extends the knowledge base itself
These are genuinely new model variants — not just a relabeled copy — but they retain most of the original's capability and, crucially, most of its training investment. That's the whole economic trick: the expensive part, the general world knowledge baked into billions of parameters, is already paid for. Fine-tuning is comparatively cheap because it's editing, not building.
03 Smaller Distilled Clones
the open model becomes a teacher
This is the tier where open weights become genuinely more powerful than a closed API for competitors. A big open model can be turned into a teacher that trains a smaller, cheaper "student" to approximate its behavior.
Distillation isn't magic compression. You usually can't fold a 600B-class model losslessly into a 20B one — the student gives something up, particularly on rare knowledge and hard multi-step reasoning. But "enough performance for a particular product or domain" is a much lower bar than "matches the teacher everywhere," and it's often all a competitor needs.
What makes open weights different from a closed API here is the quality of supervision available:
- Output logits, not just sampled text
- Intermediate hidden states
- Attention or routing information
- Unlimited local teacher inference
- Controlled synthetic training data
- Gradients, if the setup allows training
Logit and hidden-state access can provide much richer supervision than anything obtainable by querying a closed API — you're not reconstructing the teacher's judgment from text alone, you're reading it directly off the probability distribution.
04 Architectural Derivatives
reading the blueprint, not just the output
Open weights leak more than behavior — they leak design decisions. Anyone who can load the checkpoint can inspect the architecture that produced it:
- Tensor shapes
- Layer ratios
- Expert counts and routing
- Attention structure
- State dimensions
- Normalization choices
- Vocabulary and embeddings
Researchers can lift that knowledge — the ratio of layers to width, how experts are routed, which attention variant was chosen — and use it to inform a smaller model built in a similar shape. What they generally can't do is drop the same weights straight into a materially different architecture. Converting a model built on multi-head latent attention into something like kernelized delta attention, for instance, is not a copy-paste job — it typically demands substantial retraining from that point forward.
Is This Inference-Only?
No — and this is the part that surprises people outside ML. Open weights can normally be loaded for inference and used as a training starting point. Technically, nothing stops either use. What actually governs it is the license, and the two questions are separate:
Technical capability
Can I fine-tune, distill, or modify these tensors? — Usually yes, the moment you have the file.
Legal permission
Does the license allow derivatives, commercial use, redistribution, and training a competing model? — Depends entirely on the fine print.
"Open weights" does not automatically mean open source or unrestricted. Some licenses permit nearly everything a downstream developer could want. Others carve out restrictions on commercial use, active-user thresholds, redistribution, regulated applications, or — increasingly common — a clause that specifically forbids using the model's outputs to train a competing model.
The Cost Hierarchy
training still costs money — just not the same amount of money
None of this is free. Every tier above requires real compute and real expertise. But the tiers are wildly uneven in price, and that unevenness is the entire strategic story:
The strategic consequence is the part worth sitting with: releasing weights doesn't just let competitors host your model cheaply. It hands them a pretrained asset from which they can produce many specialized, quantized, censored, uncensored, distilled, and hardware-targeted derivatives — bounded only by the license they agreed to and the capability losses that compression inevitably introduces.