DaisyRose-27B: An open coding-agent model trained purely with reinforcement learning

Startup RadixArk has released DaisyRose-27B, its first open-weights model. It's built on Qwen3.8-27B, was trained only with reinforcement learning on long agentic tasks, and runs on a single GPU. RadixArk says it doubles the base model's success rate on the tough Terminal Bench 4.1.

Model releases Try it yourself Nov 20, 2026 7 min read Source: MarkTechPost
Illustrative image, AI-generated

What's going on

AI infrastructure startup RadixArk released its first in-house model with freely downloadable weights this week: DaisyRose-27B. It's an agentic coding model. That means it doesn't just suggest code. It works through many steps on its own and uses tools along the way: it runs terminal commands, reads and edits files, and runs tests.

DaisyRose-27B wasn't built from scratch. RadixArk took Alibaba's Qwen3.8-27B and post-trained it. The twist: according to the Model Card, this was done purely with reinforcement learning (RL, learning from rewards: the model attempts tasks and gets rewarded when it succeeds). There was no SFT (supervised fine-tuning, i.e. training on reference answers) and no distillation (learning from the outputs of a larger teacher model). The weights are on Hugging Face under the permissive Apache 2.0 license and are meant as a drop-in replacement for the base model. If you already run Qwen3.8-27B, you can just swap it out.

RadixArk is run by the team behind the SGLang inference engine. According to Yahoo Finance (Simply Wall St), the company launched with a $100 million seed round that included chipmaker AMD. Its stated goal is to widen access to large-scale AI infrastructure.

Under the hood

RadixArk didn't touch the architecture. The model has 27.8 billion parameters in total. Of those, 0.46 billion belong to a vision encoder and 0.42 billion to an MTP head. It's a dense model, so every parameter is used for every response. Mixture-of-experts models, by contrast, only activate some of their parameters.

The 64 layers follow a 3:1 pattern: three layers of Gated DeltaNet, followed by one layer of classic full attention. Gated DeltaNet is an efficient "linear" attention whose compute cost doesn't blow up on long inputs. A 27-layer vision encoder handles images, and the output is always text. The multi-token prediction (MTP) layer predicts several tokens at once, which enables speculative decoding: a fast draft is produced and the big model only has to verify it, which speeds up generation. The context window is 262,144 tokens. DaisyRose is a "thinking" model, so it reasons visibly before it answers.

How it was trained

Together with Eigent AI, RadixArk put together about 1,200 tasks, picked from thousands of candidates. Each one targets a specific weakness of the base model. On each attempt, the model worked in a sandbox (an isolated test environment) and had up to 1.5 hours, more than 100 tool calls and over 256,000 output tokens. According to the blog post, full agent sessions reached up to one million tokens.

Training ran on Miles, RadixArk's own open-source RL framework, in fully asynchronous mode. In that mode, generating attempts and learning from them run in parallel instead of waiting on each other. The run used 144 Nvidia H200 GPUs for 18 days. 128 of them had the agent work on tasks, and only 16 handled the actual training. In total, that came to 63,000 GPU hours.

RadixArk reports an MFU (model FLOPs utilization, i.e. how much of the theoretical compute is actually used) of 37 percent with its internal backend. An open-source Megatron-based trainer managed 16 percent. Throughput doubled from 8,300 to 16,800 tokens per second, which the company says saved 57 percent of GPU time. The sandboxes ran on AgentENV. Between mid-September and mid-November, about 944,000 sandboxes were launched, with up to 1,566 running at once, and 99 percent of them were created successfully over nine weeks. RadixArk says this cost about 80 percent less than mainstream cloud providers. That's also the company's own figure.

Benchmarks: a big jump on terminal tasks

Every number here comes from RadixArk itself. Each entry is the better of the BF16 and FP8 runs.

Benchmark DaisyRose-27B Qwen3.8-27B Change
Terminal Bench 4.1 (pass@1) 12.0 5.6 +6.4
Terminal Bench 2.1 75.5 73.0 +2.5
DeepSWE v1.1 46.2 42.2 +4.0
SWE Bench Pro v2 94.7 91.3 +3.4
HLE (text only) 34.3 33.9 +0.4
IFBench 82.4 79.5 +2.9
GPQA Diamond 90.7 89.2 +1.5

