round2-1.7b-loop-preview

round2-1.7b-loop-preview is an experimental, looped version of LFM3-1.7B by Liquid AI.

• First pass: Liquid AI's network runs exactly as released.
• Second pass: layers 5-20 run again through a small learned refinement path with 44M new parameters.
• Gate: a learned gate decides, per token and per channel, how much of the second pass to keep.
• Training: the new parameters were trained by expert iteration (ReST-EM) on the model's own verified answers. "Round 2" is the second accepted training round.

In short: with an 8,192-token budget, round 2 answered more questions right than stock LFM3-1.7B on all four of our evaluation sets, by 1.5 to 5.6 points.

• Where the gain comes from: mostly from finishing its reasoning within the budget more often.
• Untouched final test split: the gain was +1.5 ± 0.9 points, short of the significance bar we set before running it.
• Longer budgets: with 16k-32k tokens it ties stock.

This is a research preview, not a generally stronger model.

It needs a custom runtime. The GGUF runs only on a llama.cpp build with the two patches in runtime/, also available as a ready branch at github.com/renoirvieir4/llama.cpp. Stock llama.cpp and stock LM Studio cannot load it. A PyTorch reference implementation and the trained parameters are in pytorch/.

Base model and attribution

• Base model: LiquidAI/LFM3-1.7B, revision ac2586a34f1a1c03329dbdcdefabd8b6478ddaa7, by Liquid AI.
  • Liquid AI designed and trained the model, its hybrid convolution and attention architecture, its tokenizer and its chat template.
  • Every one of the 1.7B base weights in this repository is Liquid AI's and unchanged. The source model.safetensors has SHA-256 135922caef64e81e52af88ede8b7c3ddaa9d6da220a9737fb3065275dbfb4330.
• License: the LFM Open License v1.0 (LICENSE), inherited from the base model. See License.
• Status: an independent, unofficial derivative, not made, reviewed or endorsed by Liquid AI. "LFM" and "Liquid AI" are used only to identify the base model.
• Changes: everything changed relative to the base model is listed in NOTICE and described below.

Model details

Base	LFM3-1.7B: 24 layers (13 short-convolution, 6 full-attention, 5 sliding-window attention), hidden size 2,048, 262,144-token context
Added	44,044,544 parameters (2.6% of the base), FP32: 43.0M low-rank deltas, 1.05M router weights, 4,096 gate weights
Execution	40 layer visits per token: layers 0-20, then layers 5-20 again, then layers 21-23
GGUF	BF16 base weights plus FP32 loop parameters, 545 tensors, 3.64 GB
Training	Two rounds of expert iteration on 444 verified answers; base weights frozen
Language	Trained and evaluated in English only
Status	Research preview

How the loop works

tokens -> layers 0-4 -> layers 5-20 (first pass, exactly LFM3-1.7B) -> h1
                                                                        |
          second pass over layers 5-20, reusing the same weights:
            two residual streams; at each block an mHC router reads a mix
            of the streams, the layer runs with its rank-64 deltas, and the
            router writes the result back into both streams;
            h2 = the mean of the two streams after layer 20
                                                                        |
          gate:  h = h1 + g * (h2 - h1),   g = sigmoid(c + s . rmsnorm(h1))
                                                                        |
                                                  -> layers 21-23 -> output

• The first pass is Liquid AI's network, untouched. With the gate closed (g = 0) the model is LFM3-1.7B bit for bit. Training therefore starts from stock, and stock remains reachable.
• The second pass reuses the physical weights of layers 5-20. It does not copy them. It adds:

  • Two-stream mHC routing: before every attention or convolution block, and before every feed-forward block, a router computes from the residual streams:

    • pre weights, which mix the two streams into the block's input;
    • post weights, which scale the block's output into each stream;
    • a doubly stochastic 2x2 mixing matrix between the streams. This is the exact closed-form limit of Sinkhorn normalization for two streams.

    The design is adapted from SenseNova-Loop-9B-Preview, following mHC and Hyper-Connections.

  • Rank-64 deltas on every projection in those layers, active only on the second pass: q, k, v and o in attention layers, the input and output projections in convolution layers, and all three feed-forward matrices.

  • Separate state: each visit gets its own KV cache and convolution state.

• The gate: per channel, a learned logit c, initialized to logit(0.05). Per token, a learned vector s is read against the normalized first-pass state. Together they decide how much of the second pass reaches layers 21-23.
• Cost: about 1.7x the compute of LFM3-1.7B per token (40 instead of 24 layer visits, plus routing). We measured about 89 tokens/s on one RTX 3090 in LM Studio.

