Conventional One job per adapter
Every adapter pays for its own base-model forward pass on every prompt, including prompts every other adapter already ran.
Patent pending · Multi-adapter LoRA training
Hundreds of custom models.
Hundreds of custom models.
One forward pass.
Flora trains many LoRA adapters on the same frozen LLM. When their training data shares a prompt, the base model runs that prompt once, and every adapter trains on the cached output. You stop paying for the same forward pass over and over.
- Works with LoRA & QLoRA
- 4-bit NF4 base models
- Built for multi-tenant fine-tuning
- Patent pending
The wasted work
Per-tenant fine-tuning repeats the same forward pass
LoRA made fine-tuning cheap enough to give every customer, character or user their own adapter. In practice, though, those datasets overlap heavily. A thousand pizza shops all answer "What are your hours?" Each one gets a different answer, but the question going into the base model is the same. Since LoRA keeps the base weights frozen, that question produces the same base-model output every time. Conventional pipelines compute it again for every adapter anyway.
Flora One pass, fanned out
Shared prompts go through the base model once. The output is cached and reused to train every adapter in the pool.
How it works
Two-phase training for adapter fleets
Flora splits training into two phases. The shared phase covers inputs the adapters have in common, and the individualized phase covers everything else.
Collect custom data
Each tenant fills in a predefined template, such as business hours, a character's greeting or house rules, through a web form or API. Flora turns those answers into supervised training pairs.
Pool common inputs
Training sets are grouped by the prompts they share. Templates make the overlap predictable: the questions are the same, and each tenant's answers differ.
Run the base model once
Each shared prompt makes a single forward pass through the frozen base LLM. The output (logits or embeddings) goes into a data store.
Fan out to every adapter
Every adapter in the pool trains against the same cached output, each one toward its own target answer. Base weights are never touched.
Shared phase
Common inputs → one base pass each → cached output reused by N adapters. This is where the compute goes away.
Individualized phase
Prompts unique to one adapter train as usual. Nothing is lost, and only the duplicated work is removed.
Savings calculator
How many base-model passes do you skip?
Move the sliders to match your adapter fleet. The calculator counts base-model forward passes per epoch, the expensive part of running a frozen multi-billion-parameter model.
Customers, characters, or users, each with their own adapter
Template questions every tenant answers
Data specific to a single tenant
—fewer base-model forward passes
Conventional = adapters × (shared + unique). Flora = shared + adapters × unique. This counts base-model forward passes only. Adapter updates are tiny by comparison and happen in both setups.
Use cases
Built for products where many people answer the same questions
Templates produce overlapping prompts. Overlapping prompts are where Flora saves compute.
🍕
Business chatbots
Give every small business a support bot that knows its own hours, menu, location and contact details, all trained from one shared FAQ template.
Q: What are your business hours?
A: Monday to Sunday, 9:00 AM to 9:00 PM
A: Monday to Sunday, 9:00 AM to 9:00 PM
🎮
Game characters (NPCs)
Train a voice for every NPC. RPG characters are templated on health, magic, strength and charisma, and narrative-game characters on empathy, wit and charm.
Q: How would you greet?
A: Good morrow
A: Good morrow
🏡
Rental & hospitality hosts
Guests ask about check-in, house rules, nearby restaurants and nightlife. Every listing gets an assistant trained on that host's answers.
Q: What time is check-out?
A: 11 AM — leave keys in the lockbox
A: 11 AM — leave keys in the lockbox
💬
"Me models"
Users upload their own message history and get an adapter that writes the way they do: personal assistants that sound like their owner.
Upload: SMS history → Adapter: your voice
Under the hood
Fits the PEFT stack you already use
Flora sits on top of standard parameter-efficient fine-tuning tooling. Adapters are ordinary LoRA modules, base models can be quantized, and the trained adapters drop straight into inference next to the base model.
- Adapter typeLoRA / QLoRA
- Adapter size< 1–10% of base params
- Base quantization4-bit NF4 · double quant · GPTQ
- Optimizerpaged AdamW 8-bit
- Cached base outputlogits / embeddings
- Base modelany pretrained or app-tuned LLM
# Quantized base model (QLoRA-style)
bnb = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_use_double_quant=True,
bnb_4bit_compute_dtype=torch.bfloat16,
)
# One low-rank adapter per tenant
lora = LoraConfig(
r=16, lora_alpha=32,
target_modules=["q", "v"],
lora_dropout=0.04, bias="none",
)
# Shared phase: base runs once per common prompt,
# the cached output trains every adapter in the pool
for prompt in pool.shared_prompts:
base_out = cache.get_or_compute(prompt, base_model)
for adapter, target in pool.targets(prompt):
adapter.step(base_out, target)
Guides
Learn LoRA and LLM fine-tuning
Practical references on parameter-efficient fine-tuning from the team behind Flora.
LoRA fine-tuning explained
How low-rank adaptation works, plus rank, alpha, target modules and recommended settings.
Read guide →QLoRA explained
4-bit NF4, double quantization and paged optimizers for fine-tuning on a single GPU.
Read guide →LoRA vs QLoRA vs full fine-tuning
Memory, storage, quality, and when to choose each method.
Read guide →Training many LoRA adapters
Multi-tenant fine-tuning, multi-LoRA serving, and where training compute is wasted.
Read guide →LLM fine-tuning glossary
Plain-English definitions of PEFT, adapters, rank, NF4 and more.
Read guide →
FAQ
Frequently asked questions
What is shared-pass LoRA training?
LoRA keeps base-model weights frozen, so a given prompt always produces the same base-model output. Flora runs each shared prompt through the base model once, caches the output, and reuses it to train every adapter whose dataset contains that prompt.
How much compute does Flora save?
Base-model forward passes for shared prompts drop from adapters × prompts to just prompts. With 500 adapters sharing 40 prompts, that is 40 forward passes instead of 20,000. Your overall saving depends on how much of each dataset is shared. Try the calculator, or read training many LoRA adapters.
Does Flora work with QLoRA and quantized models?
Yes. Adapters can be trained against 4-bit NormalFloat (NF4) quantized base models with double quantization and paged 8-bit optimizers, and base models can be GPTQ-quantized ahead of time for faster inference.
What happens to prompts that are unique to one adapter?
They go through an individualized training phase, where each adapter trains on its own unique prompts in the usual way. The shared phase removes only the duplicated work.
Will adapters trained this way behave differently?
For shared prompts, the base-model output is the same whether it is computed once or a thousand times, because the base weights are frozen. Each adapter still learns its own target answer from that output.
What can the adapters be used for?
Per-business support chatbots, video game characters, rental property assistants, domain experts, and "me models" that write in a specific person's voice. Anything where many tenants answer the same questions differently.
Stop paying for the same forward pass twice
Flora is a patent-pending technique from ForGen AI, in active development. Get in touch if you train adapters for many customers, characters or users.