SenseNova-Loop-9B-Preview: A Looped Multimodal Model for Long-Context Work, and How to Run It

SenseNova-Loop-9B-Preview is a 9.66 billion parameter multimodal model released by SenseNova on October 28, 2026 under Apache 2.0. It takes text and images as input and produces text, and it is built for long-context tasks and agentic workflows. The architecture loops a shared block of 24 decoder layers twice per forward pass, producing 56 layer-executions per inference step from 32 distinct sets of weights.

Written by Priya Raghunathan, local-AI hardware reviewer. I verify parameter counts, licenses, hardware requirements, and every install command against the primary source before recommending a setup path.

A new top-20 entrant on Hugging Face's image-text-to-text list

SenseNova-Loop-9B-Preview entered the top 20 of Hugging Face's image-text-to-text trending list shortly after its October 28, 2026 release. At time of writing the model page shows 94 likes and 566 downloads, and the GitHub repository has 31 stars. The most-linked Space built on it is a VRAM and GPU cost calculator (16 likes), useful for estimating what hardware you actually need before you download 19 GB of weights.

Specs at a glance

How the looped architecture works

The model splits its 32 decoder layers into three sections. Layers 0 to 3 run once as a preamble. Layers 4 to 27, a block of 24 layers, run twice in sequence with shared weights. Layers 28 to 31 and the output head finish the pass. The second loop through the shared block takes the first loop's output as its input, so the model performs B(B(h)) where B is the repeated block and h is the state entering it.

This gives the model an execution depth equivalent to a 56-layer decoder while only storing 32 sets of layer weights. The design trades additional compute per token for a smaller parameter footprint, a useful property if you want more reasoning depth without proportionally larger model files.

Alongside the looped block, the model uses two-stream manifold-constrained hyper-connections (mHC) to route information between two parallel residual streams inside the looped section, and a hybrid attention pattern that alternates three linear-attention layers with one full-attention layer in every four-layer group.

24 decoder layers are applied twice in sequence, producing 56 decoder-layer executions from 32 distinct layers.

Install and run with Transformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "sensenova/SenseNova-Loop-9B-Preview"
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? Reply with the number only."}]
prompt = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True,
    enable_thinking=False,
)
inputs = tokenizer(prompt, return_tensors="pt").to(device)

with torch.inference_mode():
    outputs = model.generate(
        **inputs,
        max_new_tokens=256,
        do_sample=False,
        use_cache=True,
    )

response = tokenizer.decode(
    outputs[0, inputs.input_ids.shape[1]:],
    skip_special_tokens=True,
)
print(response)

The script above is the minimal path from the model card. trust_remote_code=True is required because the model uses a custom architecture (sensenova_loop) that isn't in the Transformers core at time of writing, so Transformers loads the model code from the downloaded repository files rather than from its own library. do_sample=False and enable_thinking=False give you greedy, deterministic output with no reasoning preamble; drop enable_thinking=False if you want the model's thinking mode instead.

Multi-GPU deployment with LightLLM

The model card documents a 4-GPU deployment path using LightLLM via Docker. This is the path to use if you are serving the model to multiple users or need throughput rather than just a one-off test.

SGLang deployment

SGLang support for SenseNova-Loop-9B-Preview requires a custom branch from an open pull request. The commands below follow the model card exactly.

What it is built for

The model card frames SenseNova-Loop-9B-Preview around three application areas: document understanding, coding, and interaction with external tools inside agentic workflows. The 262,144-token training context makes it practical for tasks that involve long documents or multi-step tool call sequences rather than just short chat turns.

The multimodal input (text plus images) means you can pass in screenshots, diagrams, or scanned pages alongside text instructions. The model generates text only, so image output is not part of this architecture.

Benchmarks reported in the model card cover BIRD-Dev, WorkBuddy Bench, AIDABench, TeamBench, Terminal Bench 2.1, T-Banking, AutomationBench, and RaccoonPPTBench, with results shown as a figure rather than a published table. Specific per-benchmark numbers are not listed in the README at time of writing.

License and use

SenseNova-Loop-9B-Preview ships under Apache 2.0, which allows commercial use, modification, and redistribution without a separate agreement. The technical report is listed as forthcoming (TBD) in the model card, so architecture details beyond what the README and config files contain are not yet published.

FAQ

What is SenseNova-Loop-9B-Preview?

A 9.66 billion parameter multimodal model from SenseNova that takes text and images as input and generates text. It uses a looped decoder that runs 32 distinct layers through 56 executions per forward pass, giving it an effective depth closer to a 56-layer model while storing far fewer weights.

How much VRAM does it need?

The model card does not specify a minimum. The BF16 weights alone are roughly 19 GB, so a 24 GB GPU is a practical starting point for single-card inference. The 4-GPU LightLLM deployment splits the load across four cards using tensor parallelism.

Does it support Chinese?

Yes. The model card lists English and Chinese as supported languages, and the README ships with a full Chinese translation.

What makes the looped architecture different?

Most transformer models run each layer once. SenseNova-Loop-9B-Preview runs layers 4 to 27 twice per forward pass with shared weights, so the model does more computation per token than a flat 9B model without storing a larger set of parameters. The tradeoff is slower inference per token compared to a shallower model of similar size.

Is it free for commercial use?

Yes. Apache 2.0 permits commercial use, modification, and redistribution without additional permission.

Where to go from here

• Compare it with other local multimodal models: the local AI model directory has specs side by side.
• Estimate VRAM and compute costs before downloading: the GPU cost calculator Space is the most-linked tool associated with this model.
• Browse other recent how-to guides: the how-to index lists them newest first.