Table of Contents
SenseNova-Loop-9B: SenseTime's 9B Model That Runs Its Layers Twice
Most open-weight models get smarter by storing more parameters. SenseTime's SenseNova-Loop-9B gets deeper a different way: it sends your prompt through the same 24 layers twice. SenseTime released the weights and code on November 17, 2026, under Apache 2.0, and is calling the result roughly equivalent to a 14.6B dense model running on a 9B-parameter footprint (per the SenseNova-Loop-9B model card on Hugging Face). That 14.6B figure is SenseTime's own framing, not an outside lab's measurement, so treat it as a description of intent rather than a verified benchmark.
Here's what to actually take from this: if you want a free, self-hostable multimodal model with a genuinely long context window and you can spare 10 to 15 GiB of GPU memory, Loop-9B is worth downloading this week. If you need a model with an independent benchmark trail, give it a few weeks for someone outside SenseTime to run the numbers.
What the looped architecture actually does
Loop-9B is a 32-layer autoregressive decoder, but it doesn't run those 32 layers once per token the way a standard transformer does. Layers 0 through 3 run once. Then the middle block, layers 4 through 27, runs twice in sequence, with the output of the first pass feeding back in as the input to the second. Layers 28 through 31 run once at the end. Add it up and you get 56 total layer computations per forward pass from only 32 distinct sets of stored weights (per the model card).
The trick behind the looping is something SenseTime calls two-stream manifold-constrained hyper-connections, or mHC. Instead of one residual stream carrying information between layers, Loop-9B carries two, and a learned, Sinkhorn-normalized routing map decides how each layer reads from and writes back to both streams. Twenty normalization iterations run on that routing map inside the model configuration. The point of the second stream is to give the looped block more room to combine information across its two passes without the two passes just repeating the same computation.
There's a second architectural choice worth knowing before you deploy: attention is hybrid, not uniform. Every group of four layers runs three linear-attention layers followed by one full-attention layer, and the loop boundaries land on complete four-layer groups, so both passes see the identical attention pattern. That's why a serving stack needs model-specific support rather than generic "run any transformer" code; trust_remote_code=True isn't optional here.
SenseTime isn't claiming the loop trick is free. Its own ablation study (which it calls "loop scaling") found that going from one pass to two or three improved most of its four internal benchmarks, with gains topping out around three or four loops depending on the task. Loop-9B and its preview both ship with two loops as the default, because that's where SenseTime found the best tradeoff between quality and inference cost, not because two is architecturally special.
What it costs, and what it needs
The model is free. Weights ship under Apache 2.0, which permits commercial use and modification, on both Hugging Face and ModelScope, plus an official AWQ 4-bit build and GGUF quantizations at Q8_0, Q5_K_M, and Q4_K_M. Your real cost is hardware, and SenseTime's own low-memory deployment numbers are specific about what that means:
| Context length | 8-bit KV cache | 4-bit KV cache |
|---|---|---|
| 64K tokens | ~10 GiB | ~9 GiB |
| 128K tokens | ~12 GiB | ~10 GiB |
| 256K tokens | ~15 GiB | ~12 GiB |
Source: SenseNova-Loop-9B model card, "Low-Memory Deployment" section.
With 4-bit weight quantization, the model's distinct parameters occupy roughly 4.9 GB on disk (per the model card), which is why a single consumer GPU can run it at a moderate context length. Push the context toward the full 512K the architecture supports and you'll need considerably more memory than the table above shows at 256K; SenseTime doesn't publish a number for the full window, so budget conservatively if you plan to use anywhere near it.
One practical catch before you download: the Hugging Face repository is gated. You have to log in and accept SenseTime's terms before the files unlock, which is a 30-second step but not one you can script around with an anonymous curl.
How to get it running
Two commands get you the weights once you're past the gate:
pip install -U huggingface_hub
huggingface-cli login
hf download sensenova/SenseNova-Loop-9B
For a quick single-GPU text generation check, SenseTime's own quickstart (from the model card, not run here) loads the model through Transformers 5.18.0:
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
model_id = "/path/to/SenseNova-Loop-9B"
device = "cuda:0"
tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
model_id,
trust_remote_code=True,
dtype=torch.bfloat16,
device_map={"": device},
).eval()
messages = [{"role": "user", "content": "What is 13 times 7?"}]
prompt = tokenizer.apply_chat_template(
messages, tokenize=False, add_generation_prompt=True, enable_thinking=True,
)
inputs = tokenizer(prompt, return_tensors="pt").to(device)
with torch.inference_mode():
outputs = model.generate(**inputs, max_new_tokens=512, do_sample=False)
print(tokenizer.decode(outputs[0, inputs.input_ids.shape[1]:], skip_special_tokens=True))
For serving, the 4-bit AWQ checkpoint runs on a single GPU through a patched vLLM build:
git clone https://github.com/vllm-project/vllm.git
cd vllm && git fetch origin pull/64832/head && git checkout -b sensenova-loop FETCH_HEAD
python -m pip install -e .
vllm serve sensenova/SenseNova-Loop-9B-AWQ \
--served-model-name sensenova_loop \
--dtype bfloat16
That last step is the catch most people will hit first: as of release, stock vLLM doesn't know how to execute a looped decoder, so you're building from an open pull request rather than a tagged release. The same is true for SGLang. LightLLM and llama.cpp-based runtimes (via the published GGUF files) are the more stable path if you'd rather not build from a PR.
How it performs, with the asterisk attached
SenseTime says Loop-9B is "competitive with" its own Qwen3.8-27B comparison point on agentic and data-analysis tasks: 65.31 versus 65.01 on AIDABench, and 41.36 versus 44.60 on NL2Repo, where the larger Qwen model still wins. Against its own October 31 preview release, Loop-9B's gains are bigger: AutomationBench rose from 14.33 to 36.67, Terminal-Bench 2.1 from 40.45 to 59.55, and GAIA from 37.86 to 69.90 (all per the model card's benchmark section).
Every one of those numbers comes from SenseTime's own evaluation harness. TechNode's reporting on the release repeats the vendor's framing without adding an independent check, and no third-party leaderboard result had posted as of this writing. A model that beats a 27B dense competitor on two out of two cited agent benchmarks while using a third of the stored parameters is a genuinely interesting claim. It's also exactly the kind of claim that needs someone other than the people who built it to confirm.
Where it falls short
SenseTime's own "Known Limitations" section is more candid than most vendor model cards, and worth reading before you build on this: complex instruction following degrades when you hand the model many tool definitions or stacked constraints at once, coding and general agent tasks are inconsistent on long-horizon work even though the model can self-correct some errors over additional steps, and complex web generation with heavy 3D or animation sometimes needs two or three rounds of user feedback rather than landing in one shot.
Add the limits that come from the architecture itself, not SenseTime's disclosure. Input is text and images only, no audio or video. And a compatible inference implementation has to load the exact loop range, pass count, and mHC routing parameters and preserve the same computation order as the reference implementation, meaning any runtime that gets the looping wrong will silently produce different output rather than erroring out. That raises the bar for trusting a third-party quantization or serving backend that hasn't been checked against the reference numbers.
Alternatives, if looping isn't your thing
Loop-9B's actual selling point is compute depth without parameter storage. Two other ways open models chase similar efficiency goals are worth knowing before you commit:
| Model | Efficiency approach | What you trade |
|---|---|---|
| SenseNova-Loop-9B | Reuse 24 of 32 layers for a second pass (looping) | Needs a runtime with loop support; benchmarks are vendor-reported |
| Qwen3.8-27B (SenseTime's own comparison point) | Larger dense model, no architectural trick | More memory and disk, but a conventional runtime works out of the box |
| Mixture-of-experts models (e.g. Qwen3's MoE variants) | Store many experts, activate a few per token | Big download, light per-token compute; different memory profile than looping |
Layer reuse itself isn't new research. Google's 2018 Universal Transformer paper explored looping transformer layers years before any production model shipped the idea at this scale; Loop-9B is one of the first widely distributed open-weight models to put that idea into a model you can actually download and run today.
The verdict: download it, but keep your benchmark suite handy
Install Loop-9B now if you're a developer who wants a free, Apache 2.0, self-hostable model with real long-context headroom (up to 512K tokens, with 256K comfortably fitting in 12 to 15 GiB of GPU memory) and you're willing to build a serving stack from an open pull request for a week or two until vLLM and SGLang support lands upstream. Grab the AWQ build if you're on a single consumer GPU; grab a GGUF quant if llama.cpp or Ollama is already your runtime of choice.
Wait, or at least don't bet a production decision on the benchmark numbers from SenseTime's own model card, if your use case depends on Loop-9B actually beating Qwen3.8-27B-class models rather than merely approaching them. Those scores are SenseTime's own, and the better move is to run your own task against both models before you pick one. Check back in a month: if an independent group reproduces the AIDABench or GAIA numbers, Loop-9B's efficiency pitch gets a lot more credible than it is on release day.