Lernex/Metis-1.6-Praxis

Technical report  ·  Metis-1.6  ·  Lernex  ·  X

Metis-1.6 Praxis

Metis-1.6 Praxis is a 2.94B-parameter reasoning model that thinks twice: every token runs through its hybrid Mamba-2 and attention mixture-of-experts stack two times, with the same weights, touching just 0.46B parameters on each pass. I built it from scratch and trained it on 1.02 trillion tokens, and it is small enough to run on a laptop. It reaches 78.80% on MATH-500, 60.31% on AMC 2023 and 31.25% on AIME 2026, and with under 1B active parameters per token it outscores models that activate seven to twelve times as many in mathematics, which puts it on the Pareto frontier for compute. It is not a frontier model: knowledge, code and long context are where its size shows most. It thinks or answers directly, on request, across a 131,072-token context, and it is yours under Apache 2.0.

Benchmarks

Praxis in thinking and direct mode (Think | Direct) beside the post-trained releases of the 16 open models from the Praxis Base comparison set, with Metis-1.6 Logos for scale. Every model ran on the same harness, with the same prompts and scorers. The picker narrows the table to the models you choose, and bold marks the best score among the models in view. The Weighted score counts each capability once, reasoning first, after taking out what a random guess would score; Average weights every row equally. - means a benchmark does not apply.

Metis-1.6 Praxis (Think | Direct)vsall 17 modelsMetis-1.6 LogosQwen3.5 4BQwen3 4BNanbeige4.2 3BMinistral 3 3BGranite 4.1 3BFalcon-H1 3BOuro 1.4BGemma 4 E4BSmolLM3 3BLFM2.5 2.6BGemma 3 4BQwen3.5 2BLlama 3.2 3BGemma 4 E2BQwen3.5 0.8BOuro 2.6B

Pick any to compare with Metis-1.6 Praxis; pick none to see every model. Metis-1.6 columns report Think | Direct scores.

Metis-1.6 Logos10.23B · 131KQwen3.5 4B4.21B · 256KQwen3 4B4.02B · 32KNanbeige4.2 3B4.17B · 128KMinistral 3 3B3.43B · 256KGranite 4.1 3B3.40B · 128KFalcon-H1 3B3.15B · 128KOuro 1.4B1.43B · 64KGemma 4 E4B7.52B · 128KSmolLM3 3B3.08B · 64KLFM2.5 2.6B2.70B · 125KGemma 3 4B3.88B · 128KQwen3.5 2B1.88B · 256KLlama 3.2 3B3.21B · 128KGemma 4 E2B4.65B · 128KQwen3.5 0.8B0.752B · 256KOuro 2.6B2.67B · 64K

	Metis-1.6 Praxis (Think | Direct)	Metis-1.6 Logos	Qwen3.5 4B	Qwen3 4B	Nanbeige4.2 3B	Ministral 3 3B	Granite 4.1 3B	Falcon-H1 3B	Ouro 1.4B	Gemma 4 E4B	SmolLM3 3B	LFM2.5 2.6B	Gemma 3 4B	Qwen3.5 2B	Llama 3.2 3B	Gemma 4 E2B	Qwen3.5 0.8B	Ouro 2.6B
