SenseNova Loop-9B Official Release: Deeper Computation with Fewer Parameters
SenseTime has officially released SenseNova Loop-9B. Building on the Preview version’s exploration of parameter efficiency, the model reuses layer parameters through a Loop structure and incorporates manifold-constrained hyper-connections (mHC) to extend computational depth with approximately 9B parameters, supporting complex reasoning, coding, tool use and multimodal tasks. Thanks to its efficient looping architecture, the official 4-bit quantized weights occupy only about 4.9GB, with deployment GPU memory requirements as low as under 10GB. This significantly broadens the range of compatible hardware, making it possible for chips with limited GPU memory to deliver performance comparable to leading 27B-class models.
Since the Preview release, we have received considerable community interest and feedback on model usage, inference deployment and ecosystem integration. The official release retains the Loop and dual-stream mHC architecture, further improves performance on agent, coding and data analysis tasks, and continues to explore how looped computation can enhance model capabilities.
SenseNova Loop-9B has approximately 9B parameters in total. By executing shared intermediate layers twice, it expands 32 physical decoder layers into 56 layer computations. The model accepts text and image inputs, produces text outputs, and supports a context length of up to 512K tokens. In agent and data analysis evaluations, it demonstrates competitiveness comparable to Qwen3.8-27B: its NL2Repo score of 41.36 approaches Qwen3.8-27B’s 44.60, while its AIDABench score of 65.31 exceeds the latter’s 65.01.
Model Highlights
Shared loop module: Layers 4–27 form a weight-sharing loop module that runs twice, enabling 56 decoder-layer computations in a single forward pass.
Dual-stream mHC: Learnable mappings route and fuse information across two residual streams within the loop module.
Hybrid attention: The decoder uses groups of four layers, combining three linear-attention layers with one full-attention layer.
Long-context multimodality: The training regimen covers text, images, code and tool-use trajectories, extending context length to up to 512K tokens.
Resource-efficient on-premises deployment: With 4-bit weight quantization and an 8-bit KV cache, inference at a 256K context length requires approximately 15 GiB of GPU memory, lowering the barrier to local and on-premises deployment.
Official quantization available on day zero: An official AWQ 4-bit quantized version is available from launch day for rapid deployment.
SenseNova Loop-9B model weights and related code are now available for developers and researchers to download, deploy and explore.
Model Capabilities: Further Improvements over Preview
We evaluated the official SenseNova Loop-9B release on general-purpose agent, coding and data analysis tasks, comparing it with the Preview version, Qwen3.8-27B and other models.

The results show clear improvements over Preview across multiple benchmarks. With approximately 9B parameters, the official release delivers performance on par with Qwen3.8-27B.
The Model in Action
The following examples demonstrate the official SenseNova Loop-9B release in real-world scenarios. (Note: All showcases below were created by this model in Codex / Hermes through 1–4 rounds of user interaction.)
Creating an Animated Poster Website for the DISTORTION FM Music Festival

Prompt: Create an animated poster website for the DISTORTION FM music festival. Use oversized condensed headlines and a palette of lime green, black and warm white. Compress, offset and rearrange typography; bring background text forward to obscure the screen before revealing a new chapter. Clicking among three performance chapters should switch between rhythmic full-screen compositions, with loop and pause controls. Keep small Chinese performance details legible and label the fictional event as a concept design. Reference the typographic transition concept at @url:https://tympanus.net/Development/KineticTypePageTransition/ and create an original implementation.
Creating an Interactive Website for the TYPE RELAY Experimental Typography Exhibition

