Instructions to use sensenova/SenseNova-Loop-9B-GGUF with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Libraries
- Transformers
How to use sensenova/SenseNova-Loop-9B-GGUF with Transformers:
# Use a pipeline as a high-level helper from transformers import pipeline pipe = pipeline("image-text-to-text", model="sensenova/SenseNova-Loop-9B-GGUF", trust_remote_code=True)# pip install -U transformers accelerate # Load model directly from transformers import AutoModel model = AutoModel.from_pretrained("sensenova/SenseNova-Loop-9B-GGUF", trust_remote_code=True, device_map="auto") - Notebooks
- Google Colab
- Kaggle
- Local Apps Settings
- llama.cpp
How to use sensenova/SenseNova-Loop-9B-GGUF with llama.cpp:
Install (macOS, Linux)
curl -LsSf https://llama.app/install.sh | sh # Start a local OpenAI-compatible server with a web UI: llama serve -hf sensenova/SenseNova-Loop-9B-GGUF:Q4_K_M # Run inference directly in the terminal: llama cli -hf sensenova/SenseNova-Loop-9B-GGUF:Q4_K_M
Install from WinGet (Windows)
winget install llama.cpp # Start a local OpenAI-compatible server with a web UI: llama serve -hf sensenova/SenseNova-Loop-9B-GGUF:Q4_K_M # Run inference directly in the terminal: llama cli -hf sensenova/SenseNova-Loop-9B-GGUF:Q4_K_M
Build from source code
git clone https://github.com/ggml-org/llama.cpp.git cd llama.cpp cmake -B build cmake --build build -j --target llama-app # Start a local OpenAI-compatible server with a web UI: ./build/bin/llama serve -hf sensenova/SenseNova-Loop-9B-GGUF:Q4_K_M # Run inference directly in the terminal: ./build/bin/llama cli -hf sensenova/SenseNova-Loop-9B-GGUF:Q4_K_M
Use Docker
docker model run hf.co/sensenova/SenseNova-Loop-9B-GGUF:Q4_K_M
- Llama new
- LM Studio
- Jan
- vLLM
How to use sensenova/SenseNova-Loop-9B-GGUF with vLLM:
Install from pip and serve model
# Install vLLM from pip: pip install vllm # Start the vLLM server: vllm serve "sensenova/SenseNova-Loop-9B-GGUF" # Call the server using curl (OpenAI-compatible API): curl -X POST "http://localhost:8000/v1/chat/completions" \ -H "Content-Type: application/json" \ --data '{ "model": "sensenova/SenseNova-Loop-9B-GGUF", "messages": [ { "role": "user", "content": [ { "type": "text", "text": "Describe this image in one sentence." }, { "type": "image_url", "image_url": { "url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg" } } ] } ] }'Use Docker
docker model run hf.co/sensenova/SenseNova-Loop-9B-GGUF:Q4_K_M
- SGLang
How to use sensenova/SenseNova-Loop-9B-GGUF with SGLang:
Install from pip and serve model
# Install SGLang from pip: pip install sglang # Start the SGLang server: python3 -m sglang.launch_server \ --model-path "sensenova/SenseNova-Loop-9B-GGUF" \ --host 0.0.0.0 \ --port 30000 # Call the server using curl (OpenAI-compatible API): curl -X POST "http://localhost:30000/v1/chat/completions" \ -H "Content-Type: application/json" \ --data '{ "model": "sensenova/SenseNova-Loop-9B-GGUF", "messages": [ { "role": "user", "content": [ { "type": "text", "text": "Describe this image in one sentence." }, { "type": "image_url", "image_url": { "url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg" } } ] } ] }'Use Docker images
docker run --gpus all \ --shm-size 32g \ -p 30000:30000 \ -v ~/.cache/huggingface:/root/.cache/huggingface \ --env "HF_TOKEN=<secret>" \ --ipc=host \ lmsysorg/sglang:latest \ python3 -m sglang.launch_server \ --model-path "sensenova/SenseNova-Loop-9B-GGUF" \ --host 0.0.0.0 \ --port 30000 # Call the server using curl (OpenAI-compatible API): curl -X POST "http://localhost:30000/v1/chat/completions" \ -H "Content-Type: application/json" \ --data '{ "model": "sensenova/SenseNova-Loop-9B-GGUF", "messages": [ { "role": "user", "content": [ { "type": "text", "text": "Describe this image in one sentence." }, { "type": "image_url", "image_url": { "url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg" } } ] } ] }' - Ollama
How to use sensenova/SenseNova-Loop-9B-GGUF with Ollama:
ollama run hf.co/sensenova/SenseNova-Loop-9B-GGUF:Q4_K_M
- Unsloth Desktop
- Pi
How to use sensenova/SenseNova-Loop-9B-GGUF with Pi:
Start the llama.cpp server
# Install llama.cpp: brew install llama.cpp # Start a local OpenAI-compatible server: llama serve -hf sensenova/SenseNova-Loop-9B-GGUF:Q4_K_M
Configure the model in Pi
# Install Pi: npm install -g @earendil-works/pi-coding-agent # Add to ~/.pi/agent/models.json: { "providers": { "llama-cpp": { "baseUrl": "http://localhost:9931/v1", "api": "openai-completions", "apiKey": "none", "models": [ { "id": "sensenova/SenseNova-Loop-9B-GGUF:Q4_K_M" } ] } } }Run Pi
# Start Pi in your project directory: pi
- Docker Model Runner
How to use sensenova/SenseNova-Loop-9B-GGUF with Docker Model Runner:
docker model run hf.co/sensenova/SenseNova-Loop-9B-GGUF:Q4_K_M
- Lemonade
How to use sensenova/SenseNova-Loop-9B-GGUF with Lemonade:
Pull the model
# Download Lemonade from https://lemonade-server.ai/ lemonade pull sensenova/SenseNova-Loop-9B-GGUF:Q4_K_M
Run and chat with the model
lemonade run user.SenseNova-Loop-9B-GGUF-Q4_K_M
List all available models
lemonade list
- Hermes Agent
How to use sensenova/SenseNova-Loop-9B-GGUF with Hermes Agent:
Start the llama.cpp server
# Install llama.cpp: brew install llama.cpp # Start a local OpenAI-compatible server: llama serve -hf sensenova/SenseNova-Loop-9B-GGUF:Q4_K_M
Configure Hermes
# Install Hermes: curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash hermes setup # Point Hermes at the local server: hermes config set model.provider custom hermes config set model.base_url http://127.0.0.1:9931/v1 hermes config set model.default sensenova/SenseNova-Loop-9B-GGUF:Q4_K_M
Run Hermes
hermes
- Atomic Chat
- OpenClaw
How to use sensenova/SenseNova-Loop-9B-GGUF with OpenClaw:
Start the llama.cpp server
# Install llama.cpp: brew install llama.cpp # Start a local OpenAI-compatible server: llama serve -hf sensenova/SenseNova-Loop-9B-GGUF:Q4_K_M
Configure OpenClaw
# Install OpenClaw: npm install -g openclaw@latest # Register the local server and set it as the default model: openclaw onboard --non-interactive --mode local \ --auth-choice custom-api-key \ --custom-base-url http://127.0.0.1:9931/v1 \ --custom-model-id "sensenova/SenseNova-Loop-9B-GGUF:Q4_K_M" \ --custom-provider-id llama-cpp \ --custom-compatibility openai \ --custom-text-input \ --accept-risk \ --skip-health
Run OpenClaw
openclaw agent --local --agent main --message "Hello from Hugging Face"
- SenseNova-Loop-9B
- ๐ Architecture
- ๐ฃ News
- ๐ SenseNova-Loop-9B: Deeper Computation with Fewer Parameters
- ๐ฌ Showcase
- ๐ Model Performance: From Preview to Release
- ๐ง Model Architecture
- ๐ฌ Loop Scaling: Exploring the Benefits of Looped Computation
- ๐พ Low-Memory Deployment
- Get Started
- ๐๏ธ Training
- โ ๏ธ Known Limitations
- ๐ License and Citation
- ๐ Architecture
SenseNova-Loop-9B
English | ็ฎไฝไธญๆ
๐ Architecture
๐ฃ News
๐ฅ 2026-11-18: Added download links for the AWQ and GGUF weights.
๐ฅ 2026-11-17: We release SenseNova-Loop-9B, with model weights and code available to the community.
๐ฅ 2026-10-31: We release SenseNova-Loop-9B-Preview, with model weights and code available to the community.
๐ SenseNova-Loop-9B: Deeper Computation with Fewer Parameters
We officially release SenseNova-Loop-9B. Building on the Preview's exploration of parameter efficiency, the model reuses layer weights through a looped architecture and combines them with manifold-constrained hyper-connections (mHC) to expand computational depth within a compact parameter budget. It is designed for complex reasoning, coding, tool use, and multimodal tasks.
Since the Preview release, we have received community interest and feedback on model use, inference deployment, and ecosystem integration. The official release retains the looped architecture and two-stream mHC, further improving performance on agentic, coding, and data analysis tasks while continuing to explore the capabilities of looped computation.
SenseNova-Loop-9B has approximately 9B parameters. By repeatedly executing shared middle layers, it extends 32 physical decoder layers into 56 layer executions. The model accepts text and images and generates text, supporting long-context understanding and multi-step tasks. In agentic and data analysis evaluations, the model is competitive with Qwen3.8-27B: it scores 41.36 versus 44.60 on NL2Repo and 65.31 versus 65.01 on AIDABench.
Model Highlights
- Shared looped block: 24 decoder layers are executed twice in sequence, producing 56 layer computations from 32 distinct layers per forward pass.
- Two-stream mHC: learned mappings route and combine information between two residual streams within the looped block.
- Hybrid attention: the decoder interleaves linear and full attention in a repeating four-layer pattern.
- Long-context multimodal training: the training recipe includes text, images, code, and tool-use trajectories, with the context length extended to 512K tokens.
- Low-memory deployment: With 4-bit weights and an 8-bit KV cache, multimodal inference at a 256K context length requires approximately 15 GiB of GPU memory.
- Official quantized release: An official AWQ 4-bit version is available on launch day for easier deployment.
๐ฌ Showcase
3D
SVG + Web
Poster
Web
Design
๐ Model Performance: From Preview to Release
We evaluate SenseNova-Loop-9B on agentic, coding, and data analysis tasks, comparing the release with the Preview and other models.
The release outperforms the Preview on all seven benchmarks shown. AutomationBench rises from 14.33 to 36.67, Terminal-Bench 2.1 from 40.45 to 59.55, and GAIA from 37.86 to 69.90.
Compared with Qwen3.8-27B, the release matches its 36.67 on AutomationBench and scores 65.31 versus 65.01 on AIDABench. On NL2Repo, it scores 41.36 versus 44.60. Its BIRD score of 72.34 is 0.96 percentage points above the Preview's 71.38.
๐ง Model Architecture
SenseNova-Loop-9B is built on a 32-layer multimodal decoder combining shared-weight looped computation, hybrid attention, and two-stream manifold-constrained hyper-connections (mHC). It extends computation depth by reusing middle-layer parameters, accepts text and images, generates text, and supports a context length of up to 512K tokens.
Model Specifications
| Property | SenseNova-Loop-9B |
|---|---|
| Architecture | Autoregressive multimodal decoder; looped block with two-stream mHC |
| Parameter scale | Approximately 9B total parameters; approximately 14.6B inference-equivalent parameters |
| Input / output | Text and images / text |
| Distinct decoder layers | 32 |
| Looped layer range / passes | [4, 28) / 2, with 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 block of layers 4โ27 twice, and finally through layers 28โ31 and the output head. If B denotes the looped block and h its input, the looped computation can be written as B(B(h)).
During inference, each forward pass performs 56 decoder-layer computations while storing only 32 sets of decoder-layer weights. The looped block shares the same weights across both passes, with the output of the first pass serving as input to the second.
Hybrid Attention
The decoder interleaves linear attention and full attention. Each group of four layers contains three linear-attention layers followed by one full-attention layer. The loop boundaries align with complete four-layer groups, so both passes preserve the same attention pattern.
Two-Stream mHC
Within the looped block, mHC uses two residual streams to carry information around decoder-layer computations. Learned mappings determine how each layer reads from the streams, mixes information between them, and writes its output back to the residual state. The stream-mixing map is constrained with Sinkhorn normalization, using 20 iterations in the model configuration.
The two streams can be viewed as two sets of hidden states carried in parallel. A looped layer reads from the streams, applies attention or feed-forward computation, and writes its output back. Repeated row and column normalization constrains how information is mixed between the streams. These 20 normalization iterations are internal to mHC and are separate from the two passes through the looped block.
The loop range, number of passes, and mHC routing parameters together define the checkpoint's execution configuration. A compatible inference implementation must load these parameters and preserve the same computation order.
| Configuration | Value |
|---|---|
| Distinct decoder layers / executions | 32 / 56 |
| Looped layer range / passes | [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 promising performance scaling, offering another way to expand model capability through repeated computation. Using the original 9B model with a standard single forward pass (Loop 1) as the baseline, we vary the number of loops while holding the training data and other settings constant. Overall performance improves across the four tasks, with the best results at three or four loops. AIDABench-QA and Workbuddy-office peak at three loops, improving by 6.42% and 16.93% relative to the baseline; LiveCodeBench V6 and AIDABench data visualization peak at four loops, improving by 8.10% and 8.55%.
To balance inference efficiency, both the Preview and the release use two loops by default. Deeper loops nevertheless provide further gains: moving from two to four loops improves LiveCodeBench V6 by 1.04 percentage points and AIDABench data visualization by 1.35 percentage points. These experiments cover one to four loops, leaving the potential of deeper looping open for further study.
Different tasks respond differently to loop depth. We will continue exploring deeper computation and Dynamic Loop architectures that adapt the number of loops to each input, allocating computation according to task complexity.
๐พ Low-Memory Deployment
The shared looped architecture uses approximately 9B distinct parameters. With 4-bit weight quantization, the model weights occupy approximately 4.9 GB. Using an 8-bit or 4-bit KV cache can further reduce memory requirements for long-context inference. The estimated minimum GPU memory requirements for deployment are:
| Context length | 8-bit KV cache | 4-bit KV cache |
|---|---|---|
| 64K | ~10 GiB | ~9 GiB |
| 128K | ~12 GiB | ~10 GiB |
| 256K | ~15 GiB | ~12 GiB |
Get Started
Model Weights
| Weights | Download | Files |
|---|---|---|
| BF16 | Hugging Face ยท ModelScope | Release weights in Safetensors format |
| AWQ | Hugging Face | 4-bit AWQ weights and matching MTP draft |
| GGUF | Hugging Face | BF16, Q8_0, Q5_K_M, and Q4_K_M |
Serve GGUF with llama.cpp
Build OpenSenseNova/llama.cpp, then run llama serve with the Hugging Face model ID and the Q4_K_M quantization tag.
llama serve -hf sensenova/SenseNova-Loop-9B-GGUF:Q4_K_M \
-ngl 99 -c 4096 --port 8000
Text Generation with Transformers
Use Transformers to load the model from a Hugging Face repository or a local model directory. The examples below cover single-GPU text generation and serving with inference engines.
Requirements
The checked Preview environment uses Transformers 5.18.0, PyTorch 2.11.0, and CUDA 13.0. The model directory must include the configuration, tokenizer, chat template, custom model code, and all weight shards.
First install a CUDA-compatible build of PyTorch, then install the remaining dependencies:
python -m pip install "transformers==5.18.0" accelerate safetensors
Set model_id to the release model directory or repository ID, then run:
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
model_id = "/path/to/SenseNova-Loop-9B"
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?"}]
prompt = tokenizer.apply_chat_template(
messages,
tokenize=False,
add_generation_prompt=True,
enable_thinking=True,
)
inputs = tokenizer(prompt, return_tensors="pt").to(device)
with torch.inference_mode():
outputs = model.generate(
**inputs,
max_new_tokens=512,
do_sample=False,
use_cache=True,
)
response = tokenizer.decode(
outputs[0, inputs.input_ids.shape[1]:],
skip_special_tokens=True,
)
print(response)
The example enables thinking mode, uses greedy decoding, and generates up to 512 new tokens. Set enable_thinking to False to disable thinking, or change device to select a GPU. trust_remote_code=True loads the custom SenseNova Loop model implementation.
Deployment
BF16 deployment examples
The following commands are adapted from the Preview deployment examples. Replace the model path with the release checkpoint directory; the release engine versions and configurations will be updated with the model.
LightLLM
Four-GPU deployment example:
docker pull ghcr.io/modeltc/lightllm:main
docker run --rm --gpus all --ipc=host -p 8000:8000 \
-v /path/to/SenseNova-Loop-9B:/model \
-e LOADWORKER=4 -e LIGHTLLM_TRITON_AUTOTUNE_LEVEL=1 \
ghcr.io/modeltc/lightllm:main \
python -m lightllm.server.api_server \
--model_dir /model --model_name SenseNova-Loop-9B \
--tp 4 --host 0.0.0.0 --port 8000
Once the service is running, send an OpenAI-compatible request:
curl http://localhost:8000/v1/chat/completions \
-H 'Content-Type: application/json' \
-d '{"model": "SenseNova-Loop-9B", "messages": [{"role": "user", "content": "Hello!"}], "max_tokens": 128}'
SGLang
Use the version from SGLang PR #47281, which includes the SenseNova Loop implementation, and replace the model path:
git clone https://github.com/sgl-project/sglang.git
cd sglang
git fetch origin pull/47281/head
git checkout -b sensenova-loop FETCH_HEAD
python -m pip install -e ./python
sglang serve --model-path /path/to/SenseNova-Loop-9B
vLLM
Use the version from vLLM PR #64832, which includes the SenseNova Loop implementation, and replace the model path:
git clone https://github.com/vllm-project/vllm.git
cd vllm
git fetch origin pull/64832/head
git checkout -b sensenova-loop FETCH_HEAD
python -m pip install -e .
vllm serve /path/to/SenseNova-Loop-9B \
--served-model-name sensenova_loop \
--tensor-parallel-size 4 \
--dtype bfloat16
Inference Acceleration
SenseNova-Loop supports MTP speculative decoding. DSpark and DFlash2 draft model training instructions are available in SenseSpec; available release draft weights and launch settings will be updated with the model.
๐๏ธ Training
For model fine-tuning, refer to the SenseNova-Loop examples in OpenSenseNova/torchtitan.
Training scripts for DSpark and DFlash2 speculative decoding draft models are available in OpenSenseNova/SenseSpec.
โ ๏ธ Known Limitations
Given its size and development time, SenseNova-Loop-9B has room for improvement in the following areas:
- Complex instruction following: The model may misunderstand or miss requirements when given many complex tool definitions or multiple constraints.
- Coding and general agent tasks: Performance can be inconsistent on coding and general agent tasks. The model can correct some errors through additional steps, but its ability to handle complex, long-horizon tasks still needs improvement.
- Complex web generation: Websites with complex 3D scenes and rich animations may not be completed in a single turn. Some examples require user feedback and two to three rounds of refinement.
We will continue to improve the model and plan to apply the Loop architecture to larger models in the future. We welcome community feedback and reports of issues.
๐ License and Citation
The model project is licensed under the Apache License 2.0.
- Downloads last month
- -
4-bit
5-bit
8-bit
16-bit