# Params	2.94B	10.23B	4.21B	4.02B	4.17B	3.43B	3.40B	3.15B	1.43B	7.52B	3.08B	2.70B	3.88B	1.88B	3.21B	4.65B	0.752B	2.67B
# Activated params, per pass	0.464B	1.18B	3.57B	3.63B	3.15B	3.03B	3.15B	2.81B	1.23B	4.03B	2.81B	2.44B	3.21B	1.37B	2.82B	1.90B	0.498B	2.47B
# Activated params, total	0.94B	2.37B	3.57B	3.63B	6.30B	3.03B	3.15B	2.81B	4.93B	4.03B	2.81B	2.44B	3.21B	1.37B	2.82B	1.90B	0.498B	9.87B
Context	131K	131K	256K	32K	128K	256K	128K	128K	64K	128K	64K	125K	128K	256K	128K	128K	256K	64K
Training tokens	1.02T	1.02T	undisclosed	36T	28T	1-3T	14.9T	2.5T	7.7T	undisclosed	11.2T	34T	4T	undisclosed	9T	undisclosed	undisclosed	7.7T
Summary Scores (Think | Direct)
Weighted score	27.10 | 24.24	46.46 | 33.29	53.14	48.08	55.64	32.95	29.99	30.25	36.21	50.20	37.56	43.43	31.94	37.41	24.58	42.05	20.36	39.71
Average	33.82 | 32.14	52.00 | 41.20	60.24	53.86	61.33	38.74	36.81	37.25	44.27	55.58	44.62	49.93	38.11	45.62	35.00	49.29	29.81	47.01
Math & Olympiad Reasoning
AIME 2025	10.00 | 0.00	67.50 | 0.00	64.17	53.75	68.75	15.00	5.83	14.17	37.08	41.25	34.58	42.08	11.25	18.75	0.00	29.58	0.42	54.58
AIME 2026	16.67 | 0.00	67.50 | 6.67	73.33	63.75	73.75	9.58	4.58	7.08	44.17	46.67	40.83	40.83	10.00	14.17	0.42	40.83	0.00	60.83
HMMT Feb 2025	6.67 | 0.00	65.00 | 13.33	36.25	35.83	63.75	5.83	0.42	5.00	27.92	25.00	24.17	24.58	1.25	10.83	0.42	20.83	0.00	30.42
HMMT Nov 2025	16.67 | 0.00	59.58 | 10.00	39.58	44.17	60.42	4.58	1.25	5.00	32.50	38.33	25.83	26.67	4.58	5.00	1.25	16.25	0.00	40.83
HMMT Feb 2026	18.18 | 0.00	63.64 | 0.00	35.61	34.85	53.79	6.06	0.76	6.06	28.41	31.82	26.89	22.35	5.30	12.50	0.76	18.94	0.00	32.20
AMC 2023	55.00 | 22.50	95.00 | 60.00	84.38	93.44	95.00	42.81	34.06	55.00	86.88	86.25	85.94	71.56	44.69	55.00	15.31	76.56	25.00	93.44
Brumo 2025	23.33 | 6.67	75.83 | 33.33	49.58	59.58	75.00	15.42	9.17	20.00	54.58	54.17	54.17	40.00	20.00	24.58	0.42	43.75	4.58	65.83
IMO-AnswerBench	16.00 | 2.50	57.00 | 19.50	33.50	37.00	41.00	9.50	7.00	8.50	29.00	29.50	27.50	23.00	6.50	11.50	0.00	20.50	5.00	38.00
Apex 2025	0.00 | 0.00	0.00 | 16.67	0.00	0.00	0.00	1.04	0.00	0.00	2.08	2.08	0.00	1.04	0.00	0.00	0.00	1.04	3.12	0.00
MATH-500	78.80 | 51.80	89.40 | 70.60	83.60	88.00	91.80	64.60	61.60	76.40	88.60	90.40	85.20	84.60	72.60	72.80	32.40	86.00	43.60	90.20
GSM8K	76.80 | 63.60	90.60 | 81.00	96.60	95.20	95.20	87.20	82.00	88.00	94.60	92.80	92.40	90.80	90.60	87.20	74.00	90.80	64.20	96.00
Frontier Science & Knowledge
GPQA Diamond	27.78 | 22.22	55.05 | 34.34	76.26	52.02	76.77	33.33	32.32	37.37	40.40	61.62	33.33	54.04	31.82	51.01	24.75	42.93	23.23	46.97
GPQA Main	31.03 | 25.22	50.45 | 33.03	70.76	47.32	67.63	33.03	30.80	35.49	42.19	55.14	34.37	54.02	31.03	45.98	27.23	42.41	26.56	43.75
GPQA Extended	23.26 | 17.58	41.58 | 30.22	65.57	48.35	65.57	30.22	32.05	34.80	37.91	50.00	34.80	53.85	28.39	44.32	25.46	45.97	22.89	41.58
Humanity's Last Exam	5.85 | 6.50	4.38 | 6.91	6.90	3.95	10.62	3.02	3.92	4.47	5.52	4.47	4.68	5.42	4.62	5.48	4.22	3.88	4.90	4.71
MMLU-Pro	34.57 | 32.29	59.14 | 44.00	66.86	64.86	70.29	48.29	34.57	47.00	59.14	68.00	55.57	62.14	36.29	53.14	34.14	59.43	27.86	60.57
MMLU	53.43 | 50.43	68.00 | 61.57	73.57	78.14	80.43	67.57	52.86	61.00	70.71	79.57	71.14	78.29	58.00	70.00	57.86	73.43	38.00	69.86
Coding & Agentic Tool Use
LiveCodeBench v6	12.57 | 11.43	24.57 | 13.71	17.14	34.29	29.14	24.00	19.43	17.71	30.29	42.29	23.43	30.86	43.43	9.14	12.00	19.43	4.00	32.00
HumanEval	51.83 | 62.80	76.22 | 72.56	87.80	92.68	95.12	79.27	82.32	71.95	89.02	95.73	89.02	92.07	71.95	53.05	60.37	87.20	20.12	93.29
HumanEval+	42.07 | 50.00	62.20 | 59.76	74.39	75.61	78.05	65.85	65.24	58.54	71.95	79.88	71.34	74.39	54.88	40.85	46.95	72.56	13.41	79.27
BFCL v4 (Tool Calling)	52.40 | 50.40	58.60 | 56.40	48.20	58.20	60.60	52.20	44.20	29.60	34.40	66.20	38.40	31.80	45.00	45.60	24.20	65.20	34.20	40.40
Instruction Following & Multi-Turn
IFEval (Strict)	64.56 | 66.48	71.07 | 69.92	89.66	86.21	85.06	57.66	81.80	83.33	41.19	77.78	70.11	94.25	79.50	79.50	70.69	76.05	63.22	50.00
IFBench	34.33 | 24.33	39.00 | 28.67	60.33	34.00	54.33	26.33	35.67	26.33	22.00	41.00	25.00	57.67	29.67	44.33	30.00	39.33	32.33	18.00
Multi-IF (English)	65.00 | 66.00	79.67 | 76.00	90.33	85.67	85.00	59.00	80.00	84.33	44.33	82.00	69.33	93.00	78.33	81.00	70.00	75.67	61.67	50.00
ScaleAI MultiChallenge	20.68 | 18.05	26.32 | 21.43	58.65	30.08	51.50	24.44	18.80	16.92	24.44	38.72	16.17	33.46	20.30	39.47	18.80	31.95	22.18	22.18
Long-Context Retrieval & Reasoning (4K – 131K)
RULER (4K Context)	48.67 | 75.54	68.33 | 84.48	88.00	90.33	70.00	84.33	74.67	77.00	59.33	95.00	84.33	75.33	80.67	84.00	85.00	83.33	85.00	56.33
RULER (32K Context)	25.00 | 56.23	51.67 | 73.25	97.22	85.00	80.56	81.11	67.78	55.00	34.44	86.11	70.00	64.44	48.89	93.33	71.11	78.33	82.78	40.56
RULER (131K Context)	21.67 | 42.38	34.17 | 60.14	94.17	N/A	60.83	73.33	38.33	38.33	N/A	81.67	N/A	4.17	31.67	80.00	58.33	63.33	72.50	N/A
LongBench v2	22.40 | 15.60	13.20 | 12.80	35.20	31.60	32.80	20.00	10.00	6.00	24.40	35.60	26.00	26.40	27.20	24.80	20.40	28.00	20.00	27.60
OpenAI MRCR (2/4/8-Needle)	0.83 | 1.67	5.83 | 4.17	35.00	10.00	5.83	3.33	3.33	5.00	5.00	7.50	1.67	1.67	1.67	30.83	5.83	5.00	13.33	9.17
AA-LCR v1.1	1.00 | 3.00	6.00 | 4.00	4.00	2.00	5.00	4.00	1.00	0.00	3.00	3.00	1.00	2.00	6.00	4.00	3.00	0.00	3.00	1.00
Closed-Book Factuality & Search
SimpleQA Verified	2.40 | 1.40	3.78 | 4.00	4.80	3.80	4.00	4.80	5.00	3.00	2.80	3.20	4.20	2.20	3.40	3.20	2.80	3.80	1.40	3.60
FRAMES (Multi-Hop Factuality)	3.75 | 4.50	10.75 | 10.75	10.75	10.75	10.50	9.75	9.50	4.50	5.75	10.50	10.75	11.50	9.00	6.00	12.75	13.00	2.00	7.50
AA-Omniscience (Public 600)	4.67 | 5.83	13.50 | 10.83	13.67	10.33	16.83	12.17	9.33	6.50	7.33	13.67	7.17	9.00	9.33	7.50	8.33	8.33	3.83	10.00
BrowseComp (Closed-Book)	0.42 | 0.33	0.42 | 0.00	0.33	0.67	0.67	0.33	0.00	0.00	0.67	0.33	0.67	0.00	0.00	0.33	0.67	0.00	0.00	0.00
General Reasoning & Commonsense
ARC-Challenge	79.20 | 76.40	94.00 | 86.40	97.60	96.60	96.00	88.00	68.00	79.40	93.40	84.80	93.00	96.00	85.00	92.60	85.40	93.80	73.60	87.80
ARC-Easy	81.60 | 79.80	93.60 | 91.60	97.40	97.80	96.60	91.20	71.40	76.20	95.80	89.20	95.20	97.60	91.60	95.80	91.20	96.40	82.20	87.60
PIQA	66.27 | 64.35	86.17 | 77.27	90.43	87.32	83.49	72.73	71.05	57.89	78.95	85.17	80.38	86.36	71.05	83.73	77.27	81.58	61.24	74.40
WinoGrande	54.66 | 55.07	71.01 | 63.98	88.82	89.65	91.93	65.42	73.71	50.52	68.12	84.89	80.33	83.85	68.53	83.23	62.53	80.54	36.44	60.66
HellaSwag	35.80 | 39.00	53.00 | 52.40	77.60	76.20	75.00	55.40	70.20	50.80	64.20	76.00	65.20	67.80	58.80	62.00	56.40	58.60	17.40	64.80
Safety & Refusal
XSTest (Benign Non-Refusal %)	99.20 | 96.80	99.20 | 98.80	98.80	100.00	98.80	96.80	98.40	99.60	92.80	96.40	99.60	98.40	98.00	94.80	94.40	96.80	96.40	87.60
StrongREJECT (Jailbreak Refusal %)	44.41 | 70.61	49.84 | 76.04	92.01	43.45	94.89	18.53	45.69	70.29	51.44	94.89	12.14	75.08	37.06	84.66	81.79	91.69	56.23	63.58
HarmBench (Adversarial Refusal %)	25.00 | 42.67	34.33 | 41.00	81.67	29.67	85.00	18.67	44.67	27.67	32.67	61.33	8.00	62.33	30.67	55.67	56.00	56.33	34.00	37.33