Prompt 1: Create an interactive website for an experimental typography exhibition called TYPE RELAY. Make typography itself the focus of page transitions: as users switch among the three exhibition chapters, Form, Sound and Meaning, oversized Chinese characters and Latin letters should carry one chapter naturally into the next through rhythmic movement, changes in scale and rearrangement, like a continuous typographic performance. Give each chapter its own content, colors and composition, combining a strongly experimental character with a clear reading hierarchy. Design an original visual language, transition choreography and interaction details, and build a complete, functional website that users can interact with in a browser.
Prompt 2: Continue developing TYPE RELAY according to the detailed requirements below, refining the visuals and transitions:
Create an original website for the TYPE RELAY experimental typography exhibition, with three switchable chapters: Form, Sound and Meaning. The core experience is a full-screen transition driven by oversized typography, with the aesthetic of avant-garde graphic design and a kinetic typography short film.
Each chapter must have a complete, distinct composition: oversized Chinese and English headlines, concise exhibition copy, a visually striking hero image or original graphic, and minimal navigation. Establish hierarchy through strong type-size contrasts, partially cropped elements extending beyond the viewport, asymmetric layouts and precise use of negative space. Choose the color palette and font pairings yourself.
Transitions triggered by clicking a chapter should have three stages:
The current content exits briskly, and the chapter keyword rapidly enlarges. Multiple lines of the same word gradually fill the screen.
Lines of text sweep across the screen in different directions with staggered timing, creating rhythmic occlusion. The background color simultaneously takes over, and the chapter switches at the point of maximum occlusion.
The typographic array continues moving and exits. The new chapter’s headline, main visual and description appear in sequence, settling into a clearly readable layout.
Transitions should last approximately 1.5–2 seconds, with distinct anticipation, acceleration and resolution rather than constant-speed sliding. Carefully choreograph the text’s movement paths, line spacing, scale and layering to create both impact and order. Maintain visual continuity throughout; the next chapter should not appear abruptly.
The three chapters should share a visual language while differing in structure, rhythm and negative space. Support forward and backward navigation, handle animation states correctly during repeated clicks, and preserve complete compositions when the window is resized. Build a working website that can be used directly in a browser.
Creating Beyond the Coastline: A Photography Magazine-Style HTML Website

Prompt: Create Beyond the Coastline, a photography magazine-style HTML short-form website. Use off-white and deep black, oversized serif type, restrained Chinese captions and genuinely high-quality coastal photographs. Embed the opening seascape within gaps in the typography, expand it to full screen on scroll, and then flow through three chapters: Wind, Rocks and Tides. Use precise negative space and scrolling rhythm between images and text. Reference the image-and-type expansion relationship at tympanus.net/Development/ImageExpansionTypography. You may use publicly available images that can be used legally, save them locally and credit their sources; do not substitute gradient blocks for photography.
Model Architecture
SenseNova Loop-9B is built on a 32-layer multimodal decoder that combines weight-sharing looped computation, hybrid attention and dual-stream manifold-constrained hyper-connections (mHC). Reusing intermediate-layer parameters extends computational depth. The model supports text and image inputs, text outputs, and a context length of up to 512K tokens.
Model Specifications
Item | SenseNova-Loop-9B |
Architecture | Autoregressive multimodal decoder; dual-stream mHC in the loop module |
Parameter count | Approximately 9B total parameters; approximately 14.6B inference-equivalent parameters |
Input / Output | Text and images / Text |
Distinct decoder layers | 32 |
Loop layer range / Executions | [4, 28) / 2 executions, shared weights |
Decoder-layer executions | 56 per forward pass |
mHC residual streams | 2 |
Context length | 512K tokens |
Weight precision | BF16 backbone; FP32 mHC routing parameters |
Looped Decoder
Inputs first pass through layers 0–3, then through the same set of layers 4–27 twice. Layers 28–31 and the output head then produce the model output. Denoting the loop module by B and its input by h, the looped computation can be written as B(B(h)).
During inference, each forward pass performs 56 decoder-layer computations while storing weights for only 32 decoder layers. The loop module reuses the same weights in both executions, with the output of the first serving as the input to the second.
Hybrid Attention
The decoder interleaves linear-attention and full-attention layers. Each group of four contains three linear-attention layers followed by one full-attention layer. The loop module’s boundaries align with complete four-layer groups, preserving the same attention pattern in both executions.
Dual-Stream mHC
Within the loop module, mHC uses two residual streams to carry information before and after decoder-layer computation. Learnable mappings determine how each layer reads the streams, mixes information between them, and writes layer outputs back to the residual state. The inter-stream mixing mapping is constrained through Sinkhorn normalization, configured for 20 iterations.
The two residual streams can be understood as two sets of hidden states propagated in parallel: each looped layer reads from the residual streams, performs attention or feed-forward computation, and writes the results back. Repeated row and column normalization of the inter-stream mixing matrix constrains how information mixes between the streams. These 20 normalization iterations are internal mHC computations and are distinct from the two executions of the loop module.
The loop layer range, execution count and mHC routing parameters together define the execution configuration of the model checkpoint. A compatible inference implementation must load these parameters and preserve the same computation order.
Configuration | Value |
Distinct decoder layers / Layer executions | 32 / 56 |
Loop layer range / Executions | [4, 28) / 2 |
Hidden dimension | 4,096 |
Feed-forward dimension | 12,288 |
Vocabulary size | 248,320 |
Full-attention heads / KV heads | 16 / 4 |
mHC residual streams / Sinkhorn iterations | 2 / 20 |
Loop Scaling: Exploring the Benefits of Looped Computation

