Lernex/Metis-1.6-Logos

Technical report  ·  Metis-1.6  ·  Lernex  ·  X

Metis-1.6 Logos

Metis-1.6 Logos is a 10.23B-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 1.18B parameters on each pass. I built it from scratch, from the data pipeline to the training kernels, and trained it on 1.02 trillion tokens, roughly a twelfth of the median among the open models it is measured against that publish a count. It ranks second of 30 open models in mathematics, with 67.50% on AIME 2025 and 63.64% on HMMT February 2026, and sits on the Pareto frontier for both training data and compute. It is not a frontier model and does not pretend to be: code, instruction following and long context still trail. It thinks or answers directly, on request, across a 131,072-token context, and it is yours under Apache 2.0.

Benchmarks

Logos in thinking and direct mode (Think | Direct) beside Metis-1.6 Praxis and the post-trained releases of 15 open models from the Logos Base comparison set. 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 Logos (Think | Direct)vsall 16 modelsMetis-1.6 PraxisQwen3.5 4BQwen3 4BLFM2.5 8B-A1BGranite 4.0 H TinyTrinity NanoOLMoE 1B-7BQwen3.5 9BQwen3 8BGemma 4 12BGemma 3 12BGranite 4.1 8BMinistral 3 8BOlmo 3 7BFalcon-H1 7BGemma 4 E4B

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

Metis-1.6 Praxis2.94B · 131KQwen3.5 4B4.21B · 256KQwen3 4B4.02B · 32KLFM2.5 8B-A1B8.47B · 125KGranite 4.0 H Tiny6.94B · 128KTrinity Nano6.12B · 128KOLMoE 1B-7B6.92B · 4KQwen3.5 9B8.95B · 256KQwen3 8B8.19B · 32KGemma 4 12B11.94B · 256KGemma 3 12B12.19B · 128KGranite 4.1 8B8.38B · 128KMinistral 3 8B8.49B · 256KOlmo 3 7B7.30B · 64KFalcon-H1 7B7.59B · 256KGemma 4 E4B7.52B · 128K

	Metis-1.6 Logos (Think | Direct)	Metis-1.6 Praxis	Qwen3.5 4B	Qwen3 4B	LFM2.5 8B-A1B	Granite 4.0 H Tiny	Trinity Nano	OLMoE 1B-7B	Qwen3.5 9B	Qwen3 8B	Gemma 4 12B	Gemma 3 12B	Granite 4.1 8B	Ministral 3 8B	Olmo 3 7B	Falcon-H1 7B	Gemma 4 E4B
