Model reference · open weights

TLM

LLMs McGill-NLP Text gen 6 builds Open weights 216 dl/mo

TLM is an open-weight language model from McGill-NLP. TLM-40M (FP32) weighs 83 MB; the smallest configuration that runs it is RTX 3060 12 GB.

  • TLM-230M is a 229M parameter text-generation model developed by McGill-NLP that uses a tiered architecture to expose two behavioral tiers from a single set of weights.
  • The public tier is accessible by default, while a keyed tier is reached by applying a secret permutation key that swaps 5% of attention heads and MLP columns.
  • The model supports a 2048-token context length, is trained on English data, and is released under the Apache 2.0 license.

Summary of the McGill-NLP/TLM-230M model card, 2026-10-01. The estimate below is for another build of the family.

What it is

Released byMcGill-NLP
Released2026-08-28
Parameters229M
VRAM83 MB for the weights

What it runs on

Memory and cards for TLM-40M (FP32)

83 MBweights, file size
18 MBcache per 1K tokens
505 MBruntime overhead, at least
2,048 tokenscontext max
CardRequests at onceContext maxMemory
2K each
RTX 3060 12 GB292all 2K11.6 GB
RTX 4060 Ti 16 GB392all 2K15.4 GB
RTX 3090 24 GB604all 2K23.4 GB
RTX 4090 24 GB603all 2K23.4 GB
RTX 5090 32 GB806all 2K31.0 GB
L40S 48 GB1000+all 2K44.0 GB
A100 80 GB1000+all 2K78.2 GB
H100 80 GB1000+all 2K78.1 GB
RTX PRO 6000 Blackwell 96 GB1000+all 2K93.8 GB
DGX Spark (GB10) 128 GB unified1000+all 2K107 GB
H200 141 GB1000+all 2K138 GB
B200 180 GB1000+all 2K176 GB
Memory needed at each load
Requests at once2K tokens each
1626 MB
5777 MB
8890 MB
161.2 GB
321.8 GB
643.0 GB

One card, with vLLM's small-card settings.

Builds

Sizes, precisions & builds

BuildParamsPrecisionWeightsSmallest setup
TLM-230M ↗ 229MFP32 458 MBRTX 3060 12 GB
TLM-100M ↗ 99MFP32 198 MBRTX 3060 12 GB
TLM-120M ↗ 117MFP32 234 MBRTX 3060 12 GB
TLM-70M ↗ 67MFP32 135 MBRTX 3060 12 GB
TLM-40M (above) ↗ 42MFP32 83 MBRTX 3060 12 GB
TLM-20M ↗ 22MFP32 44 MBRTX 3060 12 GB

From the model card

What McGill-NLP says about TLM

Read the model card

A Tiered Language Model (TLM) pretrained with Tiered Alignment: one set of weights that exposes two behavioral tiers, toggled by a secret permutation key.

  • Public tier (C1) — what you get by loading the weights normally. Open to everyone.
  • Keyed tier (C2) — reached by applying key_5pct.json, which permutes 5% of the attention heads and MLP columns. The permutation is self-inverse, so applying it toggles between the two tiers over the same underlying parameters.

TLM-230M is the 240m rung of a scaling ladder. Its non-keyed counterpart (identical architecture and token budget, trained without a key) is the baseline used for all public-tier comparisons.

Files

FileWhat it is
model.safetensorsWeights in the C1 (public) configuration
key_5pct.jsonThe secret permutation key — swaps over attn_heads and mlp_cols
config.json, tokenizer.jsonGPT-Neo config; GPT-2 BPE tokenizer (vocab 50257)

Optimizer state is not included; these checkpoints are for inference and evaluation.

Usage

The weights require GPTNeoForCausalLMTiered, not stock GPTNeoForCausalLM: this architecture defines lm_head with bias=True, and loading through AutoModelForCausalLM silently drops that trained bias.

from tiered.model import GPTNeoForCausalLMTiered
from tiered.permutation import load_key, apply_permutation, unapply_permutation

model = GPTNeoForCausalLMTiered.from_pretrained("McGill-NLP/TLM-230M")
key = load_key("key_5pct.json")          # downloaded from this repo

# C1 (public) — the state the weights ship in
logits_public = model(input_ids).logits

apply_permutation(model, key)            # -> C2 (keyed)
logits_keyed = model(input_ids).logits

unapply_permutation(model, key)          # back to C1, bit-exactly

Model details

Total parameters229,137,745
Layers / hidden / heads16 / 768 / 12
MLP ratio / context8 / 2048
Training tokens22.91B (100x total params)
Steps / global batch49,948 / 224 seqs
Peak LR / warmup3.9e-4 / 1000 steps
DataFineWeb (retain split)
Key coverage5%

Architecture follows the DataDecide ladder (arXiv:2504.11393): interpolated between the 150M and 300M rungs (log-linear in total params, fraction 0.3033).

A note on the ladder's names

Repository names here are total parameter counts, rounded. The underlying DataDecide rung labels are not parameter counts, so the two orderings differ — the "90M" rung has 117M total parameters, more than the "100M" rung's 99M. Ordered by actual size, the ladder runs:

TLM-20M, TLM-40M, TLM-70M, TLM-100M, TLM-120M, TLM-180M, TLM-230M, TLM-650M

TLM-180M predates this ladder and uses 12 layers rather than 16, so it is not architecturally part of it; treat it separately when fitting scaling curves.

Citation

Code: https://github.com/charbel08/permutation-alignment

Quoted from the model card on Hugging Face. The full card is behind the Hugging Face link above.

© 2026 AxForge · EU-hosted AI infrastructure Pricing Docs Trust Privacy Terms