LATEST
AI Tools

DaisyRose-27B: Free 27B Coding Model, Terminal-Bench Doubled

Updated November 21, 2026
12 min read
Editor's Note: This article was human-reviewed for accuracy
Colorful programming code on a computer monitor screen

Quick Answer & Key Takeaways

  • • DaisyRose-27B is RadixArk's first model, a 27B coding model trained with reinforcement learning only on Qwen3.8-27B.
  • • Its Terminal-Bench 4.1 score more than doubles the base model, from 5.6% to 12.0%, and the Apache 2.0 weights are free to download.
  • • It runs on a single GPU, from an RTX 5090 to a DGX Spark, but every benchmark so far is self-reported by RadixArk.

RadixArk had never shipped a model before November 18, 2026. Then it released DaisyRose-27B, a 27-billion-parameter coding model trained with reinforcement learning and nothing else: no supervised fine-tuning, no distillation from a bigger teacher. The headline result is a Terminal-Bench 4.1 pass@1 score of 12.0%, more than double the 5.6% of the Qwen3.8-27B base it started from. The weights are free under Apache 2.0, and the whole model fits on a single GPU. This review covers what DaisyRose-27B is, how it was trained, what its benchmarks actually prove, what it costs to run, and how to try it yourself.

What DaisyRose-27B is

DaisyRose-27B is RadixArk's first model, built on Alibaba's Qwen3.8-27B and post-trained with reinforcement learning using Miles, RadixArk's open-source RL framework. It keeps the base model's architecture, tokenizer, chat template, image understanding, and 256K-token context window unchanged, which makes it a drop-in replacement for Qwen3.8-27B in existing inference and post-training stacks. That matters more than it sounds: anyone already serving Qwen3.8-27B can swap in DaisyRose-27B without changing their serving setup.

Under the hood it is a dense 27.8-billion-parameter model: 64 decoder layers in a 3:1 pattern of Gated DeltaNet linear-attention layers to full-attention layers, a hidden size of 5,120, a 27-layer vision encoder, and a multi-token-prediction layer that supports speculative decoding. Input is text and images; output is text. It is a thinking model, which means it reasons before answering, and its reasoning comes back in a separate reasoning_content field when served through an OpenAI-compatible endpoint.

The release ships in three checkpoint formats on Hugging Face: BF16, FP8, and NVFP4, all under Apache 2.0. A community GGUF build from bartowski adds llama.cpp-friendly quantizations, including a Q4_K_M file of 17.33 GB. As of November 21, the official model page showed 918 downloads and 270 likes, small numbers that fit a three-day-old release from a first-time model maker.

How it was trained: 1,200 tasks, 144 GPUs, 18 days

The training story is the real point of this release. RadixArk built the training set in partnership with Eigent AI, starting from a large pool of tasks in machine learning, software engineering, science, and other fields. Thousands of candidates were cut down to about 1,200 that made the final set, selected on three rules: each task had to target a mistake the base model actually made, each had to need several interdependent steps, and each had to reward solving the problem rather than gaming the grader. Every attempt got up to 1.5 hours in a sandbox, with more than 100 tool calls and more than 256K output tokens, and some agent sessions stretched to 1 million tokens through harness summarization.

Training ran on Miles in fully asynchronous mode: 128 H200 GPUs ran agent inference while 16 more trained the policy, with updated weights pushed back to the inference fleet after every step. The whole run took 18 days and about 63,000 GPU-hours. RadixArk reports 37% model FLOPs utilization on its internal backend, against 16% for an open-source Megatron-based trainer on comparable runs, which it translates into 57% lower training cost and about twice the end-to-end speed: roughly 16,800 tokens per second across the 144 GPUs versus about 8,300. Those efficiency figures are RadixArk's own internal comparison, not an independent measurement, and the open trainer it was measured against is unnamed.

Every training attempt ran in a sandbox built on the open-source AgentENV project, to which RadixArk also contributes fixes. Between mid-September and mid-November the service ran about 944,000 sandboxes, peaking at 1,566 running at the same time, with 99% of sandbox creations succeeding across the nine weeks and more than 99.95% since late October. RadixArk puts the sandbox cloud costs about 80% below popular cloud sandbox providers, another company-reported figure with no named providers to check against.

Benchmarks: what the numbers actually say

