The Release
RadixArk just dropped DaisyRose-27B, their first model, and the numbers tell a story about post-training efficiency that feels like it matters. Built on Qwen3.8-27B and trained with their open-source RL framework Miles, the model improves Terminal-Bench 4.1 pass@1 from 5.6% to 12.0%. That's not just an incremental bump—it's doubling the solve rate on long-horizon agent tasks.
The model ships under Apache 2.0 in BF16, FP8, and NVFP4 formats. It keeps Qwen3.8-27B's architecture, tokenizer, and 256K-token context window, but the post-training transforms its capabilities on reasoning and coding benchmarks. Beyond Terminal-Bench, it posts gains across DeepSWE v1.1 (42.2% → 46.2%), SWE Bench Pro v2 (91.3% → 94.7%), and GPQA Diamond (89.2% → 90.7%).
What makes this interesting isn't just the benchmark improvements. It's how they got there: 1,200 curated tasks, 18 days of training on 144 H200 GPUs, and a training backend that runs 2× faster end-to-end than open-source alternatives.
Task Design: Curated, Not Scaled
The training data philosophy here is refreshingly anti-scale. RadixArk partnered with Eigent AI to build thousands of candidate tasks, then filtered down to about 1,200 that made the final cut. Each task targets a specific mistake Qwen3.8-27B makes, requires several interdependent steps, and must reward actually solving the problem.
They ran the base model on every task and redesigned each one around the mistakes they wanted to eliminate. Then they tuned difficulty until solve rates hit a useful learning range. Each attempt gets up to 1.5 hours in a sandbox, with more than 100 tool calls and over 256K output tokens.
This is the opposite of "scale the data, let the model figure it out." It's surgical. It's also labor-intensive—they reviewed every task alongside the model's attempts, fixing or removing anything that could be gamed without solving the intended problem.
The bet here is that quality compounds in post-training. When you're doing reinforcement learning on long-horizon tasks, a carefully designed problem that teaches the right lesson is worth more than ten mediocre ones. The benchmark gains suggest they're right.
Training Backend: 37% MFU, 2× Faster
This is where things get technical, and where RadixArk's internal training infrastructure shows its edge. They trained in fully asynchronous mode: 128 H200s run inference on agent tasks while 16 more run the trainer. The agent doesn't wait for training, training doesn't wait for the agent. After every step, the updated model ships out to the inference GPUs.
Their backend hit 37% model FLOPs utilization (MFU) on this release. For context, the open-source trainer built on Megatron reached 16% on comparable runs. That's 57% lower training cost for the same work.
The gap widens on mixture-of-experts models. On Qwen3.6-35B-A3B, they report 6.2× better efficiency. On GLM-5.3-Flash (roughly 300B parameters), it's more than 10×.
End-to-end, counting the time the agent spends on tasks, the release run trained at about 16,800 tokens per second across 144 GPUs. The open-source trainer hit about 8,300 tokens per second on the same hardware. That's 2× faster wall-clock time.
Stability Over Weeks
The release run trained for weeks on 144 H200s—63,000 GPU-hours total. From first step to last, speed and efficiency held steady. That's not trivial. Training runs that long tend to degrade, hit weird failure modes, or require manual intervention. Stability at scale is infrastructure maturity showing up in the benchmark numbers.
Their backend handles training steps that learn from a handful of very long sessions, some up to 1M tokens, folded into multiple trajectories via harness summarization. This is built for agent training specifically, not adapted from language model pretraining infrastructure.
Sandbox Service: 944K Runs, 99.95% Success
Every training attempt runs in a sandbox—a fresh environment where the agent executes commands, edits files, and gets graded. RadixArk's service is built on the open-source AgentENV project (which they also contribute to).
Between mid-September and mid-November, the service ran about 944,000 sandboxes for this project. Peak concurrent load: 1,566 sandboxes. The service scaled from one machine to as many as 12, shipped ten upgrades (nearly all while training was running), and maintained 99% success rate overall. Since late October, that figure exceeded 99.95%.
Cloud infrastructure costs for the project's sandboxes ran about 80% lower than using popular cloud sandbox providers. One optimization: letting each sandbox's memory allocation grow and shrink with actual usage, packing more sandboxes per machine.
This is unsexy infrastructure work. It's also the kind of thing that determines whether you can actually train agent models at scale or just talk about it.
What This Means for Post-Training
The open-source RL training ecosystem has been playing catch-up to closed labs for a while now. Miles, RadixArk's framework, is part of that story, but this release is about execution at scale—actually running long training jobs on difficult tasks without everything falling apart.
The efficiency gains matter because they change the economics. If you can train 57% cheaper or 2× faster, you can iterate more. You can try weirder experiments. You can afford to be surgical about task design because the training loop itself isn't the bottleneck.
The task curation philosophy is a bet against pure scale in post-training. It's saying that for agent capabilities, carefully designed problems that target specific weaknesses compound better than thousands of mediocre examples. The Terminal-Bench numbers support that bet, but it's still early.
Try It
The model is available on Hugging Face in BF16, FP8, and NVFP4. RadixArk recommends serving with SGLang and DSpark speculative decoding. The SGLang cookbook has launch configurations for different GPU setups.
The model thinks before answering by default—reasoning appears in reasoning_content, final answer in content. Inference settings follow the standard Qwen chat template with a 256K-token context window.
Miles is open-source if you want to train your own agents. The sandbox service is built on AgentENV, also open-source.
RadixArk wants feedback on where DaisyRose-27B falls short. The interesting part will be seeing whether the efficiency gains and task-curation approach generalize to other domains, or whether this is a local optimum for Terminal-Bench-style problems. Either way, 37% MFU and 2× speedup in post-training infrastructure is worth paying attention to.