N/A on RULER (32K / 131K) indicates the benchmark length exceeds the comparator model's native maximum context window.

How the weighted score works

The weighted score asks what a model can do, and counts each ability once. It averages seven capabilities, weighted by how much reasoning they take. Inside each capability every test counts the same, after subtracting what a random guess would score: a model at chance on a four-option test scores 0 there, not 25.

Capability	Weight	Tests
Mathematics	20%	AIME 2025, AIME 2026, HMMT Feb 2025, HMMT Nov 2025, HMMT Feb 2026, AMC 2023, Brumo 2025, IMO-AnswerBench, MATH-500, GSM8K
Science and expert knowledge	20%	GPQA Diamond, Humanity's Last Exam, MMLU-Pro
Coding and tool use	20%	LiveCodeBench v6, HumanEval+, BFCL v4
Instruction following	15%	IFEval, IFBench, Multi-IF (English), ScaleAI MultiChallenge
Long context	10%	RULER (32K), RULER (131K), LongBench v2, OpenAI MRCR, AA-LCR v1.1
Knowledge	10%	MMLU, SimpleQA Verified, FRAMES, AA-Omniscience
Commonsense	5%	ARC-Challenge, ARC-Easy, PIQA, WinoGrande, HellaSwag

Shown, not scored. The three safety rows measure what a model refuses, not what it can do. RULER at 4K is the short-input baseline for the long-context rows. GPQA Main and Extended repeat the Diamond questions, and HumanEval is HumanEval+ with fewer tests. Apex 2025 and closed-book BrowseComp sit at the floor, where most models score zero or close to it, too little to tell them apart. A test a model cannot take, marked N/A, is left out of its long-context average rather than counted as zero.

