Case Study - Reaching frontier-model quality with a local model

The problem

The proposal platform generates client-facing “Gene-to-GMP” CMC proposals across monoclonal antibodies (mAb), bispecific antibodies (bsAb), and biosimilars. Generation ran on Claude Opus 4.8 in the cloud. Two pressures pushed us toward a local model.

• Privacy — Proposals carry sensitive CDMO pricing and scope. Multi-tenant customers (Aragen, Syngene, and others) want on-prem isolation, not “send our pricing to a cloud LLM.”
• Cost at scale — Per-token cloud cost scales with volume; a self-hosted model is a fixed GPU cost.

The risk was the widely held assumption that open models are materially worse than frontier models. The job was to find out how much worse — and whether the gap is closable.

The hypothesis

The task is constrained, not open-ended: follow a fixed proposal structure, cite specific regulations, pull activities from a catalogue, and let a deterministic engine handle pricing. We hypothesised the frontier-model edge would be small for this shape of work, and that RAG plus validators could close most of it — because the hard part (knowledge and citations) is retrievable, not innate.

What we built

We built a decomposed, grounded generation pipeline — deliberately not a single giant LLM call.

• Regulatory RAG corpus — 49 official guideline documents (ICH Q-series, 21 CFR, FDA/EMA/WHO biosimilar guidance, EU GMP annexes, CTD M4Q), each with provenance and trust tier. Embedded with OpenAI text-embedding-3-large; retrieval is filterable by jurisdiction and status, so drafts can never set “Required.”
• Section-level generation — Each of the 13 workflow work-packages is generated independently and concurrently, not as one 9,000-token blob.
• Deterministic validators — Code (not the model) enforces structure (at least 2 client inputs and at least 2 deliverables), citation traceability (every cited regulation id must appear in retrieved context), trap-phrase avoidance, and a repair loop that re-prompts on failure.

The design principle that proved decisive: move rules from prompt into code, and decompose the task into bounded pieces. A weaker model is made reliable by not asking it to hold everything at once.

The experiments

Experiment A — Closed-book recall (the wrong test). OLMo scored 0.40 on a 365-probe closed-book CMC knowledge eval (judged by GPT-5.5). It looked bad. The lesson: closed-book recall is the wrong metric for a RAG system — the model doesn’t need to memorise ICH Q5B, it needs to reason over the retrieved text.

Experiment B — Open-book, with RAG (the right test). The same model, given retrieved context, produced grounded, correctly-cited proposal sections. Across 11 molecule families × 13 workflows = 143 sections, the pipeline passed 143/143 with the repair loop. The lesson: RAG closed the knowledge gap completely.

Experiment C — Head-to-head vs Claude, identical pipeline. The real A/B: same RAG, same prompts, same validators, same repair loop — only the model was swapped. We generated all 13 sections with each model, judged by an independent panel.

Robust verification: the final tally was confirmed by a 3-judge panel per section, position-swapped, majority vote (78 GPT-5 judgments). Both v2 and v4 held at 7:6, with v4 showing cleaner consensus (more unanimous votes). The single-pass v3 swing proved that one judge is noise — panels are essential.

Closing the gap

A deep gap-analysis of every Claude win revealed the pattern: OLMo knew the rules but stayed generic where Claude got specific. Claude named exact attributes (deamidation, C-terminal lysine, afucosylation), named techniques (icIEF, CE-SDS, peptide mapping), mapped deliverables to CTD subsections, and reasoned about reference-product comparison. OLMo said “PTMs” and “orthogonal methods.”

The fix was four cheap, training-free levers.

Net effect: 3:10 → 7:6. The cheap levers didn’t just close the gap — they reversed it.

Two precision fixes added rigor. First, validator over-strictness: the citation checker wrongly flagged CTD coordinates (3.2.S.x / 3.2.P.x) as “unsupported.” A deep per-citation analysis of 6 “failing” sections showed 5 of 6 were validator false-positives — legitimate dossier structure, not fabricated citations. Whitelisting CTD coordinates lifted validation from 7/13 → 12/13.

Second, one genuine model error: OLMo cited “EU GMP Annex 2” for Qualified-Person batch certification, which is actually governed by Annex 16. The root cause was a retrieval gap (Annex 16 was missing from the corpus, and the generic query didn’t surface it), not a hallucination. Adding Annex 16 plus a QP-aware retrieval query fixed it: the section now cites Annex 16 correctly. Final validation: 13/13.