Training: the approach we took

Goal: make the looped model answer more questions right than stock LFM3-1.7B, training only the added parameters with reinforcement learning. The reward is computed on both the final answer and the chain of thought.

Reward for each answer:

• Right final answer: 0.7 + 0.2 x chain-of-thought grade + 0.1 x efficiency.
• Wrong final answer: 0.15 x chain-of-thought grade.
• Hit the token cap: 0.
• Chain-of-thought grade (0-1): 0.4 x the reasoning's conclusion agrees with the final answer, plus 0.3 x the arithmetic steps check out, plus 0.2 x low repetition, plus 0.1 x low dithering.
• Efficiency (0-1): on a log scale relative to the median length of that question's answers: 0.5 at the median, 1 at half of it, 0 at double.

Why expert iteration: we first tried policy-gradient RL (REINFORCE-style updates) and it did not learn. At about 100 answers per update the gradient was mostly noise, and the model drifted toward longer answers without held-out gains. Expert iteration (ReST-EM, Singh et al., 2023) optimizes the same reward as an EM procedure. Each round:

1. Sample: answer 256 fresh questions 4 times each, with an 8,192-token cap. Sampling uses temperature 1.0, top-k 20, top-p 0.95 and repetition penalty 1.1.
2. Keep the right answers, ranked by reward: up to 2 per question that had both right and wrong answers, and 1 per question that was always right.
3. Fit: train only the loop parameters on the kept answers, with a reward-weighted token-level likelihood loss, for 2 epochs.
4. Accept or roll back: keep the round only if it beats the previously accepted model by more than one standard error on a fixed held-out set. The comparison is paired, with the same random draws. Otherwise roll back.

Each round's 256 questions were stratified: 96 MMLU-Pro, 64 procedurally generated (logic, math, physics, statistics, cybersecurity, coding), 32 GSM8K, 32 ARC-Challenge and 32 MBPP. Held-out questions were excluded.

Round	Answers sampled	Right (pass@1 / pass@4)	Answers kept	Held-out score (8,192 tokens)	Against the previous model	Verdict
Start: untrained loop				75.6% (stock: 76.8%)
1	1,024	68.8% / 77.0%	223 (from 197 questions)	80.2%	+4.6 ± 2.4	accepted
2 (this model)	1,024	72.4% / 78.5%	221 (from 201 questions)	82.4%	+2.2 ± 2.1	accepted
3	1,024			76.2%	−6.2 ± 2.0	rolled back

Training hyperparameters

Setting	Value
Loop	layers [5, 21), 2 passes, 2 mHC streams, delta rank 64, token-and-channel gate initialized at 0.05
Trainable	loop parameters only (routers, deltas, gate); base frozen
Sampling	256 questions x 4 answers per round, 8,192-token cap, temperature 1.0, top-k 20, top-p 0.95, repetition penalty 1.1
Kept answers	up to 2 per question with mixed results, 1 per always-right question
Loss	reward-weighted token-level negative log-likelihood of the kept answers
Optimizer	AdamW, fresh each round; linear warmup over 10% of steps, then constant; gradient clipping at 1.0
Learning rates	deltas 5e-5; routers and the gate's token vector 2e-5; gate logits 2e-3
Weight decay	0.01 (0 for the gate logits)
Batch and epochs	32 answers per step, 2 epochs, about 14 steps per round
Safety stop	end the fit if KL to stock on chat text exceeds 0.015; it reached 0.0030 in round 1 and 0.0058 in round 2
Validation	10% of kept answers held out; validation likelihood improved along with training likelihood in both rounds
Compute	2 x NVIDIA RTX 3090, about 70 minutes per round

Results

How we compared:

• Pairing: every comparison is paired against stock LFM3-1.7B, on the same questions with the same random draws. "±" is one standard error of the paired per-question difference.
• Scoring: an answer counts as right only if it finishes within the token budget and its final answer verifies. Cut-off answers count as wrong.
• Thinking: all evaluations used thinking mode.

Evaluation sets. These are our own splits, built from public datasets plus procedurally generated questions with exactly computed answers. They are not comparable with published leaderboard numbers.

Set	Contents	Sampling
Held-out set	250 training-pool questions the untrained loop solved only sometimes: MMLU-Pro 120, procedural 80, MBPP 22, ARC-Challenge 15, GSM8K 13. Never trained on, but used to accept rounds, so round 2's score on it is optimistic.	temperature 1.0 for all questions
monitor-v2	128 questions: physics from MMLU-Pro and ARC-Challenge, general knowledge from MMLU-Pro, coding and cybersecurity from procedural questions. 4 answers each.	temperature 1.0 for all questions
reasoning-v1 dev	191 questions	Liquid AI's recommended setting per subject: temperature 1.0 for math, physics and statistics, 0.1 for the rest
reasoning-v1 final	576 questions	as for dev