"pass@1" is the share of tasks solved on the first try. The biggest jump is on the tough Terminal Bench 4.1, where the score more than doubles. Coding tasks show solid gains, while knowledge benchmarks (HLE, GPQA Diamond) barely move. That makes sense: RL on agentic tasks doesn't teach a model new facts.

Against much larger models, the results are mixed. MiMo V2.6 Flash (309 billion total parameters) leads Terminal Bench 4.1 with 16.1. Inkling 2 Small (594 billion) leads DeepSWE with 72.1 and HLE with 44.1. In RadixArk's nine-model comparison table, DaisyRose only comes out on top for instruction following (IFBench, 82.4). Against similarly sized open models like Meta's Muse Glimmer-30B or Qwen3.6-35B-A3B, it wins every listed test. One thing stands out: RadixArk gives no score for the official SWE-bench Pro variant that Qwen reports on its Model Card (61.7 for the base model).

What you need to try it

RadixArk says the model fits on a single GPU. At full precision (BF16) it needs about 52 GB of VRAM (video memory), around 29 GB in FP8, and about 23 GB in NVFP4. NVFP4 is a 4-bit format from Nvidia that only runs on Blackwell-generation GPUs. Officially listed target hardware: H200, B200, GB300, RTX PRO 6000, RTX 5090 and DGX Spark.

For home users, the GGUF version is the one to watch. It's a file format for tools like llama.cpp, LM Studio and Ollama. With 4-bit quantization (the model gets smaller because its numbers are stored at lower precision), expect roughly 18 to 20 GB. A 24 GB card such as an RTX 3090/4090, or an RTX 5090 with 32 GB, is realistic. Apple Silicon Macs with at least 32 GB of unified memory should also run the GGUF version, just more slowly. Keep in mind that long contexts need extra memory, and agent sessions with hundreds of thousands of tokens push that up a lot. On CPU alone, a dense 27B model is sluggish. You'll also need 20 to 55 GB of disk space, depending on the format.

For servers, RadixArk recommends SGLang with DSpark speculative decoding and the Qwen3.8-27B-DSpark draft model. vLLM works via vllm serve "RadixArk/DaisyRose-27B". For thinking mode, the company recommends temperature 1.0, top_p 0.95 and top_k 20.

The bigger picture

DaisyRose-27B isn't so much a new frontier model as a showcase. RadixArk is showing that you can take a good open model and use pure reinforcement learning to improve it on long agentic tasks with modest effort. By big-lab standards, 63,000 GPU hours isn't much. It's also a pitch for the company's own tools: Miles, AgentENV and SGLang.

If you run local coding agents, the model is an easy swap that could bring a noticeable boost on terminal tasks. The caveats: every number comes from the company, and there are no independent tests yet. Some benchmark versions, such as SWE Bench Pro v2 with scores above 90, are hard to compare with the familiar official leaderboards. And on really hard agentic tasks, much larger MoE models are still clearly ahead. Miwa, who wrote about the model on Note, is right to recommend testing the base model and DaisyRose on your own tasks under the same conditions.

Sources

#radixark#open-source#coding-agent#reinforcement-learning#qwen
Read the original source

Try it yourself: DaisyRose-27B

Explained step by step, no prior knowledge needed – on your own computer or free in your browser.

What can I do with it?

DaisyRose-27B is a coding assistant that can work as an agent. In tools like coding agents, it reads files, runs terminal commands, works through error messages and makes its way to a solution over many steps. It understands images as well as text, such as screenshots of error messages or diagrams, but it only answers in text. As a thinking model, it reasons before it answers. That helps on complex tasks but takes time. The company says it beats its base model, Qwen3.8-27B, on every test it measured, especially on long terminal tasks, and that it follows instructions very closely. It adds almost nothing in factual knowledge over the base model. On hard agentic tasks, it still loses to very large models with hundreds of billions of parameters. All figures come from the company.