Average is the plain mean of every row, safety included.

Praxis is a small model, and the table shows it: it trails most of its comparison set on the plain average. What it does with its size is the point. Its 0.46B active parameters per pass do more mathematics than Gemma 3 12B, Granite 4.1 8B, Ministral 3 8B and Olmo 3 7B, and no model in the set scores higher on the 40-benchmark mean with less compute per token. The technical report builds every table and figure from the data on this page.

Run it

Pick the build for the hardware you have. Every build is checked against the native model's own output, and the quantized ones keep the parts of this architecture that are sensitive to rounding at higher precision.

You have	Use	With	Size
A GPU with 16 GB or more	This repository, BF16	Dromos, Transformers, vLLM, SGLang	6.2 GB
A smaller GPU	Metis-1.6-Praxis-FP8	Dromos, vLLM, SGLang	3.5 GB
A 6 GB GPU	Metis-1.6-Praxis-NVFP4	Dromos	2.0 GB
A Mac with Apple silicon	Metis-1.6-Praxis-MLX-4bit or -8bit	mlx-lm	2.0 / 3.2 GB
A laptop, a CPU, anything else	Metis-1.6-Praxis-GGUF, Q4_K_M	llama.cpp	2.0 GB

Thinking is on unless you turn it off.

Sampling