# Params	10.23B	2.94B	4.21B	4.02B	8.47B	6.94B	6.12B	6.92B	8.95B	8.19B	11.94B	12.19B	8.38B	8.49B	7.30B	7.59B	7.52B
# Activated params, per pass	1.18B	0.464B	3.57B	3.63B	1.42B	1.31B	0.614B	1.08B	6.92B	6.95B	10.94B	10.78B	7.97B	7.42B	6.48B	6.79B	4.03B
# Activated params, total	2.37B	0.94B	3.57B	3.63B	1.42B	1.31B	0.614B	1.08B	6.92B	6.95B	10.94B	10.78B	7.97B	7.42B	6.48B	6.79B	4.03B
Context	131K	131K	256K	32K	125K	128K	128K	4K	256K	32K	256K	128K	128K	256K	64K	256K	128K
Training tokens	1.02T	1.02T	undisclosed	36T	38T	22.5T	10T	5.13T	undisclosed	36T	undisclosed	12T	14.9T	1-3T	6.08T	12T	undisclosed
Summary Scores (Think | Direct)
Weighted score	46.46 | 33.29	27.10 | 24.24	53.14	48.08	34.36	30.71	23.31	12.75	56.57	49.53	59.88	40.77	40.17	39.27	33.67	36.39	50.20
Average	52.00 | 41.20	33.82 | 32.14	60.24	53.86	39.46	38.63	31.41	24.94	63.03	55.38	65.04	45.97	46.87	44.38	43.15	43.30	55.58
Math & Olympiad Reasoning
AIME 2025	67.50 | 0.00	10.00 | 0.00	64.17	53.75	20.83	7.92	1.67	0.00	71.25	52.08	79.17	18.75	16.67	20.83	24.58	10.83	41.25
AIME 2026	67.50 | 6.67	16.67 | 0.00	73.33	63.75	23.33	3.75	2.92	0.00	78.75	61.25	79.58	16.25	13.33	17.50	29.17	7.08	46.67
HMMT Feb 2025	65.00 | 13.33	6.67 | 0.00	36.25	35.83	10.42	2.08	1.25	0.00	45.42	33.75	61.67	9.17	10.00	12.50	10.42	3.75	25.00
HMMT Nov 2025	59.58 | 10.00	16.67 | 0.00	39.58	44.17	7.08	3.33	0.42	1.67	46.67	43.75	69.58	8.33	9.58	12.92	12.08	3.33	38.33
HMMT Feb 2026	63.64 | 0.00	18.18 | 0.00	35.61	34.85	14.39	1.52	0.76	0.38	39.39	41.67	53.03	10.23	12.12	9.85	18.94	2.27	31.82
AMC 2023	95.00 | 60.00	55.00 | 22.50	84.38	93.44	61.25	41.56	28.44	7.50	93.12	90.94	97.81	64.38	65.00	58.12	67.19	47.50	86.25
Brumo 2025	75.83 | 33.33	23.33 | 6.67	49.58	59.58	29.17	11.67	9.58	2.08	62.08	67.08	76.25	26.25	23.75	22.50	29.58	18.75	54.17
IMO-AnswerBench	57.00 | 19.50	16.00 | 2.50	33.50	37.00	4.00	4.00	2.50	2.00	38.50	37.00	44.50	12.50	10.00	12.50	12.00	7.00	29.50
Apex 2025	0.00 | 16.67	0.00 | 0.00	0.00	0.00	0.00	0.00	0.00	0.00	1.04	0.00	1.04	0.00	0.00	0.00	0.00	1.04	2.08
MATH-500	89.40 | 70.60	78.80 | 51.80	83.60	88.00	71.40	67.00	56.60	20.60	88.40	88.20	94.20	83.20	78.40	71.60	76.60	56.40	90.40
GSM8K	90.60 | 81.00	76.80 | 63.60	96.60	95.20	90.40	88.20	80.20	53.80	96.40	96.20	97.80	90.20	94.40	85.60	83.00	87.20	92.80
Frontier Science & Knowledge
GPQA Diamond	55.05 | 34.34	27.78 | 22.22	76.26	52.02	28.28	30.30	23.74	23.74	81.31	53.54	74.24	39.39	40.40	40.91	37.37	44.95	61.62
GPQA Main	50.45 | 33.03	31.03 | 25.22	70.76	47.32	39.28	28.35	24.55	23.89	72.10	52.46	66.07	37.72	39.51	41.74	34.37	41.96	55.14
GPQA Extended	41.58 | 30.22	23.26 | 17.58	65.57	48.35	43.22	29.30	23.26	21.79	65.20	49.82	60.81	34.43	38.83	39.56	35.53	42.31	50.00
Humanity's Last Exam	4.38 | 6.91	5.85 | 6.50	6.90	3.95	3.70	5.55	4.41	2.71	7.82	3.98	9.39	4.01	4.31	2.07	4.59	3.48	4.47
MMLU-Pro	59.14 | 44.00	34.57 | 32.29	66.86	64.86	49.86	33.43	33.43	14.29	71.43	68.86	61.57	60.57	59.14	59.29	47.00	61.71	68.00
MMLU	68.00 | 61.57	53.43 | 50.43	73.57	78.14	65.57	59.14	62.57	36.29	74.29	81.43	76.29	76.71	77.29	75.71	62.86	77.00	79.57
Coding & Agentic Tool Use
LiveCodeBench v6	24.57 | 13.71	12.57 | 11.43	17.14	34.29	18.29	20.57	10.29	2.86	20.57	32.00	39.43	39.43	22.29	33.71	0.57	22.86	42.29
HumanEval	76.22 | 72.56	51.83 | 62.80	87.80	92.68	79.27	81.71	59.76	30.49	91.46	88.41	96.95	84.76	85.37	87.20	82.93	82.93	95.73
HumanEval+	62.20 | 59.76	42.07 | 50.00	74.39	75.61	64.63	64.02	45.12	22.56	77.44	74.39	83.54	65.24	70.12	70.73	67.68	65.85	79.88
BFCL v4 (Tool Calling)	58.60 | 56.40	52.40 | 50.40	48.20	58.20	36.60	55.80	30.20	11.00	54.60	59.80	67.20	51.80	60.00	56.60	44.80	36.00	66.20
Instruction Following & Multi-Turn
IFEval (Strict)	71.07 | 69.92	64.56 | 66.48	89.66	86.21	84.67	78.74	53.26	63.98	92.15	86.97	92.91	84.87	84.87	61.69	85.25	86.02	77.78
IFBench	39.00 | 28.67	34.33 | 24.33	60.33	34.00	52.00	20.33	16.67	21.33	63.67	35.00	74.00	36.67	36.67	30.67	34.33	30.00	41.00
Multi-IF (English)	79.67 | 76.00	65.00 | 66.00	90.33	85.67	85.33	77.33	52.67	63.00	92.67	88.33	94.67	85.33	83.67	63.67	82.67	85.00	82.00
ScaleAI MultiChallenge	26.32 | 21.43	20.68 | 18.05	58.65	30.08	29.32	15.41	19.17	14.66	58.65	34.59	62.78	32.33	18.80	27.07	24.06	20.30	38.72
Long-Context Retrieval & Reasoning (4K – 131K)
RULER (4K Context)	68.33 | 84.48	48.67 | 75.54	88.00	90.33	63.67	81.67	78.33	59.00	88.33	92.33	90.00	94.00	86.33	92.00	73.00	93.00	95.00
RULER (32K Context)	51.67 | 73.25	25.00 | 56.23	97.22	85.00	41.11	61.67	50.56	N/A	90.56	87.78	88.33	71.11	76.67	87.78	53.33	79.44	86.11
RULER (131K Context)	34.17 | 60.14	21.67 | 42.38	94.17	N/A	5.83	47.50	16.67	N/A	85.00	N/A	83.33	45.00	50.83	78.33	N/A	45.83	81.67
LongBench v2	13.20 | 12.80	22.40 | 15.60	35.20	31.60	15.60	14.40	13.60	10.40	34.80	33.60	40.00	29.60	24.40	31.20	33.60	20.40	35.60
OpenAI MRCR (2/4/8-Needle)	5.83 | 4.17	0.83 | 1.67	35.00	10.00	0.83	5.83	0.83	0.00	34.17	9.17	15.83	7.50	8.33	5.83	0.83	7.50	7.50
AA-LCR v1.1	6.00 | 4.00	1.00 | 3.00	4.00	2.00	0.00	1.00	4.00	3.00	9.00	2.00	5.00	5.00	4.00	6.00	3.00	2.00	3.00
Closed-Book Factuality & Search
SimpleQA Verified	3.78 | 4.00	2.40 | 1.40	4.80	3.80	8.00	4.60	3.40	3.80	7.00	6.40	4.60	4.80	5.00	5.00	3.20	4.00	3.20
FRAMES (Multi-Hop Factuality)	10.75 | 10.75	3.75 | 4.50	10.75	10.75	17.50	10.25	9.00	4.75	17.50	16.00	17.25	14.50	17.50	16.00	7.00	8.75	10.50
AA-Omniscience (Public 600)	13.50 | 10.83	4.67 | 5.83	13.67	10.33	20.83	12.17	9.83	6.67	15.50	12.17	15.50	12.00	15.00	15.17	6.50	12.83	13.67
BrowseComp (Closed-Book)	0.42 | 0.00	0.42 | 0.33	0.33	0.67	2.00	0.00	0.67	0.67	0.00	1.67	0.33	0.67	0.67	1.33	0.00	0.67	0.33
General Reasoning & Commonsense
ARC-Challenge	94.00 | 86.40	79.20 | 76.40	97.60	96.60	93.60	81.00	88.20	48.20	96.60	97.60	96.20	96.00	94.00	94.40	83.00	95.20	84.80
ARC-Easy	93.60 | 91.60	81.60 | 79.80	97.40	97.80	93.80	82.60	95.00	50.00	97.40	98.40	97.00	97.60	97.80	96.60	86.00	96.80	89.20
PIQA	86.17 | 77.27	66.27 | 64.35	90.43	87.32	83.73	73.92	81.82	53.11	91.39	89.71	91.15	88.04	89.00	83.49	73.92	85.65	85.17
WinoGrande	71.01 | 63.98	54.66 | 55.07	88.82	89.65	77.23	69.77	72.26	58.80	89.44	92.55	90.06	83.23	86.75	75.78	68.32	83.85	84.89
HellaSwag	53.00 | 52.40	35.80 | 39.00	77.60	76.20	48.20	57.60	59.60	41.00	84.20	82.80	79.00	81.60	82.20	69.80	55.40	78.20	76.00
Safety & Refusal
XSTest (Benign Non-Refusal %)	99.20 | 98.80	99.20 | 96.80	98.80	100.00	99.20	92.80	99.60	92.40	99.20	100.00	100.00	98.40	94.40	96.80	91.60	98.80	96.40
StrongREJECT (Jailbreak Refusal %)	49.84 | 76.04	44.41 | 70.61	92.01	43.45	2.88	76.36	15.02	90.10	94.89	46.33	97.44	46.01	72.84	23.00	88.50	67.09	94.89
HarmBench (Adversarial Refusal %)	34.33 | 41.00	25.00 | 42.67	81.67	29.67	10.67	57.00	8.67	60.00	91.00	36.00	71.33	29.33	55.00	15.33	77.67	36.33	61.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.