Who is it worth it for?

Worth it if you're a developer or tinkerer with a GPU that has at least 24 GB, or a Mac with plenty of memory, and you want to run a local coding agent with no cloud costs. That goes double if you already use Qwen3.8-27B. For plain chat, knowledge questions or machines with little VRAM, it's probably not your first pick.

Ideas: What you can do with it

Local coding agent

Hook the model up to a coding agent through an OpenAI-compatible API and have it find and fix bugs in your project. Your code never leaves your machine.

Everyday scripts

Describe in plain language what you want to automate, such as renaming photos or making backups, and get a ready-to-use Bash or Python script with an explanation.

Error messages from screenshots

Because the model understands images, you can just paste in a screenshot of an error message. It explains the cause and gives you the commands to fix it.

Adding tests

Give the model existing code and have it write and run unit tests. That quickly gives older projects a basic safety net.

Updating documentation

Have the model read several files and update a guide or README to match the current code. Review the result before you accept it.

Size27.8 B parameters
Download17 GB (about 23 min at 100 Mbit/s)
Licenseapache-2.0
TypeImage + text (understands images)

What your computer needs

Graphics card (NVIDIA) at least 13 GB VRAM, recommended 20 GBe.g. RTX 3090, RTX 4090, Tesla P40
Mac (Apple Silicon M1–M5) from 32 GB unified memoryThe GPU and CPU share the memory – the model can use about 70% of it
CPU only (no graphics card) Very slow without a graphics cardan estimated 3 words per second on a current desktop PC. This requires at least 32 GB of RAM.
Storage approx. 19 GB freeModel download plus programs
Google Colab runs for freeThe free Tesla T4 GPU with 15 GB is enough

Which variant is right for me?

Many models come in several sizes or "quantizations." These are compressed versions: smaller and faster, but slightly less accurate. Rule of thumb: pick the largest variant whose memory requirement fits in your VRAM (video memory). The scripts below choose this for you automatically.

VariantDownloadNeeds approx.Compatible graphics cards
Q2_K 11 GB13 GBe.g. RTX 4060 Ti 16 GB, RTX 4080, RTX 5080, RX 7800 XT
Q3_K_M 13 GB16 GBe.g. RTX 4060 Ti 16 GB, RTX 4080, RTX 5080, RX 7800 XT
Q4_K_M Default 17 GB20 GBe.g. RTX 3090, RTX 4090, Tesla P40
Q5_K_M 21 GB24 GBe.g. RTX 3090, RTX 4090, Tesla P40
Q6_K 24 GB28 GBe.g. RTX 5090
Q8_0 29 GB33 GBe.g. 2× RTX 3090/4090 or RTX A6000
BF16 55 GB62 GBe.g. multiple professional GPUs (2× A6000, H100) or DGX Spark

BF16 (about 52 GB) is only for pro GPUs like the H200, B200 or RTX PRO 6000. FP8 (about 29 GB) fits on 32 GB cards like the RTX 5090. NVFP4 (about 23 GB) is the most efficient option, but it only runs on Blackwell GPUs (RTX 50 series, B200, DGX Spark). For older 24 GB cards or Macs, a 4-bit GGUF version (roughly 18–20 GB) is your best bet.

  • BF16 needs about 52 GB, FP8 about 29 GB and NVFP4 about 23 GB of VRAM.
  • NVFP4 only works on Nvidia GPUs from the Blackwell generation.
  • Officially listed target hardware: H200, B200, GB300, RTX PRO 6000, RTX 5090 and DGX Spark, each as a single GPU.
  • A 4-bit GGUF version roughly fits on 24 GB cards or on Macs with at least 32 GB of unified memory.
  • Long contexts (up to 262,144 tokens) need a lot of extra memory. If VRAM is tight, set a smaller context window.