Looped Transformers show strong potential for performance scaling, introducing looped computation as a new dimension for improving model capabilities. Using the original 9B model—Loop 1 in the chart, corresponding to a standard single forward computation—as the baseline, we explored loop scaling while holding the training data and other settings constant. Increasing the number of loops during both training and inference improved performance across all four core tasks. AIDAbench-QA and Workbuddy-office performed best at three loops, improving by 6.42% and 16.93%, respectively, over the 9B baseline. LiveCodeBench V6 and AIDAbench-data_visualization improved further at four loops, delivering gains of 8.10% and 8.55%, respectively.
To balance inference efficiency in practical applications, both the current Preview and official release default to two loops. Nevertheless, deeper looping continues to yield performance gains. On two relatively complex tasks, code generation (LiveCodeBench V6) and data visualization (AIDAbench-data_visualization), increasing the loop count from two to four raises scores by a further 1.04 and 1.35 percentage points, respectively. These results validate the effectiveness of Loop Scaling and suggest that the current experiments with one to four loops are only a starting point: the capabilities available at greater loop depths warrant further exploration.
The experiments also reveal substantial differences in the loop depth required by different types of tasks. Building on this observation, future research will explore the capabilities of deeper loops and focus on a Dynamic Loop architecture. This architecture aims to adaptively select the optimal number of loops based on task complexity, allocating sufficient computation to complex tasks while maintaining overall inference efficiency.
Deployment on Hardware with Limited GPU Memory
Thanks to its looped weight-sharing structure, the model requires only approximately 9B distinct parameters, with 4-bit quantized weights occupying about 4.9GB. This substantially lowers hardware requirements for local and on-premises deployment. An 8-bit or 4-bit KV cache can further reduce GPU memory requirements for long-context inference. The table below shows minimum deployment memory requirements at different KV quantization precisions:
Context length | 8-bit KV | 4-bit KV |
64K | Approx. 10 GiB | Approx. 9 GiB |
128K | Approx. 12 GiB | Approx. 10 GiB |
256K | Approx. 15 GiB | Approx. 12 GiB |
Current Limitations and Ongoing Improvements
Although the Loop Transformer architecture has demonstrated considerable potential, model size and development time mean that SenseNova Loop-9B still has room for improvement in the following areas:
With numerous or complex tool definitions, or multiple conditional constraints, the model may still make interpretation and execution errors that affect task performance.
Coding capabilities have improved substantially over Preview and are now practical for many uses. However, consistency on coding and general-purpose agent tasks remains an area for improvement, although the model can correct its mistakes through additional steps. Overall, its ability to handle complex, long-horizon tasks requires further refinement.
High-quality websites with complex 3D scenes and rich dynamic elements may not be completed in a single round. Some examples require 2–3 rounds of fixes informed by user feedback to achieve good results.
We will continue addressing these limitations and plan to apply the Loop architecture to larger models. We aim to release model updates more frequently in response to real-world needs, and welcome community feedback, examples of issues and suggestions for improvement.
Getting Started with SenseNova Loop-9B
Model weights and related code are now available. Developers can load the model from a Hugging Face repository or a local model directory.
Hugging Face repository: https://huggingface.co/collections/sensenova/sensenova-loop
The examples below demonstrate text generation on a single GPU and how to launch a service using inference engines.
Environment Requirements
The environment validated for Preview uses Transformers 5.18.0, PyTorch 2.11.0 and CUDA 13.0. The model directory must contain the configuration, tokenizer, chat template, custom model code and all weight shards.
First install a PyTorch version compatible with your CUDA environment, then install the remaining dependencies:
bash |
Generating Text with Transformers
Replace model_id with the official release model directory or repository ID, then run the following code:
python |
The example enables thinking mode by default, uses greedy decoding and generates up to 512 new tokens. Set enable_thinking to False to disable thinking mode, and change device to select a GPU. trust_remote_code=True loads the custom SenseNova-Loop model implementation.
Model Deployment
The following commands are based on the Preview deployment examples. Replace the model path with the official release weights directory. The engine versions and configurations for the official release will be updated alongside the release.
LightLLM
The following example deploys the model across four GPUs:
bash |
Once the service is running, send requests through the OpenAI-compatible API:
bash |
SGLang
Use the version corresponding to SGLang PR #47281, which includes the SenseNova Loop implementation, and replace the model path:
bash |
vLLM
Use the version corresponding to vLLM PR #64832, which includes the SenseNova Loop implementation, and replace the model path. This PR currently supports only unquantized text inference and does not support the AWQ 4-bit low-memory configuration described above:
bash |
Open Model Weights and Source Code
GitHub: https://github.com/OpenSenseNova/SenseNova-Loop
Hugging Face:https://huggingface.co/collections/sensenova/sensenova-loop