# SenseNova Loop-9B: SenseTime's 9B model that runs its layers twice


SenseTime released SenseNova Loop-9B on November 17, 2026: an open-weights multimodal model with about 9 billion parameters that gets depth by reusing layers instead of adding them. The middle 24 of its 32 decoder layers share weights and execute twice, so each forward pass performs 56 layer computations while the weights stay small enough that the official 4-bit build is about 4.9 GB. SenseTime's own benchmarks put it near Qwen3.8-27B, a model with three times the parameters, and the memory table says 256K context inference fits in roughly 15 GB of GPU memory. The weights carry an Apache 2.0 tag but sit behind a gated Hugging Face download. Here is what is actually new, what is vendor claim, and what I could not verify.

#### What SenseTime actually shipped

The official release follows the SenseNova-6.8-Loop-9B-Preview from October 31 by about two and a half weeks. Weights and code are on Hugging Face and ModelScope, with the repository under OpenSenseNova on GitHub. Three weight formats are available: BF16 release weights in Safetensors, an AWQ 4-bit quantization with a matching MTP draft, and GGUF builds in BF16, Q8_0, Q5_K_M and Q4_K_M. The AWQ and GGUF downloads were added on November 18, a day after launch. The model takes text and images in, produces text, and supports up to 512K tokens of context.

#### The loop architecture, in plain terms

The decoder has 32 distinct layers. Input passes through the first 4, then through the middle 24 layers twice in a row using the same weights, then through the last 4. That gives 56 layer executions per forward pass with storage for only 32 layers, which SenseTime describes as about 14.6B inference-equivalent parameters from roughly 9B stored ones. Two more choices matter for builders. First, dual-stream manifold-constrained hyper-connections (mHC): learnable mappings, kept in FP32, route and fuse information between two residual streams inside the loop block. Second, hybrid attention: the decoder works in groups of four layers, three linear-attention layers and one full-attention layer, which is part of how 512K context stays affordable on memory.

#### The benchmark claims, labeled as vendor claims

All numbers here are SenseTime's self-reported results from the model card and release post; I found no independent evaluations yet. Against its own Preview, the release improves on all seven benchmarks SenseTime shows: AutomationBench 14.33 to 36.67, Terminal-Bench 2.1 40.45 to 59.55, GAIA 37.86 to 69.90, and BIRD 71.38 to 72.34. Against Qwen3.8-27B: NL2Repo 41.36 versus 44.60, AIDABench 65.31 versus 65.01, and a tie at 36.67 on AutomationBench. Treat these as directional, not proven. The selection of benchmarks is SenseTime's, and a GAIA jump from 37.86 to 69.90 between preview and release is large enough that I would want third-party replication before relying on it.

#### What it costs to run

The shared-loop structure is the whole deployment story. SenseTime's published minimum memory table, with 4-bit weights:

| Context length | 8-bit KV cache | 4-bit KV cache |
| --- | --- | --- |
| 64K | about 10 GiB | about 9 GiB |
| 128K | about 12 GiB | about 10 GiB |
| 256K | about 15 GiB | about 12 GiB |

That puts long-context multimodal inference on a single consumer or workstation GPU, or a small cloud instance, instead of a multi-GPU node. The GGUF builds mean llama.cpp-class tooling should work without conversion.

#### The open-source caveat

The repository is tagged Apache 2.0, and the model card is public. But the weight files are gated: Hugging Face requires you to log in and agree to share your account information before downloading (gated=auto in the public API, as third-party coverage of the launch confirmed). Apache 2.0 terms with a gated download is still far better than a research-only license, but if your pipeline assumes anonymous artifact pulls, plan for a token and an accepted gate.

#### Limitations SenseTime admits itself

The release post lists three, unusually candid for a launch. With numerous or complex tool definitions, or multiple conditional constraints, the model can misinterpret and mis-execute in ways that hurt task performance. Coding and general agent work improved a lot over Preview but stays inconsistent; the model can correct itself with extra steps, yet complex long-horizon tasks need more refinement. And complex web generation with 3D scenes or heavy dynamic elements often takes two to three feedback rounds. In other words: the benchmark gains in agentic tasks come with an explicit warning about agentic reliability.

#### Why this matters for builders

Two trends worth tracking meet here. First, parameter efficiency through recurrence: looping shared layers is a different lever from distillation or MoE for getting more compute per stored gigabyte, and Loop-9B is the most concrete open data point this month for how far that lever goes. Second, the floor for serious local agentic models keeps dropping: a 27B-class vendor claim at 10 to 15 GB of memory with 256K context was a datacenter workload not long ago. Whether Loop-9B holds up outside SenseTime's benchmark selection is exactly what the next few weeks of community evals will show.

### What is SenseNova Loop-9B?

SenseTime's official open-weights release from November 17, 2026: a multimodal model of about 9B parameters that accepts text and images, outputs text, supports 512K context, and reuses 24 shared layers twice to reach 56 layer computations per forward pass. It succeeds the Loop-9B Preview from October 31.

### How does the loop architecture work?

Of 32 decoder layers, the middle 24 share weights and run twice in sequence, so one forward pass performs 56 layer computations while storing 32 layers. Dual-stream mHC mappings in FP32 route information between two residual streams, and attention is hybrid: three linear-attention layers plus one full-attention layer per four-layer group.

### How much GPU memory does SenseNova Loop-9B need?

Per SenseTime's table with 4-bit weights: about 10 GiB at 64K context with an 8-bit KV cache, about 12 GiB at 128K, and about 15 GiB at 256K. A 4-bit KV cache trims roughly 1 to 3 GiB more. The AWQ 4-bit weights themselves are about 4.9 GB.

### Is SenseNova Loop-9B really open source?

The license is Apache 2.0 and the card and code are public, but the Hugging Face weight files are gated: you must log in and agree to share account information before downloading. Practical access is easy, anonymous CI pulls are not.

### How does it compare to Qwen3.8-27B?

Only on SenseTime's own numbers so far: NL2Repo 41.36 versus 44.60, AIDABench 65.31 versus 65.01, and a tie at 36.67 on AutomationBench. That is near-parity on the vendor's chosen agentic and data-analysis benchmarks, with about a third of the parameters. Independent comparisons do not exist yet.

### What are the admitted limitations?

SenseTime lists shaky interpretation when tool definitions or constraints get complex, inconsistent coding and agent performance on long-horizon tasks, and multi-round fixes needed for complex web generation. These are the vendor's words, and they line up with what you should test first.

### Should I switch my local stack to SenseNova Loop-9B?

Not on launch-week evidence. If you already run a 27B-class local model for agentic or data work, Loop-9B is worth a weekend benchmark on your own tasks because the memory savings are real and the GGUF builds lower the cost of trying. Wait for independent evals before putting it in anything production.

## Sources

- SenseTime release post: https://www.sensetime.com/en/news/sensenova-loop-9b-release-20261118-1435
- Hugging Face model card: https://huggingface.co/sensenova/SenseNova-Loop-9B
- Hugging Face collection: https://huggingface.co/collections/sensenova/sensenova-loop
- GitHub repository: https://github.com/OpenSenseNova/SenseNova-Loop
