Say you want your own version of a big AI model — one tuned to write in your company's voice, or to format every answer as a particular kind of report, or to draw in one specific art style. The obvious way is to fine-tune it: keep training the model on your examples until it picks up the behaviour. The problem is that a frontier model has hundreds of billions of parameters, and retraining all of them is brutally expensive — you'd need a fortune in compute, and you'd end up storing a whole separate multi-gigabyte copy of the model for every custom version you make. For almost everyone, that's a non-starter.

The technique that made custom models practical for the rest of us sidesteps the whole problem. It's called LoRA — Low-Rank Adaptation — and it has quietly become one of the most important tools in applied AI.

Don't move the model — bolt a small piece on

LoRA's trick is to leave the giant original model completely frozen and never touch its weights at all. Instead, it slips small, trainable add-on matrices alongside the model's existing ones, and trains only those. The enormous base model just sits there, untouched; all the learning happens in the little bolt-on pieces.

The "low-rank" part is the clever bit. The insight, from a 2021 Microsoft paper, is that the change you need to adapt a model to a new task is much simpler than the model itself — it has, in the jargon, a "low intrinsic rank." So instead of learning a full-sized adjustment to a giant weight matrix, you approximate that adjustment as the product of two much smaller matrices. Those two small matrices have a tiny fraction of the parameters — often well under 1% of the model — and they're all you train.

Why that changes everything

Three consequences fall out of this, and together they're why LoRA is everywhere.

It's cheap. Training under 1% of the parameters needs far less memory and compute than full fine-tuning. A follow-on technique called QLoRA pushed this far enough to fine-tune a 65-billion-parameter model on a single 48-gigabyte GPU — and to bring more modest models within reach of a single consumer graphics card, something that used to require a server room.

The result is tiny. A finished LoRA adapter is measured in megabytes, not gigabytes, because it's just those small matrices. So instead of storing a separate full model per task, you keep one base model and a library of little adapters, snapping the right one on for each job. Those community "character" models, the custom image-generation styles people trade by the thousand, a SaaS product serving a different fine-tune to each customer — overwhelmingly, those are LoRAs, hot-swapped on top of a shared base.

It usually doesn't cost you quality. On a wide range of tasks, a LoRA fine-tune lands remarkably close to the quality of full fine-tuning, despite touching a sliver of the parameters. You get most of the benefit for a fraction of the price.

LoRA is the best-known member of a broader family called parameter-efficient fine-tuning — PEFT — which is the general art of adapting a big model by training only a small added part of it. It's just the one that won.

What it can't do

The honest limit follows directly from how it works: LoRA steers a model, it doesn't rebuild it. Because the base stays frozen and you're only nudging it with a small adjustment, fine-tuning of this kind is excellent at teaching style, tone, format and behaviour — and poor at stuffing in large amounts of genuinely new factual knowledge the base model never had. If what you actually need is for the model to know your company's latest documents, the better tool is usually retrieval — feeding the facts in at question time — not a LoRA. (We walked through when to fine-tune versus when to use retrieval separately; LoRA is the cheap how of the fine-tuning half.)

There are knobs to get wrong, too. The "rank" you choose is a dial: too low and the adapter can't capture what you need; too high and you start giving back the efficiency that made it worth doing. But those are tuning details on top of an idea that is, at its core, elegantly simple — and a good example of a recurring pattern in modern AI. Faced with a model too big to move, the winning move was not a bigger computer. It was the realisation that you didn't need to move the whole thing at all.