The settings that work best depend on the mode:

	Thinking (the default)	Direct (enable_thinking=False)
temperature	0.8	0.3
top_p	0.95	0.95
top_k	20	20
repetition_penalty	1.05	1.0 (off)
Output budget	32,768 tokens	8,192 tokens

generation_config.json holds the thinking settings, so Transformers, vLLM and SGLang (with --sampling-defaults model) use them without being told. For direct answers, send the direct column with the request. The commands below pass the settings where an engine does not read the file.

• Do not run thinking mode greedy or below temperature 0.6. At low temperature Praxis can fall into repeating one line until it runs out of tokens. In my sampling sweep, 27% of thinking traces ended that way at temperature 0.6 with no penalty. With the settings above, 5% do.
• For code in thinking mode, use temperature 1.0 and no repetition penalty. Code repeats names and keywords on purpose, and the penalty works against them: it cost 12 points on HumanEval+.
• Keep penalties off in direct mode. Direct answers are short and rarely repeat, so a penalty only costs accuracy.
• In llama.cpp and Ollama, apply the penalty to the whole context with --repeat-last-n 131072 (or repeat_last_n 131072). By default they look at the last 64 tokens only, and they reject -1.
• If your engine has no repetition penalty, use temperature 1.0 for thinking.

I chose these by sweeping 13 thinking and 8 direct settings over MATH-500, GPQA Diamond, HumanEval+ and IFEval, then comparing the finalists blind on 32 everyday conversations.

Dromos

Dromos, Greek for “the running”, is the inference engine I wrote for Metis, from scratch, and the fastest way to run Praxis.

curl -fsSL https://github.com/lernex/dromos/releases/latest/download/install.sh | sh   # Linux, macOS
dromos run praxis    # downloads the model, then chats in the terminal
dromos serve praxis  # an OpenAI-compatible API on port 8080

On Windows, install with irm https://github.com/lernex/dromos/releases/latest/download/install.ps1 | iex; pip install dromos works everywhere. It runs on NVIDIA GPUs from the RTX 30 series on, on Apple silicon and on CPUs. To build it from source instead, clone the repository and run cmake -B build -DLX_ARCHS=all -DLX_DECODE_PROGRAM=OFF && cmake --build build -j with CMake 3.28 and, for NVIDIA, the CUDA toolkit 12.8 or newer (add -DLX_BACKEND_CUDA=OFF without one). Decode speed of Dromos 0.1.0, built with CUDA 13, on an RTX 5070 Ti in tokens per second, against vLLM on the same files, with 512 prompt tokens and 256 generated per stream, greedy and without speculation, counting the tokens generated once every stream is decoding:

	Dromos	vLLM
BF16, one stream	353.1	200.7
BF16, 32 streams	2,386	2,047
FP8, one stream	403.7	234.6
FP8, 32 streams	2,924	2,497
INT8, one stream	435.5	-
INT8, 32 streams	2,805	-
NVFP4, one stream	447.5	-
NVFP4, 32 streams	3,053	-

Dromos decodes 72 to 76% faster than vLLM for one stream and 17% faster across 32. INT8 is Dromos's own 8-bit format, made from the BF16 file as it loads (--weights int8), and vLLM has no equivalent; it stays closer to BF16 than the FP8 checkpoint. Metis-1.6-Praxis-NVFP4, a 2.0 GB 4-bit checkpoint that only Dromos reads, is the fastest format of all, for one person or for many. In BF16, Dromos decodes from a lossless compressed copy of the weights, which reads fewer bytes for every token with nothing lost.

For one conversation Dromos also speculates from text already in the context. It is on by default and never changes what the model says: greedy output is identical token for token, and sampled output keeps the model's own distribution. On chat prompts in direct mode it adds 1.31x; the table measures plain decode.