RadixArk reports seven benchmarks, all run by RadixArk itself, with DaisyRose-27B beating its base model on every one. The scores use the higher of the BF16 and FP8 runs for each benchmark.

BenchmarkQwen3.8-27BDaisyRose-27BChange
Terminal Bench 4.1 (pass@1)5.612.0+6.4
Terminal Bench 2.173.075.5+2.5
DeepSWE v1.142.246.2+4.0
SWE Bench Pro v291.394.7+3.4
HLE (text only)33.934.3+0.4
IFBench79.582.4+2.9
GPQA Diamond89.290.7+1.5

The honest reading starts with the headline. Terminal Bench 4.1 more than doubling, from 5.6% to 12.0%, is a real improvement in long-horizon terminal work, and the coding gains are steady rather than one-off: plus 4.0 points on DeepSWE v1.1 and plus 3.4 on SWE Bench Pro v2. But 12.0% pass@1 also means 88 out of 100 attempts still fail under that setup, so this is progress on a hard benchmark, not a solved problem. The knowledge gains are small: plus 0.4 on HLE and plus 1.5 on GPQA Diamond, which fits a training set built around agent tasks rather than general knowledge.

Against larger models the picture is mixed. In RadixArk's own nine-model comparison table, MiMo V2.6 Flash, a 309-billion-parameter model, leads Terminal Bench 4.1 at 16.1, and Inkling 2 Small, at 594 billion parameters, leads DeepSWE at 72.1 and HLE at 44.1. DaisyRose-27B tops that table on only one benchmark, IFBench, where its 82.4 is the best score of the nine. A 27B dense model trailing 300B-plus models on hard agentic tasks is expected, not a flaw; the point is how close it gets for its size.

One row in that comparison table needs a warning. RadixArk's table lists DeepSWE v1.1 at 4.4 for Meta's Muse Glimmer-30B and 0.0 for Qwen3.6-35B-A3B, next to DaisyRose-27B's 46.2. A 0.0 on a coding benchmark from a capable 35B model reads like a harness failure or an unevaluated entry, not a real capability gap, so do not use those two cells to conclude DaisyRose-27B is ten times better than its rivals. The table is RadixArk's own, it cites each developer's reports or leaderboards, and the SWE Bench Pro v2 figures trace to arXiv paper 2611.16289. Until an independent lab reruns these numbers, treat every score here as company-reported.

What DaisyRose-27B costs: the weights are free, the GPU is not

There is no price list for DaisyRose-27B because there is nothing to buy. The weights are free under Apache 2.0, which permits commercial use, and RadixArk publishes no hosted API and no per-token price. The cost of using it is the hardware you run it on, plus electricity.

FormatSizeWhat it needs
BF16About 52 GBOne high-memory GPU, such as an H200, B200, or RTX PRO 6000
FP8About 29 GBOne GPU with at least 29 GB of memory
NVFP4About 23 GBA Blackwell GPU only, such as a B200, GB300, RTX 5090, or DGX Spark
GGUF Q4_K_M (bartowski)17.33 GBllama.cpp, LM Studio, or another GGUF runner

The cheapest named route to a Blackwell card is NVIDIA's DGX Spark, a 64 GB desktop machine that went on sale at $4,999. At November 21, 2026 market rates (1 USD = 0.764 GBP, 1.4307 CAD), that is about £3,819 or C$7,152, marked as an approximation. Our DGX Spark review covers what that price actually buys, including the storage and memory limits that matter for local model work. An RTX 5090 is the other consumer route RadixArk lists, and the GGUF build is the fallback for anyone without a data-center card: 17.33 GB fits on a 24 GB consumer GPU with room for context.

Cloud rental is the alternative to buying hardware, but there is no published per-token price to compare against hosted models, because no hosted DaisyRose-27B API exists yet. If you want a per-token bill instead of a GPU bill, the hosted open-weight options are the comparison: Kimi K3.1 Pro at $2 per million input tokens, Mistral Large 4, and DeepSeek V4.1 Flash at $0.15 per million input tokens off-peak. DaisyRose-27B only wins that comparison if you already own the GPU or run enough volume for the fixed hardware cost to beat per-token billing.

How to run DaisyRose-27B

RadixArk recommends serving the model with SGLang and DSpark speculative decoding, using the official SGLang Docker image. The SGLang cookbook generates the launch command for each GPU and checkpoint format, and the model card's quickstart starts the server with a single command:

python3 -m sglang.launch_server --model-path RadixArk/DaisyRose-27B

vLLM works too, with one line:

vllm serve "RadixArk/DaisyRose-27B"

Once the server is up on port 30000, it speaks the OpenAI chat API, so any tool that talks to an OpenAI-compatible endpoint can point at it. The official quickstart uses the OpenAI Python client with base_url="http://localhost:30000/v1" and the served model name DaisyRose-27B. The model's suggested sampling settings are temperature 1.0, top_p 0.95, top_k 20, and min_p 0.0, and its reasoning returns in reasoning_content while the final answer returns in content. SGLang itself is worth knowing beyond this model: NVIDIA, AMD, Intel, and Google recently united behind it as an open inference standard.

For a laptop or desktop without a data-center GPU, the GGUF route is simpler. Bartowski's build runs under llama.cpp, and the Q4_K_M quantization starts with one command:

llama-server -hf bartowski/RadixArk_DaisyRose-27B-GGUF:Q4_K_M

That serves a built-in chat web interface on localhost port 8080. Expect slower, more verbose output than a hosted API: this is a thinking model running on local hardware, and long agent sessions are exactly the workload it was trained for, so a short chat question is not where it shows its strength.

DaisyRose-27B vs the alternatives

DaisyRose-27BQwen3.8-27BMuse Glimmer-30BQwen3.6-35B-A3B
DeveloperRadixArkQwen (Alibaba)Meta Superintelligence LabQwen (Alibaba)
Total parameters27.8B27BAbout 29.6B35B
Active parameters27.8B (dense)27B (dense)About 29.6B (dense)3B (MoE)
Context window262,144 tokens262,144 (extensible to 1M)131,072+262,144 (extensible to 1,010,000)
LicenseApache 2.0Apache 2.0Apache 2.0Apache 2.0
Terminal Bench 2.175.573.051.744.9
SWE Bench Pro v294.791.380.473.3
DeepSWE v1.146.242.24.4*0.0*
HLE (text only)34.333.922.022.2
IFBench82.479.577.064.4
GPQA Diamond90.789.283.586.0

*The DeepSWE figures for Muse Glimmer-30B and Qwen3.6-35B-A3B come from RadixArk's own comparison table and look like harness failures rather than real scores; read them with that caveat. All other scores in this table are also RadixArk-reported, not independently verified.

The table's real story is the gap to the base model, not the gap to rivals. DaisyRose-27B beats Qwen3.8-27B on all seven benchmarks RadixArk reports, with the widest margins on the agent benchmarks that its training targeted. Against other models in its size class it leads on IFBench and GPQA Diamond and trails only much larger models on the hardest agentic tests. For a team choosing a local coding model, the practical choice is between DaisyRose-27B's free weights and a hosted API: a hosted model costs per token but needs no GPU, while DaisyRose-27B costs nothing per token but needs a GPU you already own or rent.

The catches

Every benchmark in this article is self-reported by RadixArk, and no independent evaluation had appeared by November 21. That is normal for a three-day-old release, but it means the 12.0% Terminal-Bench figure is a company number until someone else reruns it. The 1,200-task training set is small by design, and RadixArk is open about the trade-off: tasks were chosen to fix the base model's mistakes, which should generalize, but a model trained on 1,200 curated tasks can still fail on long-horizon plans, unfamiliar tools, or work outside the training distribution.

There are practical limits too. NVFP4, the smallest official checkpoint at about 23 GB, needs a Blackwell GPU, so older cards are limited to the 52 GB BF16 or 29 GB FP8 builds. There is no hosted API, no chat app, and no fine-tuning service from RadixArk, so non-technical users have nothing to click. And the efficiency claims, 37% MFU, 57% lower training cost, 80% cheaper sandboxes, are internal comparisons against unnamed baselines. They describe RadixArk's training operation, not something a user can verify from the weights alone.

Who should try it

DaisyRose-27B fits three groups. Developers with a spare GPU and a taste for self-hosting get a better Qwen3.8-27B for agent work, free, under a license that allows commercial use. Researchers studying agent post-training get a clean case study: a public recipe, 1,200 tasks, and a measurable jump on Terminal-Bench, plus the open-source Miles framework to reproduce the approach. Teams already running Qwen3.8-27B in SGLang or vLLM can swap it in with no other change and measure the difference on their own tasks.

