SenseNova Loop 9B Hands-On: Looped Multimodal Model Tested
SenseNova Loop 9B tested on handwritten math, physics diagrams, invoices, and SQL generation. Here's how accuracy and VRAM use actually hold up.
What is SenseNova Loop 9B?
SenseNova Loop 9B Preview is an open-weight multimodal model from SenseNova that takes text and images as input and produces text output. It targets document reading, code generation, and agentic workflows that involve tool use and long context. Despite having roughly 9 billion stored parameters, it runs with the effective depth of a much larger network by reusing a block of layers twice during inference, an architecture the model card calls a looped decoder. It is released under the Apache 2.0 license on Hugging Face, and it is explicitly labeled a preview, not a finished production model.
TL;DR
- Looped execution means a block of 24 decoder layers (layers 4 through 27) runs twice with shared weights, giving 56 total decoder-layer computations from only 32 distinct layers, so the model gets extra depth without extra stored parameters.
- Hands-on testing across handwritten math, a physics beam diagram, a scanned invoice, and SQL generation found the outputs correct in every case, with only minor slips in reasoning presentation, not final answers.
- VRAM usage sat around 18.5 GB for a long-horizon multimodal task on an A6000, which is a reasonable footprint for a model doing document OCR plus multi-step reasoning.
- Inference speed is the weak point: the invoice-parsing test ran at about two tokens per second even with flash attention and the documented prerequisites in place, taking over three minutes for one response.
- Two-stream mHC (manifold-constrained hyper-connections) routes information through two residual streams with a learned mixer, which the architecture relies on to keep the looped section from degrading as information passes through twice.
- The model is Apache 2.0 licensed and ships with deployment paths for Transformers, LightLLM, SGLang, and vLLM, though some of those integrations (like the vLLM and SGLang support) exist as open pull requests rather than merged, stable releases.
- Benchmarks and inference acceleration features (MTP, Dspark, Dflash2) are still in progress, which fits the preview label and likely explains some of the slowness.
How does the looped architecture actually work?
Normal transformer language models are a stack of layers that data passes through exactly once, top to bottom. SenseNova Loop 9B changes that for its middle section. According to the model card, the decoder has 32 distinct layers total. The first four layers (0 through 3) run once, the last four (28 through 31) run once, and the middle block of 24 layers (4 through 27) runs twice in sequence with the same shared weights. The second pass takes the first pass’s output as its input. That produces 56 decoder-layer executions per forward pass while only storing weights for 32 layers.
The intuition is something like rereading a dense paragraph with the same brain: the second pass has more context to work with than the first, without needing a separate set of weights to do it. This gets you depth comparable to a larger model while keeping the parameter count, and the memory needed to store it, closer to a 9B model (the card lists about 9B backbone parameters and roughly 14.6B inference parameters once the looped execution is accounted for).
The decoder also interleaves attention types: each four-layer group contains three linear-attention layers followed by one full-attention layer, and the loop boundaries are aligned so this pattern holds across both passes.
What is mHC and why does it matter?
The second architectural piece is two-stream manifold-constrained hyper-connections, or mHC. Instead of one residual stream carrying information through the network, the looped section carries two streams side by side. A learned mixer decides how much of each stream to blend at each layer, constrained by Sinkhorn normalization (the documented configuration uses 20 iterations). The purpose is to keep information flowing cleanly as it goes around the loop twice, rather than degrading or collapsing the way a naive “just run the same layers again” approach might. This is what lets the model double up on computation in the middle block without the second pass becoming redundant or unstable.
How did it perform on real tasks?
In hands-on testing, the model was run locally and given a mix of multimodal tasks designed to probe document understanding, scientific reasoning, and code generation.
On a handwritten math test, the model was shown a messy photo of two equations with crossed-out scribbles and asked to read, solve, and explain each step. It read the handwriting correctly, factored both equations, arrived at the right answers (independently verified with a judge model), and correctly noted the crossed-out portion separately rather than trying to solve it.
On a physics test, it was given a diagram of a beam resting on two supports with small math labels, and asked to work out the vibration equations. It read every label correctly, correctly identified the supports as pinned (meaning the beam is simply supported), and arrived at natural frequencies and mode shapes matching standard textbook results. The middle steps of the derivation were described as a bit shaky in presentation, though the final answer was correct.
On an invoice parsing test, it converted a scanned invoice into structured JSON, correctly extracting names, addresses, all three line items, and every total, while also verifying that the math added up. The output quality was high, but this test exposed the speed issue: around two tokens per second on an A6000 GPU, taking over three minutes for a single response even with flash attention and the documented setup in place.
On a SQL generation test, it was asked to translate a plain-English question involving joins, a date filter, grouping, and a top-three result into a real SQL query. It joined all three tables correctly, filtered to completed 2023 orders, used distinct order counts to avoid double-counting, and grouped by customer ID instead of customer name, a detail an experienced SQL developer would get right but a weaker model might miss.
On a workflow diagram test involving a busy document with two parallel processing pipelines and small labels, it correctly followed both pipelines in order, from PDF parsing through OCR, layout analysis, and table structuring to final document assembly, and explained each step in plain language. It made one mistake: treating a merge-and-export step as part of only one pipeline, when both pipelines actually combine into a single document before export.
How much VRAM and compute does it need?
During the physics diagram test, VRAM usage on the test GPU settled at about 18.5 GB once the model was fully loaded for a multimodal, long-horizon task. That is a workable footprint for a 9B-class model doing document-level reasoning, and well within range for a single high-memory consumer or workstation GPU (the testing was done on an A6000).
Speed is the catch. The invoice test ran at roughly two tokens per second, a rate that made a single structured-extraction response take over three minutes, even with flash attention variants and the model card’s documented prerequisites satisfied. Two of the model’s listed inference acceleration features, Dspark and Dflash2, are still described as “training in progress” on the model card, and only MTP (multi-token prediction) is currently available. That likely explains a meaningful chunk of the slowness, and suggests throughput should improve once those components ship.
Is SenseNova Loop 9B worth using right now?
For accuracy on multimodal document and reasoning tasks, it performs well above what its 9B parameter count might suggest, which is the point of the looped architecture. Handwriting, physics notation, invoices, and SQL generation all came back correct or very close to correct, with only cosmetic issues in presentation rather than wrong final answers. The Apache 2.0 license and support for Transformers, LightLLM, and (via open pull requests) SGLang and vLLM make it accessible to deploy.
The honest caveat is the preview label. Inference speed well under what you’d want for production use, missing acceleration features, and a “technical report: TBD” status on the model card all point to a model still being finished. For experimentation, local document parsing, or evaluating whether looped-transformer architectures are worth adopting, it’s a reasonable model to try now. For latency-sensitive production workloads, the current preview build is not there yet.
Frequently Asked Questions
What makes SenseNova Loop 9B different from a standard 9B model?
It reuses a block of 24 decoder layers twice during each forward pass instead of running every layer only once, producing 56 layer executions from 32 stored layers. This gives it more effective depth and reasoning capacity without increasing the stored parameter count the way a larger dense model would.
How much VRAM does SenseNova Loop 9B need?
In testing, a long-horizon multimodal task (reading and solving a physics diagram) used about 18.5 GB of VRAM on an A6000 GPU, which fits comfortably on a single high-memory GPU.
Why is SenseNova Loop 9B slow during inference?
Testing measured around two tokens per second on invoice parsing, even with flash attention and documented prerequisites in place. The model card lists two acceleration methods, Dspark and Dflash2, as still in training, with only MTP currently available, which likely limits current throughput.
Is SenseNova Loop 9B good at coding?
It is not marketed as a dedicated coding model, but it handled a non-trivial SQL generation task correctly, including multi-table joins, date filtering, distinct counting, and grouping by the correct column, suggesting solid general code reasoning.
Is SenseNova Loop 9B free to use commercially?
Yes. It is released under the Apache 2.0 license, which permits commercial use, though it remains a preview release without a finalized technical report or fully optimized inference speed.