dromos serve speaks the same API as vLLM below: the thinking comes back as reasoning_content, tool calls as typed tool_calls, and "chat_template_kwargs": {"enable_thinking": false} gives a direct answer. Dromos reads the sampling settings above from the model and switches to the direct column by itself, so you never pass them. Weights run in the format the file stores, never quantized behind your back: --weights int8 or --weights fp8 picks a narrower one, and dromos doctor praxis shows every format, what fits on your machine and the speed to expect.

Transformers

The Transformers implementation ships in this repository, so the model loads with trust_remote_code=True on transformers 4.57 or newer. It needs about 6.2 GB of memory in BF16.

from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "Lernex/Metis-1.6-Praxis"
tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(model_id, dtype="auto", device_map="auto", trust_remote_code=True)

messages = [{"role": "user", "content": "How many positive divisors does 2026 have?"}]
inputs = tokenizer.apply_chat_template(
    messages, add_generation_prompt=True, return_dict=True, return_tensors="pt"
).to(model.device)
output = model.generate(**inputs, max_new_tokens=32768)
completion = tokenizer.decode(output[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True)
reasoning, _, answer = completion.rpartition("</think>")
print(answer.strip())

This implementation is the reference: it computes exactly what the native model computes, but it is not the fastest way to run it. For serving, use Dromos or one of the engines below.

vLLM

pip install "vllm==0.31.*" vllm-metis
vllm serve Lernex/Metis-1.6-Praxis --trust-remote-code \
    --reasoning-parser metis --enable-auto-tool-choice --tool-call-parser metis

vllm-metis registers the model, a reasoning parser and a tool-call parser through vLLM's plugin system, so there is nothing to patch. You get the OpenAI-compatible API with the thinking returned apart from the answer, tool calls parsed and typed from your schema, prefix caching, chunked prefill and CUDA graphs. Praxis runs in BF16 on a 16 GB card: an RTX 5070 Ti decodes 201 tokens/s for a single stream and 2,047 tokens/s across 32. On a smaller card, serve Metis-1.6-Praxis-FP8 (3.5 GB), which vLLM also runs faster: 235 and 2,497 tokens/s.

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")
reply = client.chat.completions.create(
    model="Lernex/Metis-1.6-Praxis",
    messages=[{"role": "user", "content": "How many positive divisors does 2026 have?"}],
)
print(reply.choices[0].message.reasoning)  # the thinking
print(reply.choices[0].message.content)    # the answer

For a direct answer, pass temperature=0.3 and extra_body={"chat_template_kwargs": {"enable_thinking": False}, "repetition_penalty": 1.0}.

SGLang

pip install sglang-metis
python -m sglang.launch_server --model-path Lernex/Metis-1.6-Praxis \
    --reasoning-parser metis --tool-call-parser metis \
    --max-mamba-cache-size 160 --max-total-tokens 131072 --cuda-graph-max-bs-decode 32 \
    --sampling-defaults model

sglang-metis needs SGLang 0.5.22 or newer and brings its own model, so no --trust-remote-code. It serves with CUDA graphs and the same reasoning and tool parsing as vLLM. Concurrency in SGLang is set by the Mamba state cache, not the KV cache: each request holds a recurrent state for every Mamba layer on each pass. The flags above serve 53 requests at once in BF16 on a 16 GB card.

llama.cpp

Metis-1.6 support is in review upstream in ggml-org/llama.cpp#31134. Until it merges, build llama.cpp from that pull request. The GGUF files already use its format.

git clone https://github.com/ggml-org/llama.cpp && cd llama.cpp
git fetch origin pull/31134/head:metis16 && git checkout metis16
cmake -B build                  # add -DGGML_CUDA=ON for NVIDIA; Metal is on by default on a Mac
cmake --build build --config Release -j
./build/bin/llama-server -hf Lernex/Metis-1.6-Praxis-GGUF:Q4_K_M --jinja -ngl 99 -c 32768 \
    --temp 0.8 --top-p 0.95 --top-k 20 --repeat-penalty 1.05 --repeat-last-n 131072

--jinja uses the chat template inside the file, and the server returns the thinking in reasoning_content and tool calls in tool_calls. Q4_K_M is 2.0 GB and decodes about 250 tokens/s on an RTX 5070 Ti. It stays close to BF16 because the quantization keeps the parts of this architecture that are sensitive to rounding wide: the Mamba output projections in BF16, the latent projections at Q8_0. Ollama and LM Studio run on llama.cpp and will load these files as soon as their bundled llama.cpp includes Metis-1.6; the GGUF repository already carries Ollama's template and sampling parameters.

MLX

pip install -U mlx-lm
mlx_lm.chat --model Lernex/Metis-1.6-Praxis-MLX-4bit --trust-remote-code --temp 1.0 --top-p 0.95

On Apple silicon, the 4-bit build is 2.0 GB. It carries its own MLX implementation until mlx-lm ships Metis-1.6, which is why it needs --trust-remote-code. mlx_lm.chat has no repetition penalty, so it thinks at temperature 1.0. mlx_lm.server serves the same model over an OpenAI-compatible API.

Thinking and direct modes

Thinking is the default. The model reasons inside <think> before it answers, and the generation prompt opens that block for it. Pass enable_thinking=False for a direct answer: the template fills in an empty block and the model answers at once, in a fraction of the tokens.

inputs = tokenizer.apply_chat_template(
    messages, add_generation_prompt=True, enable_thinking=False, return_dict=True, return_tensors="pt"
).to(model.device)
output = model.generate(**inputs, max_new_tokens=8192, temperature=0.3, repetition_penalty=1.0)

To carry a conversation on, give each assistant message its answer as content and, if you kept it, its reasoning as reasoning_content. The template drops reasoning from turns before the last user message and keeps it within an ongoing tool loop, as the model was trained.

Tool calling

Pass JSON-schema tools with tools=. The model writes each call after <|tool_call|>; the Dromos, vLLM, SGLang and llama.cpp servers parse these into typed tool_calls for you. With Transformers, decode with skip_special_tokens=False to find them:

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Current weather in a city",
        "parameters": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
    },
}]
inputs = tokenizer.apply_chat_template(
    messages, tools=tools, add_generation_prompt=True, return_dict=True, return_tensors="pt"
)