Performance on real hardware

We served OLMo-3.1-32B (BF16, 60 GB) on a single NVIDIA RTX PRO 6000 Blackwell (96 GB) via vLLM.

The key insight: single-request speed is the wrong metric for a multi-tenant SaaS. The Blackwell GPU batches concurrent requests — 8 proposals finish in the time of 1. Decomposing each proposal into 13 concurrent sections means a full proposal lands in ~60s, and many tenants’ proposals run in parallel. Published benchmarks show this card sustaining ~930 tok/s at 50 concurrent users.

Hardware lessons learned:

• BF16 32B (~64 GB) does not fit a 48 GB L40S — it needs quantization or a 96 GB card. The Blackwell fits it natively.
• Blackwell (sm_120) needed CUDA 12.9+ and FlashInfer disabled (an arch-detection bug); FlashAttention-2 worked. Bleeding-edge hardware has driver/library rough edges.
• Use a Deep Learning AMI (drivers pre-installed), not base Ubuntu.

Cost

For a high-volume, multi-tenant proposal product, the fixed-cost local model wins economically at scale — and is the only option that satisfies on-prem data privacy.

Closing the last gap with fine-tuning

Reaching 7:6 on RAG alone was the right first milestone — but the panel pinpointed exactly where to invest next. The two most regulation-dense workflows, regulatory CMC and comparability / biosimilarity, still lost to Claude, because those sections need learned regulatory judgment — what to include, correct CTD mapping, scope discipline — not retrievable facts. That was the textbook case for fine-tuning, so we ran the experiment deliberately: a targeted QLoRA adapter to teach the judgment RAG can’t. It paid off — the local model went from losing every hard section to matching the frontier model on exactly those workflows.

The data — best-of-N distillation. With no real CDMO proposals to train on, we synthesised the training set: for each (family × workflow × variant) task we generated a section with both Claude Opus 4.8 and GPT-5.5 through the same RAG pipeline, then kept the deterministic winner (validator pass plus completeness coverage). The result was 312 validator-clean examples across all 8 families × 13 workflows, with teacher wins splitting Claude 187 / GPT-5.5 125 — best-of-N genuinely raised the data ceiling above either single teacher. Facts stay in RAG; the fine-tune teaches behaviour, voice, and scope — not facts.

The training — two findings that drove the gains. We fine-tuned with QLoRA (4-bit nf4 frozen base plus a LoRA adapter) on the single GPU box, served by vLLM with the adapter loaded natively (no merge). Each version was measured against the panel, and disciplined code review of the training pipeline turned up two high-leverage fixes that each produced a step-change in quality.

Bug 1 — we were holding out the exact workflows we were graded on. v0 put every regulatory-CMC and comparability example into the eval split, so the model never saw them in training — yet they were the entire test. The fix: train on them, and hold out a family (biosimilar) instead for an honest eval.

Bug 2 — no completion-only loss masking. Loss was computed over the whole sequence, including the ~10 RAG chunks stuffed into the prompt — so 80–90% of the gradient was spent reproducing retrieved boilerplate, not the regulatory voice. The fix: patch the chat template with generation markers so loss lands only on the gold section. Combined with stronger learning dynamics (rank 16→32 with rsLoRA, lr 1e-4→2e-4, 3→10 epochs — the old run did only ~18 optimizer steps, far too few to learn a voice), output validity jumped from 2/6 to 5/6 valid sections.

The result. Judged like a competition — GPT-5.5, 3 judges, position-swapped, majority vote — v3 reached parity on the hardest panel: the 2 most regulation-dense workflows across representative families, with the biosimilar family strictly held out of training.

2 wins / 2 ties / 2 losses = parity on the hardest panel. The local model went from losing every hard section (v0) to matching the frontier model on exactly the regulatory-judgment workflows RAG couldn’t reach. In fresh blind head-to-head generation against other strong models through the same RAG pipeline, v3 won the blind GPT-5.5 judge decisively (net +5 to +7) on these in-domain sections — the preferred author, not just a competitive one. We froze v3 as the production-candidate: versioned, backed up to S3, and wired into the serving stack for a one-config cutover from the cloud model to local.