Nine billion parameters, billed like 56 layers: SenseTime open-sources Loop-9B, and its 4.9 GB weights fit on a consumer card
TL;DR
SenseTime released the production version of SenseNova Loop-9B on the evening of November 17. It ships under Apache 2.0, with weights on Hugging Face and code on GitHub, and it is cleared for commercial use.
The reason to look at it isn't a leaderboard crown. It's a different way to cut cost. Everyone else is adding parameters; this model keeps just 32 decoder layers and runs its middle 24 — layers 4 through 27 — twice using the same weights. One forward pass does the work of 56 layers while the GPU holds only 32 layers' worth of weights.
The arithmetic works out like this: about 9B total parameters, which SenseTime says is roughly 14.6B inference-equivalent. After 4-bit quantization the weights are about 4.9 GB. At a 256K context with an 8-bit KV cache, inference needs about 15 GiB of video memory. A 24 GB consumer card can max out the context window and still have room left over.
On scores it neither brags nor runs away with anything. AIDABench comes in at 65.31 against Qwen3.8-27B's 65.01 — a 0.3-point edge. AutomationBench is a flat tie at 36.67. NL2Repo lands at 41.36 against 44.60, a 3.24-point loss. The release page prints all three lines side by side without hiding the loss.
How it gets 56 layers out of 9B
The architecture matters because it drives every trade-off downstream.
Input passes through layers 0–3, then enters a looped block: layers 4 through 27, 24 layers that share weights and run twice in sequence, with the first pass's output feeding the second. After that come layers 28–31 and the output head. In notation, B(B(h)), where B is the looped block.
Three supporting pieces:
- Two-stream mHC. Inside the looped block, two residual streams carry hidden states in parallel. Learned mappings decide what each layer reads from each stream, how information mixes between them, and where output gets written back. The mixing matrix is constrained with Sinkhorn normalization over 20 iterations in the shipped configuration. SenseTime flags explicitly that those 20 iterations are internal mHC computation and are not the same thing as the two passes through the block — an easy conflation to make.
- Hybrid attention. Layers come in groups of four: three linear-attention layers followed by one full-attention layer. Loop boundaries align with complete four-layer groups, so both passes use an identical attention pattern.
- Specs. Hidden dimension 4,096; feed-forward dimension 12,288; vocabulary 248,320; 16 full-attention heads with 4 KV heads; BF16 backbone with FP32 mHC routing parameters.
The most informative section of the release is an ablation on loop count. Add loops during both training and inference and all four core tasks improve. AIDABench-QA and Workbuddy-office peak at three loops, gaining 6.42% and 16.93% over the single-pass baseline. LiveCodeBench V6 and AIDABench data visualization keep improving to four loops, gaining 8.10% and 8.55%. Going from two loops to four adds another 1.04 and 1.35 percentage points on code and data visualization respectively.
In other words, extra passes genuinely buy capability — you just pay a full pass of compute for each one. To keep inference economical, both the preview and the production release default to two loops, and SenseTime says a dynamic-loop architecture is next: pick the loop count based on task difficulty.
Three weak spots SenseTime admits to
The release page ends with a Current Limitations section that is unusually candid. These three items decide whether you should adopt it today:
- With many or complex tool definitions, or multiple conditional constraints, the model still misreads and mis-executes, which affects task outcomes directly.
- Coding has improved a lot over the preview and is practical for many jobs, but consistency on coding and general agent tasks remains a gap, and it needs extra self-correction steps to converge.
- Long-horizon tasks are still not stable. Sites with complex 3D scenes and heavy dynamic elements often don't finish in one round; expect two or three rounds of feedback.
So the not-a-good-fit list is clear: high-precision code refactors that must land in one shot, agent pipelines with many constraints, complex 3D interactive pages. It suits cost-sensitive work running on your own hardware where multi-round fixes are acceptable.
How to use it: three working paths and one dead end
SenseTime documents three deployment routes. The validated environment is Transformers 5.18.0, PyTorch 2.11.0 and CUDA 13.0. trust_remote_code=True is mandatory because the model implementation is custom.
- Load directly with Transformers. Point
AutoModelForCausalLM.from_pretrainedat a local directory or repo ID, setdtype=torch.bfloat16, and passenable_thinking=Falseto turn off thinking mode. - LightLLM. The official example uses four GPUs with
--tp 4and serves an OpenAI-compatible endpoint. - SGLang or vLLM. Both require the PR builds that contain the SenseNova Loop implementation: PR #47281 for SGLang, PR #64832 for vLLM.
The dead end is llama.cpp. SenseTime states plainly that this architecture won't run on llama.cpp and that GGUF support needs a dedicated implementation. For local users that's a hard gate — don't assume that a GGUF file means it will load.
Pitfall one: the memory math. The 4.9 GB figure is the weights themselves, not the disk space you need. On Hugging Face the AWQ repo's three safetensors shards total 5.59 GB, plus a separate 0.49 GB MTP draft model under mtp/.
Pitfall two: the main repo is gated. sensenova/SenseNova-Loop-9B, the BF16 repo, uses auto-approved gating — click through and you're in, but an unauthenticated fetch of its README returns 401. The AWQ (4-bit) and GGUF repos are fully open. Summing the BF16 shards gives roughly 19.3 GB across 12 files, so budget about 25 GB of local space.
Pitfall three: quantization versus engine. That vLLM PR supports only unquantized text inference, so it can't run the AWQ low-memory setup described above. To use AWQ you need the LightLLM or SGLang path.
Who it's for, and what it costs
- A good fit: individual developers with a 24 GB-class card who want long-context multimodal inference locally; teams that need on-premises deployment and can't absorb 27B-class memory costs; anyone researching looped computation, since Apache 2.0 covers commercial use and both code and weights are available.
- Not a good fit: teams expecting a drop-in replacement for a closed flagship; anyone committed to a one-command llama.cpp or Ollama launch; production systems that demand high long-horizon agent reliability.
On cost, the hardware floor is the real selling point: 4-bit weights with an 8-bit KV cache need roughly 10 GiB at 64K context, 12 GiB at 128K, and 15 GiB at 256K. On time, pulling the 5.6 GB AWQ weights takes minutes on ordinary home broadband; installing Transformers 5.18 and a PyTorch build matching CUDA 13 is the slow part, so confirm your CUDA version first.
Against models of similar size the trade-off is sharp: pay an extra pass to reach 27B-class behavior, accept higher latency and narrower engine support, and get memory down to roughly a third. That math works for batch inference and edge deployment; it may not for latency-critical interactive use.
Next steps
- First step: skip the BF16 repo. Grab the 4-bit weights from
sensenova/SenseNova-Loop-9B-AWQ— about 5.6 GB, no access request needed. - Run your own memory budget from the official table: 15 GiB for 256K context, 12 GiB for 128K, 10 GiB for 64K, plus about 2 GB for the runtime.
- For the shortest path, serve it with the LightLLM Docker image and call the OpenAI-compatible endpoint. If you write your own inference code, match
trust_remote_code=Trueand the 20-iteration Sinkhorn implementation exactly — otherwise output drifts silently. - Before shipping, test on your real workloads and watch the three admitted weak spots: multi-constraint tool calls, long-horizon consistency, and complex 3D pages.
Sources
- SenseTime release page (English): https://www.sensetime.com/en/news/sensenova-loop-9b-release-20261118-1435
- SenseTime release page (Chinese): https://www.sensetime.com/cn/news/sensenova-loop-9b-20261118-1059
- SenseTime official X post (2026-11-17T14:45:32Z): https://x.com/SenseTime_AI/status/2122702684985938356
- Hugging Face weights: https://huggingface.co/sensenova/SenseNova-Loop-9B
- GitHub repository: https://github.com/OpenSenseNova/SenseNova-Loop
- TechNode (2026-11-18): https://technode.com/2026/11/18/sensetime-releases-open-weight-loop-9b-model-that-reuses-layers-for-deeper-computation/
- PC Watch (2026-11-18): https://pc.watch.impress.co.jp/docs/news/2157448.html
- Yicai (2026-11-17): https://www.yicai.com/news/103444236.html