---
license: cc-by-nd-4.0
license_name: cc-by-nd-4.0
license_link: https://creativecommons.org/licenses/by-nd/4.0/
base_model: Qwen/Qwen3.5-9B
base_model_relation: finetune
library_name: transformers
pipeline_tag: text-generation
tags:
- aging
- longevity
- biomedical
- biology
- qwen3.5
- lora-merged
- insilicomedicine
language:
- en
---
# Longevity-LLM (L-LLM)
A domain-adapted **Qwen3.5-9B** for aging and longevity biology. L-LLM is the result of continued pretraining + supervised fine-tuning + a reasoning-augmented continuation pass on a multi-domain corpus spanning clinical aging, epigenomics, transcriptomics, proteomics, and genetics. The two trained LoRA adapters were concatenated into a single rank-64 LoRA and merged into the base weights to produce this standalone bf16 checkpoint.
## Methods
L-LLM was built by LoRA fine-tuning Qwen3.5-9B, a 9B-parameter hybrid transformer that interleaves Gated DeltaNet linear-attention layers with standard self-attention in a 3:1 ratio. Training data was assembled across three main domains:
| Domain | Sources |
|---|---|
| Knowledge priors | UniProt protein/gene annotations, Gene Ontology, protein–protein interactions, pathway membership; published aging-clock formulas and CpG-site coefficients (Biolearn) |
| Clinical & epidemiology | NHANES (age, mortality) |
| Epigenomics | GEO DNA-methylation cohorts, CpG methylation profiles, aging-clock proxy tasks |
| Transcriptomics | GTEx (tissue age), TCGA (cancer survival), expression-profile generation |
| Proteomics | Olink plasma-proteomics panels, proteomic clock proxy tasks |
| Genetics & longevity | OpenGenes (expression directionality), SynergyAge (lifespan), CellAge (senescence), anti-aging target classification |
| Reasoning corpus | Prediction tasks augmented with frontier-model chain-of-thought traces |
Approximate scale across all domains: ≈10⁶ training prompts at the order of
several billion tokens total. Exact composition, prompt counts, and token
counts will be reported in the forthcoming preprint.
Training proceeded in three stages on Qwen3.5-9B:
1. **Continued pretraining** — knowledge priors only, raw text packed into
4,096-token blocks. Rank-32 LoRA with rsLoRA scaling, LR 2 × 10⁻⁵,
3 epochs.
2. **Supervised fine-tuning** — aging prediction tasks in conversation
format. Rank-32 LoRA initialized from the phase-1 adapter, standard α/r
scaling, LR 1 × 10⁻⁴, 3 epochs.
3. **Reasoning continuation** — continued the SFT adapter on the reasoning
corpus, LR 3 × 10⁻⁵, ≈1 epoch, context length 32,768 with example
packing.
All adapters targeted the 12 linear projections including the GatedDeltaNet
modules. After training, the CPT and continued-SFT adapters were
concatenated into a single rank-64 LoRA and merged into the base weights to
produce this checkpoint. DeepSpeed ZeRO-2 on 2× NVIDIA H100 NVL 94 GB,
bf16, flash-attention 2 on self-attention layers. Full details in the
forthcoming preprint.
## Example usage
```python
from transformers.models.qwen3_5 import Qwen3_5ForConditionalGeneration
from transformers import AutoProcessor
model = Qwen3_5ForConditionalGeneration.from_pretrained(
"insilicomedicine/longevity-llm",
torch_dtype="bfloat16",
trust_remote_code=True,
device_map="auto",
)
processor = AutoProcessor.from_pretrained(
"insilicomedicine/longevity-llm", trust_remote_code=True
)
messages = [
{"role": "system", "content":
"You are a helpful assistant with expertise in aging biology."},
{"role": "user", "content": "What are the hallmarks of aging?"},
]
# enable_thinking=False is REQUIRED to suppress reasoning — the template
# reasons by default when the argument is omitted. See "Thinking mode".
inputs = processor.apply_chat_template(
messages, return_tensors="pt", add_generation_prompt=True,
enable_thinking=False,
).to(model.device)
out = model.generate(inputs, max_new_tokens=400, do_sample=False)
print(processor.decode(out[0][inputs.shape[-1]:], skip_special_tokens=True))
```
## Local deployment (vLLM, OpenAI-compatible)
For serving, the recommended path is our production vLLM container, pointed at a local copy of these weights. This reproduces the behaviour of our hosted inference endpoint.
**What you are deploying:** ≈9 B parameters, bf16, **≈18.8 GB** on disk
(4 safetensors shards). Served model name: `longevity-llm`. The API is
OpenAI-compatible (`/v1/chat/completions`, `/v1/completions`).
### Hardware
L-LLM is a single-GPU model; the weights occupy ~18.8 GB of VRAM in bf16 and
the remainder is used for the KV cache (context length × concurrency).
| GPU VRAM | Suggested settings |
|---|---|
| 80–141 GB (H100 80GB, H200, A100 80GB) | `--max-model-len 28000 --max-num-seqs 64 --gpu-memory-utilization 0.92` |
| 40–48 GB (A100 40GB, L40S) | `--max-model-len 16000 --max-num-seqs 16 --gpu-memory-utilization 0.90` |
| 24 GB (RTX 4090, A10G) | `--max-model-len 8000 --max-num-seqs 4 --gpu-memory-utilization 0.95` |
Also required: recent NVIDIA driver + CUDA 12.x, and (for the container) the NVIDIA Container Toolkit.
Local deployment was tested with H100. The 40–48 GB and 24 GB rows are estimates and have not been run.
### Validated configuration
The deployment path in this section was exercised end-to-end with these parameters/hardware:
| | |
|---|---|
| GPU | 1 × NVIDIA H100 NVL, 94 GB (shared; ~10 GB resident from other workloads) |
| Driver / CUDA | 580.126.09 / CUDA 13.0 |
| Host OS | Ubuntu 24.04 (x86-64) |
| Container runtime | Docker 29.0.2, NVIDIA Container Toolkit |
| Image | `fgalkin/longevity-llm-vllm:0.1` (vLLM 0.20.2, V1 engine, `--enforce-eager`) |
| Model revision | `e846d14efb25dbf0472eec2404ab13c329154a57` |
| Serving flags | `--max-model-len 28000 --max-num-seqs 64 --gpu-memory-utilization 0.85` |
| Observed | ~90 s cold start to HTTP 200; 59.3 GiB KV cache (1.8 M tokens); 31–35 output tok/s per request at concurrency 3 |
Not exercised:
multi-GPU parallelism, non-Linux hosts, GPUs <94 GB.
**Disk:** Budget ~55 GB total for the weights + container.
### Download the weights
```bash
pipx install "huggingface_hub[cli]"
# or: python3 -m venv ~/.venvs/hf && ~/.venvs/hf/bin/pip install -U "huggingface_hub[cli]"
hf download insilicomedicine/longevity-llm --local-dir ./longevity-llm
```
**Gated access**
Depending on when you access this page, the model may still be behind gated access. All requests are autoapproved, so don't worry.
Click **Request access**, then authenticate before downloading — run `hf auth login` (paste an `hf_...` read token from your account settings) or pass `--token hf_...` to the download command. For the container, provide the same token as `-e HUGGING_FACE_HUB_TOKEN=hf_...` when pulling weights from the Hub.
### Serve with the production container (recommended)
The serving image is on Docker Hub as [`fgalkin/longevity-llm-vllm`](https://hub.docker.com/r/fgalkin/longevity-llm-vllm). It bundles a vLLM build with Qwen3.5 support, so you do not have to match `vllm`/`transformers` versions yourself. Mount your download at `/repository`:
```bash
docker run --rm --gpus '"device=0"' -p 8000:8000 \
--entrypoint python3 \
-v "$(pwd)/longevity-llm:/repository:ro" \
-e VLLM_LOGGING_LEVEL=WARNING \
-e VLLM_WORKER_MULTIPROC_METHOD=spawn \
fgalkin/longevity-llm-vllm:0.1 \
-m vllm.entrypoints.openai.api_server \
--model /repository \
--served-model-name longevity-llm \
--trust-remote-code --dtype bfloat16 \
--max-model-len 28000 --max-num-seqs 64 \
--gpu-memory-utilization 0.92 --enforce-eager \
--no-enable-log-requests --host 0.0.0.0 --port 8000
```
> **`--entrypoint python3` is required.** The image's `ENTRYPOINT` is
> `["bash"]`, so appending `python3 -m vllm...` as the command produces
> `bash python3 -m vllm...` — bash tries to interpret the Python binary as a
> shell script and the container exits 126 with
> `/usr/local/bin/python3: cannot execute binary file`. Overriding the
> entrypoint and passing `-m ...` as the argument list avoids this.
> (This does not bite if you deploy on HF Inference Endpoints, which
> supply their own launch command)
To let the container pull from the Hub instead of mounting, replace
`--model /repository` with `--model insilicomedicine/longevity-llm` and mount a
cache volume (`-v "$HOME/.cache/huggingface:/root/.cache/huggingface"`).
> Native `pip install vllm` may not always recognize the `qwen3_5` architecture,
> which is why the container is the reliable route. If you serve natively, use a
> vLLM build with Qwen3.5 support. This checkpoint's `config.json` records
> `transformers_version: 5.6.0`.
### Smoke test
```bash
curl -s http://localhost:8000/health && echo OK
curl -s http://localhost:8000/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "longevity-llm",
"messages": [
{"role": "system", "content": "You are a helpful assistant with expertise in aging biology."},
{"role": "user", "content": "What does the Horvath2013 epigenetic clock measure?"}
],
"temperature": 0.0, "max_tokens": 400,
"chat_template_kwargs": {"enable_thinking": false}
}'
```
By default thinking is on, so without `enable_thinking: false` the model reasons first and all 400 tokens will likely be consumed before any answer is emitted (`finish_reason: "length"`, no answer).
Any OpenAI SDK works by setting `base_url="http://localhost:8000/v1"` and `model="longevity-llm"` (a local server needs no API key).
### Thinking mode
Reasoning ("thinking") is controlled **per request**, not by a server flag. **The chat template reasons by DEFAULT.** To disable it you must explicitly pass `enable_thinking: false`.
```json
"chat_template_kwargs": {"enable_thinking": false}
```
The template implements this as a soft switch: with `enable_thinking=false` it emits a pre-closed `\n\n` block, so the model proceeds straight to the answer; otherwise it opens a bare `` and reasons.
Two things to be aware of:
- The argument **must** be nested inside `chat_template_kwargs`. A top-level `"enable_thinking": false` is accepted without error and silently ignored.
- The container serves with no reasoning parser configured, so when reasoning is on the chain-of-thought arrives inside `message.content` rather than a separate `reasoning_content` field, and it is **not** wrapped in visible `` tags (the opening tag is in the prompt, not the output).
## Optimal inference settings
The settings below were selected empirically on this checkpoint.
**Factual and production use (reasoning off)** — reproducible, lowest latency:
```json
{
"temperature": 0.0,
"top_p": 0.8,
"top_k": 20,
"repetition_penalty": 1.1,
"max_tokens": 700,
"chat_template_kwargs": {"enable_thinking": false}
}
```
**Open-ended or high-stakes use (reasoning on)** — roughly double the tokens, measurably fewer fabricated entities:
```json
{
"temperature": 0.0,
"top_p": 0.8,
"top_k": 20,
"repetition_penalty": 1.1,
"max_tokens": 2200,
"chat_template_kwargs": {"enable_thinking": true}
}
```
Pair either profile with a grounding system prompt (see *Prompting* below).
### Token budget
Reasoning traces on this checkpoint commonly run 200–1,100 tokens before the answer begins. Budget **≥1,500 tokens** with reasoning on. A 400-token budget returns `finish_reason: "length"` and no answer at all. With reasoning off, 400–700 tokens is fine for most prompts.
### Prompting
Adding an explicit grounding instruction eliminates confident fabrication on unrecognised identifiers in testing, with no parameter changes:
```
You are a helpful assistant with expertise in aging biology. Ground every
claim in established literature. If a gene symbol, CpG identifier, or finding
is not one you recognise from the literature, say so explicitly and do not
speculate about its function. Never invent effect sizes.
```
This mitigates unwanted behaviour — see *Limitations*.
### Parsing reasoning output
vLLM is served here without a reasoning parser, so with reasoning enabled the chain-of-thought is prepended to `message.content` and terminated by a literal ``. The opening tag does not appear in the output (it is supplied by the prompt). Just in case, retain this fallback:
```python
content = resp.choices[0].message.content
answer = content.split("")[-1].strip() if "" in content else content
```
### Throughput
Measured on a single H100 NVL at concurrency 3: **31–35 output tokens/s per request**. The engine reported a 1.8 M-token KV cache and headroom for ~64 concurrent 28k-token requests, so this is a per-request latency figure rather than a capacity limit. Reasoning mode approximately doubles time-to-answer.
## FAQ
**What are we allowed to do with the model?** Run and serve it as distributed, including commercially, with attribution. The fine-tuning additions are CC-BY-ND-4.0, so redistributing *modified* weights is not permitted. Please contact us if you want to fine-tune, merge, or make a quantized build of L-LLM.
**Is it text-only?** Yes. The base architecture carries vision/video machinery, but L-LLM is trained and intended for text; send text messages only.
**Can we run it on multiple GPUs?** Yes, add `--tensor-parallel-size N` to the serving command. A single ≥24 GB GPU is otherwise sufficient (see the hardware table). Validate TP on your hardware, as hybrid linear-attention models occasionally have TP constraints.
**Can we get a smaller / quantized version?** Only bf16 is released, and a quantized checkpoint would be an ND-restricted derivative.
**CPU, Apple Silicon, or air-gapped hosts?** No CPU/Metal path (bf16, CUDA amd64). For air-gapped hosts, mount local weights and transfer the image with `docker save` / `docker load`.
**Which CUDA/driver do we need?** CUDA 12.x with a recent NVIDIA driver and the NVIDIA Container Toolkit. (Verified on driver 580.126.09 / CUDA 13.0.)
**Are outputs reproducible?** With `temperature=0` decoding is greedy, but results are not bit-identical across GPU types or vLLM versions.
**How do we pin a fixed version?** Pin both the container tag (`0.1`) and the model revision rather than tracking `main`.
**First request is slow?** Cold start loads ~18.8 GB into VRAM. Measured ~90 s to `/health` returning 200 on an H100 NVL with weights on local SSD. Give it 2–5 minutes.
## Limitations
These behaviours were observed on this checkpoint during deployment testing and should inform how outputs are consumed.
**Fabricated biomedical entities.** The model may state confident false claims about identifiers it does not recognise, including invented effect sizes and invented citation markers. A grounding system prompt (see *Optimal inference settings → Prompting*) reduces such inaccuracies.
**Enabling reasoning reduces this but does not eliminate it.** Reasoning mode produces fewer fabricated entities on the same prompts, but still can assert incorrect claims.
**Incorrect answers.** Some CpG-to-gene mappings L-LLM produces are incorrect.
**Treat every gene symbol, `cg` identifier, effect size and citation from this model as a lead requiring verification, not as a fact.** Do not use it as a primary source for clinical, regulatory, or publication purposes.
**Degenerate repetition.** With `repetition_penalty: 1.0` the model can loop on open-ended list prompts. Always set it above 1.0 (see *Optimal inference settings*).
**Text only.** The base architecture carries vision and video components, but the model is trained and intended for text; send text messages only.
## License
The fine-tuning additions in this repository are released under **CC-BY-ND-4.0**. The underlying Qwen3.5-9B weights remain under their original Apache-2.0 license.
## Citation
## Citation
Please cite our Cell paper if you want to use this model in your research projects.
```bibtex
@article{zhavoronkov_open_2026,
title = {An open benchmark and language models for {AI} in aging biology},
volume = {189},
issn = {0092-8674, 1097-4172},
url = {https://www.cell.com/cell/abstract/S0092-8674(26)00999-2},
doi = {10.1016/j.cell.2026.08.026},
language = {English},
number = {19},
urldate = {2026-09-27},
journal = {Cell},
publisher = {Elsevier},
author = {Zhavoronkov, Alex and Naumov, Vladimir and Sidorenko, Denis and Aliper, Alex and Aladinskiy, Vladimir and Hasani, Ramin and Amini, Alexander and Nasto, Katerina and Reymond, Mathieu and Shayakhmetov, Rim and Miftakhutdinov, Zulfat and Gladyshev, Vadim N. and Galkin, Fedor},
month = sep,
year = {2026},
keywords = {aging, aging clock, benchmark, fine-tuning, foundation model, geroprotector, large language model, longevity, multi-omics, target discovery},
pages = {5980--5994.e8},
}
```
```bibtex
@misc{insilico_medicine_2026,
author = { Insilico Medicine },
title = { longevity-llm (Revision e846d14) },
year = 2026,
url = { https://huggingface.co/insilicomedicine/longevity-llm },
doi = { 10.57967/hf/8927 },
publisher = { Hugging Face }
}
```