How do I find out what my computer has?
  • Windows: Press Ctrl + Shift + Esc → Task Manager → Performance tab → click GPU on the left. At the bottom you'll see Dedicated GPU memory (that's your VRAM). You'll find system memory under Memory.
  • Mac: Apple menu at the top left → About This Mac. You'll see your chip (e.g. M2) and memory (e.g. 16 GB). On Apple chips, graphics and processor share this memory.
  • Linux: Type nvidia-smi in the terminal (shows your graphics card and its memory) and free -h for system memory.

Guide

Google Colab (in your browser, no installation)

Google Colab is a free service from Google. It gives you a computer with a graphics card in your browser for a few hours. All you need is a Google account. For this model: runs for free – The free Tesla T4 GPU with 15 GB is enough.

  1. Download the notebook. Click the button and save the file.

    Download colab.ipynb

  2. Open Colab. Go to colab.research.google.com and sign in with your Google account.
  3. Upload the notebook. In the window that appears, click Upload on the left (or choose File → Upload notebook at the top) and select the file colab.ipynb.
  4. Turn on the GPU. In the top menu, go to Runtime → Change runtime type → under Hardware accelerator, select T4 GPU → Save.
  5. Start everything. Runtime → Run all (keyboard shortcut Ctrl + F9). If you see the warning “This notebook was not authored by Google,” click Run anyway.
  6. Wait. The cells run one after another. A green checkmark appears to the left of each cell when it's done. Installation and download take about 10 minutes here.
  7. Try it out. The result appears below the last cell. To test something else, change the text in the cell and run it again with Shift + Enter. The last cell starts a proper chat with an input field.
  8. Clean up. When you're done: Runtime → Disconnect and delete runtime. This saves your free quota.

Good to know: The free GPU is limited (usually a few hours per day). After about 90 minutes of inactivity, Colab disconnects, and you'll have to start everything over.

Windows 10 / 11

The easiest way is Ollama, a free program that launches AI models with a single command.

  1. Update your graphics driver (NVIDIA cards only): Install the NVIDIA app or the latest driver. For AMD cards, use the latest Adrenalin driver.
  2. Install Ollama. Download the file OllamaSetup.exe from ollama.com/download/windows, double-click it, and choose Install. Afterward, a small llama icon appears in the taskbar at the bottom right.
  3. Open a terminal window. Press the Windows key, type PowerShell and press Enter. A blue or black window opens.
  4. Start the model. Copy this command ("Copy" button), paste it into the window with a right-click, and press Enter:
    ollama run hf.co/bartowski/RadixArk_DaisyRose-27B-GGUF:Q4_K_M
    The first time, Ollama downloads the model (17 GB (about 23 min at 100 Mbit/s)). After that, it's instant.
  5. Start typing. Once >>> Send a message appears, type your question and press Enter. Type /bye to end the chat.

Not enough memory? Pick a smaller variant from the table above, e.g. ollama run hf.co/bartowski/RadixArk_DaisyRose-27B-GGUF:Q2_K.

Prefer automatic? A script that picks the right variant for you
  1. Download both files into the same folder: try_windows.ps1 demo.py
  2. Open the folder in File Explorer, right-click an empty spot and choose Open in Terminal.
  3. Paste this command and press Enter:
    powershell -ExecutionPolicy Bypass -File try_windows.ps1

If needed, the script installs Ollama via winget, measures your VRAM (video memory) and downloads the matching variant.

macOS

Macs with an Apple chip (M1 to M5) are ideal. Older Intel Macs are very slow.

  1. Install Ollama. Download it from ollama.com/download/mac, open the file, and drag Ollama into your Applications folder. Launch Ollama once – a llama appears in the menu bar at the top.
  2. Open Terminal. Press Cmd + Space, type Terminal, and press Enter.
  3. Start the model. Paste the command (Cmd + V) and press Enter:
    ollama run hf.co/bartowski/RadixArk_DaisyRose-27B-GGUF:Q4_K_M
    The first time, the model is downloaded (17 GB (about 23 min at 100 Mbit/s)).
  4. Start typing. Type your question and press Enter. Quit with /bye.
Pick the right variant automatically

try_mac.sh

cd ~/Downloads
bash try_mac.sh