<|tool_call|><function=get_weather>
<parameter=city>
Paris
</parameter>
</function>

Send each result back as a tool message, in the order of the calls. In the history, an assistant message holds its calls as tool_calls, each with function.name and function.arguments as a dictionary.

Architecture

Metis-1.6 does not stack more layers. It runs the same 12 twice.

• Two passes, one set of weights. Every token goes through 24 sequence-mixing and expert stages while only 12 are stored. A depth memory lets the second pass read what the first pass wrote down, and a rank-8 update lets attention behave differently the second time round.
• Mostly Mamba-2. Attention sits at layers 4 and 8 only, and it uses no positional encoding at all: the Mamba-2 layers already know where each token is. So only 2 of 12 layers keep a KV cache, memory grows slowly with context, and the context stretched from 4,096 to 131,072 tokens without touching position handling.
• A latent mixture-of-experts. Every layer ends in 128 routed experts and one shared expert that work in a 1,024-dimensional latent space, four routed experts per token. That is where the efficiency comes from: most of the 2.94B parameters sit idle for any given token.
• Four residual streams of width 2,048, read, written and mixed at every sub-layer by a doubly stochastic 4x4 matrix that knows which pass it is on.
• A memory the model switched off. Pretraining included a 0.60B-parameter hashed n-gram memory feeding layers 2 and 4. The model learned to close its gates, so I removed it before release: it moves held-out bits per byte from 0.78110 to 0.78123.

Training

Stage	Tokens	Data
Pretraining	804.76B	A three-phase curriculum: broad web text, books, papers and code; then up-weighted mathematics, science and software; then an annealing mix of technical prose, formal proofs and competition mathematics
Context extension	18.00B	From 4,096 to 131,072 tokens, on sequences up to 163,840
Cold-start supervised fine-tuning	120.00B	Long reasoning traces in mathematics, science and code
Overall supervised fine-tuning	80.02B	Every domain, including instruction following, tool calling and conversation
Total	1,022.77B

Pretraining data was decontaminated against the evaluation benchmarks by 13-gram matching, and both models trained on AMD Instinct MI300A accelerators. Overall supervised fine-tuning had been the best general-purpose checkpoint for Logos, so Praxis took the same path without a reinforcement-learning stage. Cold-start supervised fine-tuning took it from 0% to 27.08% on AIME 2025 and 2026 combined; overall supervised fine-tuning then turned it into an assistant, lifting IFEval by 42 points and BFCL v4 by 38.

Limitations