Everyone else should wait. If you need a coding model today with a per-token price and an API key, a hosted model is the simpler buy. If you want independent proof that the 12.0% holds up, wait for a third-party evaluation. And if you have no GPU at all, the GGUF build still needs a machine with 17 GB of free memory and a CPU or GPU that can run it at usable speed.

Common mistakes

The first mistake is reading 12.0% as a solved benchmark. Terminal-Bench 4.1 is designed to be hard, and 12.0% pass@1 still means most attempts fail; the improvement over 5.6% is the news, not the absolute number. The second is treating the DeepSWE comparison rows as a ranking: the 4.4 and 0.0 figures for rival models in RadixArk's table look like harness artifacts, and repeating them as fact would mislead readers. The third is downloading the NVFP4 checkpoint for a non-Blackwell card and wondering why it will not load. Check your GPU first: NVFP4 needs Blackwell, while FP8 runs on any card with 29 GB free. The fourth is expecting a chat product. DaisyRose-27B is weights and a serving recipe, not an app, and the setup work is yours.

Is DaisyRose-27B free to use?

Yes. The weights are released under Apache 2.0, which allows commercial use with no license fee. You pay only for the hardware and electricity to run it, or for cloud GPU rental if you rent instead of owning a card.

How much GPU memory does DaisyRose-27B need?

About 52 GB in BF16, about 29 GB in FP8, and about 23 GB in NVFP4, which needs a Blackwell GPU. The community GGUF build in Q4_K_M is 17.33 GB and runs under llama.cpp on a 24 GB consumer GPU.

Is DaisyRose-27B better than Qwen3.8-27B?

On RadixArk's own benchmarks, yes on all seven, with the biggest gain on Terminal-Bench 4.1, up from 5.6% to 12.0% pass@1. The numbers are self-reported and have no independent verification yet, so the lead is real on RadixArk's tests and unconfirmed everywhere else.

Can I use DaisyRose-27B commercially?

Yes. Apache 2.0 permits commercial use, including building products on the weights. The base model Qwen3.8-27B is also Apache 2.0, so there is no license conflict between the two.

Does DaisyRose-27B have a hosted API?

No. RadixArk publishes no hosted API and no per-token price. You run it yourself with SGLang or vLLM, or through the GGUF build under llama.cpp, and it exposes an OpenAI-compatible endpoint on your own machine.

Where can I download DaisyRose-27B?

From Hugging Face at RadixArk/DaisyRose-27B, in BF16, FP8, and NVFP4, plus a GGUF build from bartowski. The release announcement and training details are on the RadixArk blog and the Hugging Face blog.

DaisyRose-27B is a small, honest release with one clear claim: reinforcement learning on 1,200 well-chosen tasks more than doubled a 27B model's Terminal-Bench score, on hardware a single person can own. The benchmarks are self-reported, the absolute score is still low, and there is no hosted API, but the weights are free, the license is permissive, and the recipe is public. If you have a GPU and agent work to do, it is worth an afternoon of testing. If you do not, the hosted open-weight models remain the simpler path, and the independent evaluations will tell us soon enough whether 12.0% holds up.

Sources

12 min read
37 views
edit_note Written by

Ratul Ahamed

Founder & Editor-in-Chief

Ratul Ahamed is the founder and editor of AI Core Updates, an independent site covering AI tools, models and pricing. He is a web developer based in Bangladesh and also runs All In One Tools, a free collection of browser-based utilities. Contact: [email protected]

Read all stories by Ratul Ahamed arrow_forward
verified_user Human-Reviewed Editorial

forum Comments (0)

Leave a Reply

chat_bubble_outline

No comments yet. Be the first to join the conversation!

Weekly AI Digest

Get our weekly AI tools digest

One email a week analyzing new AI tools, model updates, and practical workflows. Tested and summarized with zero fluff. Unsubscribe any time.

bolt
Hands-on AI Tool Reviews
Pricing math, limits, and alternatives.
verified_user
Strict Anti-Spam Policy
1-click unsubscribe at any time.
mark_email_unread

Subscribe to Digest

Sent weekly • No spam

person_outline
mail_outline

No spam ever. You can unsubscribe with a single click at any time.

cookie

Cookie Settings

We use cookies to enhance your browsing experience, serve personalized content, and analyze our traffic. By clicking "Accept All", you consent to our use of cookies. Learn more