Logos is at its best where reasoning is longest. Among the 17 models in its own table it posts the top score on HMMT February 2025 (62.92), HMMT February 2026 (63.64) and IMO-AnswerBench (57.00), and the best overall mathematics result after Gemma 4 12B, a model that publishes no training-token count. 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 32 GB or more	This repository, BF16	Dromos, Transformers, vLLM, SGLang	20.8 GB
A 16 or 24 GB GPU	Metis-1.6-Logos-FP8	Dromos, vLLM, SGLang	11.2 GB
An 8 or 12 GB GPU	Metis-1.6-Logos-NVFP4	Dromos	6.6 GB
A Mac with Apple silicon	Metis-1.6-Logos-MLX-4bit or -8bit	mlx-lm	6.6 / 11.1 GB
A laptop, a CPU, anything else	Metis-1.6-Logos-GGUF, Q4_K_M	llama.cpp	6.7 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 below temperature 0.6. On hard problems Logos can fall into repeating itself until it runs out of tokens. In my sampling sweep, 11% of thinking traces ended that way at temperature 0.6 with no penalty, and GPQA Diamond fell from 50.0 to 27.5. With the settings above, 1.5% do.
• Keep penalties off in direct mode. Direct answers are short and rarely loop (1.3% at temperature 0.3), so they need none.
• 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. It scores within a point of the settings above.

