Most of the open-weight AI news lately has been about size. Bigger mixtures of experts, bigger context windows, bigger download folders. So it’s a nice change of pace that one of the more interesting releases this week goes the other way. SenseTime has put out SenseNova Loop-9B, a roughly 9-billion-parameter multimodal model that gets more “thinking” out of its small size by running the middle of its network twice.
The final release landed on Hugging Face on November 17 under the Apache 2.0 license. It replaces the Loop-9B Preview SenseTime shipped in late October. On November 18 the company added official GGUF and 4-bit AWQ builds, and those are the ones local AI folks will actually care about. The pitch is a model that fits on a mid-range gaming GPU and holds its own against models three times its size. Some of that pitch holds up. The rest still needs proving, and you’ll need some patience with the software side.
How the loop works
A normal transformer runs your prompt through each layer once and then it’s done. Loop-9B has 32 distinct decoder layers, but per the model card, layers 4 through 27 form a shared block that runs twice in a row, with the output of the first pass feeding into the second. That works out to 56 layer computations per forward pass while storing only 32 layers’ worth of weights. SenseTime describes the result as about 9B total parameters and about 14.6B “inference-equivalent” parameters.
Two other design choices sit on top of that. The decoder uses hybrid attention, with every group of four layers made up of three linear-attention layers and one full-attention layer. That’s a big part of why a 512K-token context window is practical on modest hardware. Inside the looped block, SenseTime uses what it calls two-stream manifold-constrained hyper-connections (mHC): two parallel residual streams, with learned mappings that decide how each layer reads from them, mixes them and writes back. The model takes text and images as input and outputs text.

The model card includes a loop-scaling experiment that’s honestly the most interesting part of the release. SenseTime took the same 9B model and varied how many times the block loops, holding training data constant. Performance went up across all four tasks it tested, with the best results at three or four loops. AIDABench-QA and an office task suite peaked at three loops, while LiveCodeBench V6 and AIDABench data visualization peaked at four. The shipped model still defaults to two loops to keep inference speed reasonable. SenseTime says it wants to explore “Dynamic Loop” designs that pick the loop count per input, which would let easy prompts stay cheap and hard ones get more compute.
On the benchmark side, the jump from the Preview is big on paper. SenseTime reports AutomationBench going from 14.33 to 36.67, Terminal-Bench 2.1 from 40.45 to 59.55 and GAIA from 37.86 to 69.90. Against Qwen3.8-27B, the release ties on AutomationBench at 36.67, edges ahead on AIDABench (65.31 vs. 65.01) and trails on NL2Repo (41.36 vs. 44.60). The company’s own chart also shows the 27B Qwen ahead on Terminal-Bench 2.1, 63.40 to 59.55. So “competitive with a 27B model” is fair for some tasks, but it doesn’t win across the board.
The big caveat: every one of these numbers is self-reported. As ORIENS points out in its coverage, none of them have been checked by a third party yet. Agent benchmarks are especially sensitive to the harness, prompts and tool setup, so I’d wait for community runs before treating any of this as settled.
Running it at home is not plug-and-play yet
The memory story is the real draw. SenseTime says the 4-bit weights take about 4.9 GB, and it publishes estimated minimum GPU memory figures. With an 8-bit KV cache, it lists about 10 GiB at 64K context, about 12 GiB at 128K and about 15 GiB at 256K. With a 4-bit KV cache, those drop to roughly 9, 10 and 12 GiB. In plain terms, a 12GB or 16GB graphics card is the sweet spot if you want long context. The GGUF repo lists file sizes of 5.82 GB for Q4_K_M, 6.67 GB for Q5_K_M, 9.8 GB for Q8_0 and 18.42 GB for full BF16, plus a separate 0.92 GB vision projector file for image input.
Keep in mind that smaller memory doesn’t mean faster. Because the middle block runs twice, each token costs more compute than a plain 9B model would. That’s what the 14.6B inference-equivalent figure is telling you. You’re trading speed for capability per gigabyte, and on a VRAM-limited card that’s often a good trade. Just don’t expect small-model speeds.

Then there’s the software. Because the looped architecture is new, mainstream tools don’t support it out of the box yet. The GGUF instructions tell you to build SenseTime’s own fork of llama.cpp rather than the upstream project. For server deployments, the card points to an open vLLM pull request and an open SGLang pull request. As of today, neither has been merged. Loading the full-precision weights in Transformers also requires trust_remote_code=True, which means running SenseTime’s custom model code. That’s normal for new architectures, but it’s worth knowing before you run it.
Access isn’t completely open either. The license is Apache 2.0, but the main BF16 repository is gated on Hugging Face, so you have to log in and accept the access conditions before downloading. When I checked the Hugging Face API, the GGUF and AWQ repos weren’t gated. SenseTime is also upfront about weak spots in its “Known Limitations” section: the model can miss requirements when it’s given lots of tool definitions or stacked constraints, its coding and agent performance “can be inconsistent,” and complex 3D or animation-heavy web pages may take two or three rounds of feedback. I appreciate a model card that says that out loud.
Loop-9B also isn’t the only small model trying this week. On November 17, OVHcloud announced Olala mini 7A1B, its first in-house LLM. It’s a 7B mixture-of-experts model with 1B active parameters across 256 experts per layer and hybrid Differential-TPA and Mamba-3 attention. OVH says it runs on GPUs with as little as 8 GB of memory, reaches 160 tokens per second on an RTX A4500 and does 50 tokens per second on a regular CPU. Its context window is a much shorter 32K tokens for now, with 128K promised for version 1.1 by the end of the year. OVH says the model will be on Hugging Face under Apache 2.0, and its formal launch is at the OVHcloud AI Summit on November 19. When I searched Hugging Face this afternoon, I couldn’t find the weights yet, so treat those speed claims as promises for now.
Cody’s take
I like this release more for the idea than the scoreboard. Looping layers to get more depth without more weights is a smart fit for the hardware most of us actually own, where VRAM runs out long before patience does. The loop-scaling data hints at a future where a small model can “think longer” on hard prompts instead of you downloading a bigger one. That’s a genuinely exciting direction for local AI.
But it’s early. The benchmarks are SenseTime’s own, the strongest claim (matching a 27B model) only holds on some tests, and right now you need a forked llama.cpp or unmerged vLLM and SGLang branches to run it. If you like tinkering and have a 12GB or 16GB card, the Q4_K_M GGUF is a fun weekend experiment. If you just want something that works in your usual app today, I’d wait for upstream support and some independent testing. Either way, I’m glad somebody is chasing efficiency instead of size.