Linux

  1. Check your GPU. nvidia-smi should show your card. If it doesn't, install the driver on Ubuntu and restart:
    sudo ubuntu-drivers install
  2. Install Ollama:
    curl -fsSL https://ollama.com/install.sh | sh
  3. Start the model:
    ollama run hf.co/bartowski/RadixArk_DaisyRose-27B-GGUF:Q4_K_M
    Exit with /bye. Use ollama ps to check whether the model is running on the GPU.
  4. Or let it pick the right variant automatically:

    try_linux.sh

    bash try_linux.sh
    # mit Python/transformers statt Ollama:
    MODE=hf bash try_linux.sh

Try it

Explain what this Bash script does and suggest improvements: for f in *.jpg; do convert "$f" -resize 50% "small_$f"; done
Write a Python script that reads every CSV file in a folder, merges them and removes duplicate rows. Explain each step.
Here's a screenshot of an error message from my terminal. What's causing it, and which commands will fix it?
I have a Flask project with no tests. Plan step by step how you'd build a test suite with pytest, then write the first three tests for a login route.
Check this function for edge-case bugs, rewrite it to be more robust and include matching unit tests: def average(values): return sum(values)/len(values)

Tips for better results

  • For thinking mode, use the recommended settings: temperature 1.0, top_p 0.95, top_k 20.
  • You'll get the most out of the model in an agent tool with terminal and file access, not in a plain chat window.
  • Be clear about the task: state the goal, the files involved and the result you want (e.g. 'all tests passing').
  • If you already use Qwen3.8-27B, drop in DaisyRose as a replacement and compare the two on the same tasks.
  • On servers running SGLang, turn on DSpark speculative decoding to speed up generation.

If something goes wrong

NVFP4 files won't run on older GPUs. On an RTX 30/40, use FP8 (if you have enough memory) or GGUF instead.

vLLM and SGLang need a recent version that supports the Qwen3.8 architecture with Gated DeltaNet. If loading fails, update first.

The recommended speculative decoding with SGLang also needs the Qwen3.8-27B-DSpark draft model.

As a thinking model, it produces long chains of reasoning before it answers. That costs time and context, but it's expected.

If you set the context too large, you'll run out of VRAM. Reduce the context length if that happens.

There are no independent benchmarks yet, so compare it with the base model on your own tasks.

“out of memory,” a crash, or your computer freezes

The model is too big for your VRAM (video memory). Pick a smaller variant from the table above and close other programs, especially games and browsers with lots of tabs.

It runs, but extremely slowly

Your CPU is probably doing the work instead of your graphics card. In Ollama, the PROCESSOR column of ollama ps shows how much runs on the GPU. If it says "100% CPU", update your graphics driver or pick a smaller variant that fits entirely into VRAM (video memory).

“ollama” or “python” is not found

Close the terminal window and open it again so it recognizes the newly installed program. For Python on Windows: reinstall it and check Add python.exe to PATH.

Windows: "Running scripts is disabled on this system"

Run the script with exactly the command above: powershell -ExecutionPolicy Bypass -File try_windows.ps1. This allows execution for this one time only.

Error message when loading the model (version, "trust_remote_code", unknown architecture)

Brand-new models often need the latest software version. With Ollama: update Ollama. With Python: pip install -U transformers in the activated environment. The Model Card usually lists the exact version.

Tokenstrom generates the scripts and notebook automatically. Please take a quick look before running them – they're plain, readable text. Mind the model's license: apache-2.0.

Ask the AI assistant

Questions about this article, installation or background? Our assistant knows this page and runs on our own machine, not in someone else's cloud.

Connecting …

The Assistant is an AI (Gemma 4) and can make mistakes – please check important details against the source. Questions are used only to generate an answer and are deleted after one hour. Please don't enter any personal data.

Comments

What do you think? Already tried it? Write it here, no sign-up needed.

  1. Loading comments …

Comments are public. Links aren't allowed, and we delete abusive posts. You can delete your own comment at any time in this browser. Learn more in the Privacy Policy.