I chose these by testing the strongest settings from a 21-setting sweep of Praxis on Logos, over MATH-500, GPQA Diamond, HumanEval+ and IFEval, then comparing them 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 Logos.

curl -fsSL https://github.com/lernex/dromos/releases/latest/download/install.sh | sh   # Linux, macOS
dromos run logos:fp8    # downloads the model, then chats in the terminal
dromos serve logos:fp8  # 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
FP8, one stream	187.4	117.9
FP8, 32 streams	1,331	1,143
NVFP4, one stream	199.7	-
NVFP4, 32 streams	1,425	-

Dromos decodes 59% faster than vLLM for one stream and 16% faster across 32. Both hold all 32 streams on a 16 GB card at this length, vLLM only with the flags in its section below. Metis-1.6-Logos-NVFP4, a 6.6 GB 4-bit checkpoint that only Dromos reads, is the fastest format of all, for one person or for many.

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.30x; the table measures plain decode.

dromos run logos runs this repository in BF16, and on a 16 GB card too: the routed experts that don't fit stay in system memory, and the GPU caches as many of them as it can. On the RTX 5070 Ti, BF16 Logos decodes 128.9 tokens/s that way for one stream.

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 logos:fp8 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 21 GB of memory in BF16.

from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "Lernex/Metis-1.6-Logos"
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-Logos-FP8 --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. On a 16 or 24 GB card, serve the FP8 checkpoint, as above, which keeps the Mamba output projections and every FP32 tensor as trained and runs both faster and closer to BF16 than quantizing on load. On an RTX 5070 Ti it decodes 118 tokens/s for a single stream. Across 32 streams it decodes 1,143 tokens/s with --max-model-len 1024 --gpu-memory-utilization 0.96 --max-num-batched-tokens 2048, which lets all 32 fit on a 16 GB card; with a 9,216-token context it holds 17 and queues the rest.

