Compare

Three Open Small Models Compared: A Diffusion 8B, a Looped 26B and a Terminal 27B

Three open-weight models shipped within two days of each other took three different routes: NVIDIA's Nemotron-Labs-Sigma denoises in a continuous 16-dimensional embedding space and runs an 8B model on one GPU; Thinking Machines' Inkling 2 Mini uses a looped architecture to hold 26B parameters while activating 5.4B, small enough to fit a laptop; RadixArk's DaisyRose-27B uses reinforcement learning to specialize in terminal agent tasks. This comparison lines them up on architecture, licensing, hardware floor, speed and benchmark strength.

One-line takeaway

None of these three is "a smaller general champion." Each trades something: one swaps the generation method, one swaps parameter efficiency, one swaps breadth for task focus.

The three objects and their evidence ​

ModelPublisherDateEvidence status
Nemotron-Labs-Sigma 8BNVIDIA2026-11-20Official model card and Hugging Face collection, weights downloadable
Inkling 2 MiniThinking Machines2026-11-21Launch materials, Artificial Analysis score, listed on Arena
DaisyRose-27BRadixArkaround 2026-11-21Team self-reported, no independent evaluation yet

All three are open-weight and all pitch "small enough to run yourself." But "small" means different things: Sigma is small in parameters (8B), Inkling 2 Mini is small in activation (5.4B active out of 26.4B total), DaisyRose is small enough in memory footprint (23–52 GB) to be practical.

Key parameters ​

DimensionSigma 8BInkling 2 MiniDaisyRose-27B
ArchitectureContinuous diffusion (denoising in a 16-dim embedding space)Looped transformerDense transformer with RL
Parameters8B, with a 3B sibling26.4B total, 5.4B active27B
LicenseNVIDIA Nemotron Open Model License (commercial use allowed)Apache 2.0Apache 2.0
Context4096 (8B instruct: 8192)No single published figureNot published
HardwareOne NVIDIA GPU, bf16, no CPU supportVendor describes it as laptop-runnableRoughly 23–52 GB VRAM depending on format
SpeedAbout 120–140 tokens/s on an H100Not disclosedNot disclosed
Headline resultsSix-task average 71.16 (8B base); GSM8K 91.96; AIME25 17.00Artificial Analysis Intelligence Index 20.1Terminal Bench 4.1 pass@1 from 5.6 to 12.0
Training costWarm-started from a ~1T-token autoregressive checkpoint, then ~0.3T tokens of diffusion trainingNot disclosed144 H200s, 18 days, ~63,000 GPU hours

Sigma: swapping the generation method ​

What is unusual about Sigma is not scale but that it does not generate token by token.

Autoregressive models write left to right. Discrete diffusion models such as LLaDA and Dream diffuse over discrete tokens. Sigma takes a third path: it denoises token representations in a learned 16-dimensional continuous embedding space, producing 64 tokens per block, each block passing through several denoising steps before the next begins.

Two consequences follow. The benefit is intra-block parallelism; with its self-speculative variant, NVIDIA reports an average 3.46x speedup over autoregressive on GB200 with SGLang, peaking at 4.20x. The cost is short context: 4096 for the base model and 8192 for 8B instruct, a hard limit for long documents.

Its benchmark profile is uneven on purpose: a six-task average of 71.16, slightly above sibling NLD-8B at 70.22 and Qwen3-8B at 68.91; GSM8K at 91.96 but AIME25 at 17.00. Strong elementary math and weak competition math points to a model that handles patterned multi-step computation well and struggles with problems that need a leap.

Inkling 2 Mini: swapping parameter efficiency ​

Thinking Machines framed this as a response to its own predecessor: Inkling 2 Small had 594B parameters, too large for most people to run. Mini cuts the total to 26.4B and, through looping, keeps activation at 5.4B.

The vendor's phrase is "think more, output less" — spend compute on internal iteration rather than emitting more tokens. This is the mirror image of Sigma's intra-block parallelism: one deepens along time, the other parallelizes across space.

The verifiable result is an Artificial Analysis Intelligence Index of 20.1. The vendor says it sits on the Pareto frontier of intelligence versus active parameters and leads several comparison models on AA Index, Vals Index, FrontierCode and DeepSWE. Those comparisons come from the publisher's own table and have not been independently reproduced.

For users the arithmetic is straightforward: 26B total means consumer VRAM can hold it; 5.4B active means inference speed resembles a small model. The cost is that looped architectures demand more of the serving stack, and not every framework supports them out of the box.

DaisyRose-27B: swapping breadth for focus ​

RadixArk's choice is the narrowest: not general, but terminal agents specifically.

Training is pure reinforcement learning, with no supervised fine-tuning and no distillation. The result is Terminal Bench 4.1 pass@1 rising from 5.6 on the Qwen3.8-27B base to 12.0 — more than double, though the absolute number remains low, which says as much about the task as about the model.

The training bill is transparent: 144 H200s for 18 days, about 63,000 GPU hours. That is a scale a small team can afford for targeted optimization, as opposed to retraining a base.

Caveat: the score is team-reported without independent evaluation, and the 23–52 GB VRAM range shows that quantization and format choices materially change the deployment floor.

How to choose ​

  • Need a general text model on a single GPU and can live with 4K context: Sigma 8B is the simplest deployment with the clearest commercial license.
  • Need something on a laptop or consumer GPU with more balanced capability and are willing to tune the serving stack: Inkling 2 Mini's activation footprint is friendlier.
  • Need a terminal-operation agent and accept a narrow specialization: DaisyRose is the only one explicitly trained for it.
  • Need long-document processing: none of the three fits; Sigma's 4K/8K context is an explicit weakness and the other two do not publish long-context capability.

Two licensing details ​

All three say commercial use is allowed, but the license types differ. Inkling 2 Mini and DaisyRose use Apache 2.0, the standard permissive license: modify, redistribute and sell, provided notices are kept. Sigma uses the NVIDIA Nemotron Open Model License, a vendor-specific license that permits commercial use but attaches conditions worth reading line by line — attribution on redistribution, liability limits, and whether downstream users must accept similar terms.

For product integration the difference is not "can I use it" but "what written obligations do I take on." Apache 2.0 has a clear boundary; a custom license should be read before anything ships inside a product.

A shared caveat ​

All three results are publisher-reported and measured on different suites: Sigma on a six-task set, Inkling on the Artificial Analysis index, DaisyRose on Terminal Bench. These scores cannot be compared across models and do not establish who is stronger.

What is genuinely comparable is performance within one benchmark — for example Sigma versus NLD-8B and Qwen3-8B on the same six tasks. Cross-suite ordering is only useful as a positioning reference.

Boundaries ​

  • Sigma's architecture, checkpoint count, license, context, throughput and benchmark scores come from NVIDIA's model card, the Hugging Face collection, and technical breakdowns by MarkTechPost and DEV Community;
  • Inkling 2 Mini's parameters, license, index score and hardware description come from Thinking Machines' launch, the Artificial Analysis score and its Arena listing;
  • DaisyRose-27B's training configuration and Terminal Bench result are RadixArk's own report, unverified;
  • "Laptop-runnable" is vendor phrasing without published device or quantization conditions;
  • Context lengths are reported under different conventions and are not converted here;
  • This is a public-information comparison, with no deployment instructions or performance promises, and no recommendation.

Sources ​