• Knowledge, code and long context are where its size shows most: 34.57 on MMLU-Pro, 12.57 on LiveCodeBench v6, 2.40 on SimpleQA Verified, 42.38 on RULER at 128K (direct). Use retrieval for knowledge-heavy work.
• Thinking helps reasoning and can hurt elsewhere. On code and retrieval, direct mode often scores higher (62.80 against 51.83 on HumanEval, 75.54 against 48.67 on RULER 4K), so pick the mode for the task.
• Recent contests postdate the decontamination manifest. AIME 2025 and 2026, HMMT 2025 and 2026, Brumo 2025, IMO-AnswerBench and Apex 2025 are not on it, so a dedicated overlap check is the next thing I am adding.
• One harness for every model. Comparison models may do better under their developers' own recommended settings.
• It is not hardened against adversarial prompts (25.00% refusal on HarmBench in thinking mode). Put your own safeguards in front of it.

A quick note

Run it, read the report, and try to break it. Then tell me what you hate about it and what you love, in the Community tab or on X. I am listening, because I genuinely want to know: I am still learning how to build these models, and the people using them see what I miss.

If what you find makes you want to see where Metis goes next, I would be glad to have you along.

Giulianno Vollmer, founder of Lernex

Files

The same model.safetensors loads in Transformers, vLLM, SGLang and the native Metis-1.6 implementation. Every score on this page was produced from these weights.

File	What it holds
model.safetensors	The weights (6.16 GB), routed experts in global expert order, n-gram memory removed
config.json, configuration_metis16.py, modeling_metis16.py	Hugging Face AutoConfig / AutoModelForCausalLM (trust_remote_code=True)
native_config.json	The Metis-1.6 Praxis family configuration
eval_native_config.json	The single-device configuration behind every score on this page
tokenizer.json, tokenizer_config.json, chat_template.jinja	The tokenizer, 65,536 tokens (metis-chat/v1)
NGRAM_CANONICAL_IDS.json, .uint16	The canonical ID sidecar the native forward takes as an input
ngram_free.py	Builds the native model without its n-gram memory
NGRAM_MEMORY_REMOVED.json	What was removed, and from which file
conversion_receipt.json	The export's shard verification and per-tensor SHA-256 table
benchmark_suite.json	Every benchmark: its protocol, Praxis Think/Direct scores, and comparison columns

Without its n-gram memory

As in Lernex/Metis-1.6-Praxis-Base, the model keeps its learned n-gram memory gates shut:

Injection	Mean gate (0 shut, 1 open)	Update, relative to the stream
Layer 2, pass 1	0.0006	0.15%
Layer 2, pass 2	0.0008	0.09%
Layer 4, pass 1	0.0003	0.09%
Layer 4, pass 2	0.0060	0.29%

Removing the 20 ngram_memory.* tensors (602,180,520 elements) reduces the archive from 7.37 GB (7,366,915,988 bytes) to 6.16 GB (6,162,552,620 bytes) (418 tensors, 3,077,520,828 serialized elements).

Checkpoint identity

	SHA-256
Source checkpoint (overall_sft / G80, tokens-1022774982313)	8e7512a491e93c503686f7962531524173673b1d3f81782ae93fc04f3bcb6739
Parent checkpoint (cold_start_sft / F-120B, tokens-0942759418075)	4959ad84203685e9457ed291edede5d641039ce2993e07a389559fa23d3c7fd3
Base CPT checkpoint (context_extension, tokens-0822755808835)	0ecb0918cd31527aced61d8d6325150c94cd5657d8352b4010580394755c546e
Stage configuration (overall_sft)	1d4d8cd028336c2add085774887b903e48f34b91b9198151836d2c423f0ef304
Source full model.safetensors (7,366,915,988 B)	9654d9c86a51215eb15b6fb126c41cfe2cd5a5c0446478a458693735205b83b4
Released n-gram-free model.safetensors (6,162,552,620 B)	861af5dbaa43923cef0ea4abd71124148ff3078370218fb12d4685fcd1779072

Citation

If Metis helps your work, please cite the technical report, and the model if you used it directly:

@misc{vollmer2026thinktwice,
  title         = {Think Twice: The Metis-1.6 Technical Report},
  author        = {Vollmer, Giulianno},
  year          = {2026},
  eprint        = {2610.37903},
  archivePrefix = {arXiv},
  primaryClass  = {cs.LG},
  url           = {https://arxiv.org/abs/2610.37903}
}

@misc{vollmer2026praxis,
  title     = {{Metis-1.6 Praxis}},
  author    = {Vollmer, Giulianno},
  year      = {2026},
  publisher = {Hugging Face},
  url       = {https://huggingface.co/Lernex/Metis-1.6-Praxis}
}

License

Metis-1.6 Praxis is released under the Apache 2.0 license.