With 32 GB or more, serve this repository in BF16: vllm serve Lernex/Metis-1.6-Logos --trust-remote-code with the same flags.

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-Logos-FP8",
    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-Logos-FP8 \
    --reasoning-parser metis --tool-call-parser metis \
    --max-mamba-cache-size 24 --max-total-tokens 32768 --cuda-graph-max-bs-decode 8 \
    --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 fit the FP8 checkpoint on a 16 GB card; raise them on a bigger one.

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-Logos-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 6.7 GB and decodes about 129 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-Logos-MLX-4bit --trust-remote-code --temp 1.0 --top-p 0.95

On Apple silicon, the 4-bit build is 6.6 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 20 twice.

• Two passes, one set of weights. Every token goes through 40 sequence-mixing and expert stages while only 20 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 5, 10 and 15 only, and it uses no positional encoding at all: the Mamba-2 layers already know where each token is. So only 3 of 20 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 192 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 10.23B parameters sit idle for any given token.
• Four residual streams of width 2,560, 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 1.77B-parameter hashed n-gram memory feeding layers 2 and 5. The model learned to close its gates, so I removed it before release: it changes held-out loss by less than 0.001 nats.

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	17.94B	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.00B	Every domain, including instruction following, tool calling and conversation
Total	1,022.70B

Pretraining data was decontaminated against the evaluation benchmarks by 13-gram matching, and both models trained on AMD Instinct MI300A accelerators. I also ran reinforcement learning on Logos. It shortened the reasoning at the cost of breadth, so this release is the end of supervised fine-tuning. What reinforcement learning taught me, including a length reward that punished correct answers for being long, is in the technical report.

Limitations

• Code, instruction following, long context and factual recall trail the strongest models in its class: 24.57 on LiveCodeBench v6, 39.00 on IFBench, 13.20 on LongBench v2, 3.78 on SimpleQA Verified. Use retrieval for knowledge-heavy work.
• Thinking is long on hard problems: a median of 25,028 tokens on AIME. Give it room (max_new_tokens of 32,768 or more), or ask for a direct answer when speed matters.
• 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, and these are exactly where Logos is strongest, 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 (34.33% 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 (20.80 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)
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, Logos Think/Direct scores, and comparison columns

Without its n-gram memory

As in Lernex/Metis-1.6-Logos-Base, the post-trained model keeps its learned n-gram memory gates shut. Measured on 44,684 evaluation tokens on tokens-1022704091713:

Injection	Mean gate (0 shut, 1 open)	Update, relative to the stream
Layer 2, pass 1	0.000417	0.17%
Layer 2, pass 2	0.005928	0.85%
Layer 5, pass 1	0.000131	0.04%
Layer 5, pass 2	0.002544	0.34%

Zeroing the n-gram gates moves NLL by -0.000647 nats (1.184412 → 1.183764, 97.65% top-1 token agreement). Removing the 20 ngram_memory.* tensors (1,774,549,800 elements) reduces the archive from 24.35 GB (24,349,960,158 bytes) to 20.80 GB (20,800,858,174 bytes) (679 tensors, 10,393,227,897 serialized elements).

Checkpoint identity

	SHA-256
Source checkpoint (overall_sft / G80, tokens-1022704091713)	44b8e759242f18543e8f7cd1f21797d97d96ba5c9cad276a539f16f98c47c1d4
Parent checkpoint (cold_start_sft, tokens-0922296228546)	be49dfbd169f0639923707d6d50819c7b67b1d458732a1240a7eb166838d1672
Base CPT checkpoint (context_extension, tokens-822693954328)	92db097ab8806993d4a26070adc37e904241010d5bdd77bdb6c68a281ed28ae5
Source full model.safetensors (24,349,960,158 B)	356be6c68f83d9e69171216e11600c54607ca586dc0e9e0ca227d29cebcfe614
Released n-gram-free model.safetensors (20,800,858,174 B)	965efc2f0fab4207522c61dce5f39a60b2149c346e009a8eb01b897d25360701

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{vollmer2026logos,
  title     = {{Metis-1.6 Logos}},
  author    = {Vollmer, Giulianno},
  year      = {2026},
  publisher = {Hugging Face},
  url       = {https://huggingface.co/Lernex/Metis-1.6-Logos}
}

License

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