Each reasoning-v1 subject is two-thirds public questions and one-third procedural questions. The six subjects are coding (MBPP), cybersecurity (MMLU computer security), logic (MMLU formal logic, plus Boolean-satisfiability counting), math (MMLU high-school and college mathematics), physics (MMLU high-school and college physics) and statistics (MMLU high-school statistics). The final split was evaluated once, after we had fixed its pass rule in advance: a paired gap above 2 standard errors.

Within the training budget

Evaluation	Questions x answers	Token budget	Stock LFM3-1.7B	round2	Paired gap (points)
Held-out set (used to accept rounds)	250 x 2	8,192	76.8%	82.4%	+5.6 ± 2.0
monitor-v2	128 x 4	4,096	65.4%	68.9%	+3.5 ± 1.4
reasoning-v1 dev	191 x 1	8,192	77.0%	80.6%	+3.7 ± 2.3
reasoning-v1 final (rule set in advance, run once)	576 x 2	8,192	77.0%	78.5%	+1.5 ± 0.9 (1.6 SE, not significant)

The untrained loop, with its gate at 0.05 before any training, scored 75.6% on the held-out set against stock's 76.8%. The loop alone adds nothing; the gain comes from training.

Effect of the token budget

Token budget	2,048	4,096	8,192	16,384	32,768
reasoning-v1 dev (191 x 1)	+6.8 ± 2.5	+4.2 ± 2.2	+3.7 ± 2.3	+0.0 ± 2.0	+0.0 ± 2.0
reasoning-v1 final (576 x 2)	+1.1 ± 1.0	+0.7 ± 1.0	+1.5 ± 0.9	not run	not run

The dev numbers are read off 32,768-token runs and the final numbers off the 8,192-token run. An answer counts as right within a budget only if it finished within that budget. At 32,768 tokens both models scored 174/191 on dev.

Final split by subject (8,192 tokens)

Subject	Stock LFM3-1.7B	round2	Paired gap (points)
Physics	81.8%	87.0%	+5.2 ± 2.8
Logic	62.5%	66.7%	+4.2 ± 1.9
Statistics	68.2%	71.4%	+3.1 ± 3.2
Math	91.7%	94.3%	+2.6 ± 1.7
Coding	76.6%	74.5%	−2.1 ± 1.0
Cybersecurity	81.2%	77.1%	−4.2 ± 2.3

What the results mean

• Round 2 writes shorter reasoning. On the final split, 10.8% of its answers hit the 8,192-token budget, against 13.5% for stock. Among answers that finished, it was right slightly less often: 87.9% against 89.0%.
• That trade cuts both ways. It gains where stock often runs out of budget (logic, physics, statistics and math) and loses a little where stock rarely does (coding and cybersecurity, where only 2-4% of answers are cut off).
• With a large budget there is no difference. At 16k-32k tokens stock finishes too, and the two models tie.
• The independent tests are smaller. The held-out gain (+5.6) was measured on the set used to accept rounds. The independent checks (monitor-v2, dev and final) are smaller, and only monitor-v2 clears 2 standard errors on its own.

What did not work

Each of these was measured the same way:

• More rounds: round 3 scored 6.2 ± 2.0 points below round 2 and was rolled back.
• Longer budgets and refitting: we ran expert iteration with a 16,384-token sampling cap, 32,768-token checks, and a refit from the untrained loop every round. Seven rounds, with up to 1,546 kept answers, produced no change: 83.95% pooled against the untrained loop's 84.00%.
• Preference pairs: DPO with a likelihood term on right/wrong answer pairs fit its training pairs but did not transfer. It made answers longer and less accurate, even on its training questions.
• Policy-gradient RL: no held-out gain.

Across all of these, training the loop changed how long answers run, not how often they are right.

Recommended settings

These settings are based on the evaluations above.

Sampling. These are what round 2 was trained and best evaluated with:

Use	Temperature	Top-k	Top-p	Repetition penalty
Math, science, logic, multi-step reasoning (recommended)	1.0	20	0.95	1.1
Chat, coding, tool use (Liquid AI's general setting)	0.1	50	1.0	1.1

• Origin of these profiles: they are Liquid AI's two recommended settings for LFM3-1.7B. The one difference is that our reasoning profile adds repetition penalty 1.1, because round 2 was trained and evaluated that way.
• Where round 2 helps: its gains were measured with the reasoning profile. With the general profile it was not better than stock on coding or cybersecurity, so for those tasks stock LFM3-1.7B is the better choice.
• Set the profile explicitly: the GGUF's embedded defaults are the general profile (temperature 0.1). Set the reasoning profile yourself for reasoning tasks.

Token budget and thinking:

• Thinking: leave it on, which is the chat template's default.
• max_tokens: use 8,192. That is the budget round 2 was trained for and where it beats stock. Its advantage is largest at 2k-8k tokens. Above 16k it matches stock, so raise the limit to 16k-32k only for very hard problems.

Runtime (llama.cpp or LM Studio):

• Load settings: full GPU offload, flash attention on, F16 KV cache, a single GPU.
• Memory: a 65,536-token context took about 5.2 GB of VRAM. Without flash attention, the attention buffers at that context took 17.7 GB across two GPUs.
• Tested: answers up to about 4,000 tokens through LM Studio. Earlier PyTorch evaluations went up to 32,768 tokens.

How to use

llama.cpp

The ready-to-build source is the branch round2-1.7b-loop-preview of renoirvieir4/llama.cpp. It is upstream llama.cpp ff0d396e3 plus the two patches in runtime/, and adds a tested one-command recipe (ROUND2-1.7B-LOOP-PREVIEW.md). To patch upstream yourself instead, see runtime/README.md. After building, run:

./build/bin/llama-server -m round2-1.7b-loop-preview-BF16.gguf -ngl 99 -fa on -c 65536 \
  --temp 1.0 --top-k 20 --top-p 0.95 --repeat-penalty 1.1

This exact command was tested on an RTX 3090 with a build from upstream plus both patches: it answered "17 x 23" with 391 at 89 tokens/s. With verbose logging (-v), the load log includes LFM3 refine loop: layers [5, 21) twice, 40 execution layers, delta rank 64.

LM Studio

LM Studio's own runtimes cannot load this model. runtime/README.md describes how the tested LM Studio runtime was made: a copy of LM Studio's Linux CUDA 12 llama.cpp runtime with only libllama.so replaced by the patched build. That runtime is a local build, not an official LM Studio release, and no LM Studio binaries are distributed here.

PyTorch reference

Download Liquid AI's base model, then this repository's pytorch/ folder:

hf download LiquidAI/LFM3-1.7B --revision ac2586a34f1a1c03329dbdcdefabd8b6478ddaa7 --local-dir base
hf download notfakerv/round2-1.7b-loop-preview --include "pytorch/*" --local-dir .

import json
import sys

import torch
from transformers import AutoTokenizer

sys.path.insert(0, "pytorch")
from base.modeling_lfm3 import Lfm3ForCausalLM  # Liquid AI's modeling code, downloaded into ./base
from modeling_lfm3_loop import LoopSettings, convert_model, load_adapter, stock_reference

model = Lfm3ForCausalLM.from_pretrained("base", dtype=torch.bfloat16).to("cuda")
convert_model(model, LoopSettings(**json.load(open("pytorch/loop_config.json"))))
load_adapter(model, "pytorch")
model.eval()

tokenizer = AutoTokenizer.from_pretrained("base")
messages = [{"role": "user", "content": "What is 17 multiplied by 23?"}]
inputs = tokenizer.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt", return_dict=True).to("cuda")
output = model.generate(**inputs, max_new_tokens=8192, do_sample=True, temperature=1.0, top_k=20, top_p=0.95, repetition_penalty=1.1)
print(tokenizer.decode(output[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True))

# The same network with the loop switched off is exactly LFM3-1.7B:
with torch.no_grad(), stock_reference(model):
    stock_logits = model(**inputs).logits

This snippet was tested with transformers 5.18 and PyTorch 2.11.

Validation of this release

• Native runtime against PyTorch: we compared on 4 prompts with 160-token continuations.

  • Agreement: the native GGUF predicted the same next token as the PyTorch reference 99.3-100% of the time, with mean KL at most 0.0003. That matches stock LFM3-1.7B's own agreement between the two implementations.
  • The loop's own effect: round 2 against stock has a KL of 0.0019-0.0057 in both implementations, and its per-position logit shifts correlate at a median of 0.99.

  Details are in validation/native-vs-pytorch.json.

• Decoding paths: batch and token-by-token decoding agree, and greedy decoding follows the token-by-token logits.

• Other architectures:

  • llama.cpp's architecture test suite gives identical results before and after patch 02: 175 tests over 162 architectures.
  • Greedy outputs were token-for-token identical on stock LFM3, two earlier LFM3-Loop models, Dory 4B, SenseNova Loop 9B and Clover 35B (validation/regression.json).

• LM Studio API: 17 x 23 gave 391, and a projectile problem gave 4.73 s after 3,726 tokens of reasoning (validation/lmstudio-smoke.json).

• Raw results: the per-question results behind every table above are in validation/evaluations/. They contain question IDs, subjects, counts and token lengths, but no question text.

Limitations

• Evidence: this is a research preview. The clearest wins are on sets used during development, and the gain on the final split is not statistically significant.
• No long-budget gain: there is no advantage over stock at large token budgets, and it is slightly worse on coding and cybersecurity questions.
• Scope: it was tested only in English and only on reasoning question sets. Chat quality, tool use, multilingual ability, long-context retrieval and safety behavior were not evaluated.
• Inherited behavior: it inherits the base model's knowledge, limitations and biases, and received no additional safety tuning.
• Runtime: it needs a patched runtime. Stock llama.cpp, stock LM Studio, vLLM and generic Transformers loaders cannot run it.
• Benchmarks: the numbers come from automatic graders on our own splits, with small samples. Standard errors are large relative to the effects.

Files

File	Contents
round2-1.7b-loop-preview-BF16.gguf	BF16 base weights (unchanged) plus FP32 loop parameters, 545 tensors
pytorch/adapter.safetensors	the 44M loop parameters only (FP32, 258 tensors)
pytorch/loop_config.json	loop settings
pytorch/modeling_lfm3_loop.py	reference implementation that runs Liquid AI's modeling code with the loop
runtime/01-lfm3-loop-prerequisites.patch	llama.cpp ff0d396e3 to the prerequisite custom runtime
runtime/02-lfm3-refine-loop.patch	the loop used by this model
runtime/README.md, runtime/LICENSE.llama.cpp	build and integration instructions; llama.cpp's MIT license
validation/	native-against-PyTorch comparison, regression checks, LM Studio tests, per-question evaluation results
LICENSE, NOTICE	LFM Open License v1.0; attribution and modification notices
provenance.json, SHA256SUMS	sources, settings and checksums

License

• Model files: the GGUF and pytorch/adapter.safetensors are under the LFM Open License v1.0 (LICENSE), inherited from LFM3-1.7B. Non-commercial and research use are permitted. Commercial use is licensed only to entities with annual revenue below US$10 million; see Section 5 of the license.
• Reference code: pytorch/modeling_lfm3_loop.py is under the Apache License 2.0 (pytorch/LICENSE-APACHE-2.0). Parts of it are adapted from SenseNova-Loop-9B-Preview (Apache-2.0).
• Runtime patches: patches to llama.cpp, under the MIT license (runtime/LICENSE.llama.cpp). Third-party code in patch 01 keeps its original MIT licensing.

Acknowledgements

• Liquid AI: the LFM3-1.7B base model, its architecture, tokenizer, chat template and recommended sampling settings.
• SenseNova / OpenSenseNova: the looped decoder and two-stream mHC design that this loop adapts (SenseNova-Loop-9B-Preview).
• Method authors: DeepSeek-AI for mHC; Zhu et al. for Hyper-Connections; Singh et al. for ReST-EM.
• Dataset authors: GSM8K (MIT), MMLU-Pro (MIT), ARC (CC BY-SA 4.0), MBPP (CC BY 4.0) and MMLU (MIT). Only questions were used; no dataset content is redistributed.
• Runtime contributors: the ggml authors and llama.cpp contributors; Maphist0 and contributors for llama.cpp PR #31306 (Clover); the contributors to llama.cpp PR #30306 (Dory).

Prepared by notfakerv with AI coding assistance.

Citation

Please cite the base model:

@article{liquidAI2026LFM3,
  author  = {Liquid AI},
  title   = {Introducing LFM3: Every Modality for Specialized Intelligence},
  journal = {Liquid AI Blog},
  year    = {2026},
  note    = {www.liquid.ai/blog/lfm3},
}

and, if you use this loop:

@misc{notfakerv2026round2loop,
  title        = {{round2-1.7b-loop-preview}: a looped {LFM3-1.7B} trained by expert iteration},
  author       = {notfakerv},
  year         = {2026},
  howpublished = {Hugging Face model repository},
  url          = {https://huggingface.co/notfakerv/round2-1.7b-loop-preview}
}