DaisyRose-27B: Efficient Post-Training at Scale13 min read2,688 words

DaisyRose-27B: Efficient Post-Training at Scale

See how DaisyRose-27B improved benchmark scores with 1,200 curated tasks, asynchronous reinforcement learning and a more efficient training stack.

DaisyRose-27BLLM post-trainingreinforcement learning for AIagent training infrastructureAI model benchmarks
DaisyRose-27B: Efficient Post-Training at Scale

DaisyRose-27B Shows What Efficient LLM Post-Training Can Do

Training a capable AI agent isn't just a matter of buying more GPUs. You need tasks that actually expose the model's weak spots, an environment where the agent can run reliably, and a training setup that can learn from long, expensive sessions without wasting hardware. If any one of those falls apart, more compute mostly just makes the bill bigger.

DaisyRose-27B is RadixArk's first model. It's built on Qwen3.8-27B and post-trained with reinforcement learning using the Miles framework. RadixArk says it trained on 1,200 curated long-horizon tasks over 18 days using 144 H200 GPUs. Its reported Terminal-Bench 4.1 pass@1 score rose from 5.6% for the base model to 12.0% for DaisyRose-27B.

That result is the headline, but the more useful part is how the team put the pieces together. Task selection, asynchronous training, and sandbox reliability were treated as one system. This article breaks down those choices, what the reported benchmarks show (and what they don't), and what teams building specialized models can take from the release - without pretending one run is a universal recipe.

What is DaisyRose-27B, and what changed?

DaisyRose-27B is a post-trained version of Qwen3.8-27B, not a scratch-built model. RadixArk used reinforcement learning on agent tasks that require the model to reason, plan, use tools, and finish work inside a software environment. That distinction matters: the release is really about adapting a base model to new capabilities, not replacing existing large language model pretraining.

The training set included about 1,200 tasks selected from thousands of candidates developed with Eigent AI. Individual attempts could run for up to 1.5 hours, use more than 100 tool calls, and produce more than 256,000 output tokens. The source also describes training sessions as large as one million tokens, with sessions summarized into multiple trajectories for learning.

This is a different operating profile than short question-and-answer fine-tuning. In a long agent task, a mistake early on can show up only several steps later. The agent may have to inspect files, run commands, interpret results, and revise the plan. Training on those sequences is aimed at improving behavior across a chain of decisions, not just polishing single responses.

The release is about adaptation, not just model size

The model has 27 billion total parameters and activated parameters, according to the reported benchmark table. Its base is Qwen3.8-27B; the claimed improvement comes from post-training plus the data and infrastructure around it. For teams deciding between training and fine-tuning, the practical point is simple: specialization can target a capability gap without the cost and risk of building a foundation model from the ground up.

RadixArk reports BF16, FP8, and NVFP4 checkpoints. These formats trade off numerical precision, memory needs, and inference efficiency. Which one makes sense depends on your hardware and use case. A smaller checkpoint can be easier to deploy, but you still need to validate quality and performance in your own serving setup rather than assuming different formats behave identically across workloads.

Why did task design matter so much?

The training set was built around a straightforward idea: a model learns more from tasks that expose a specific weakness than from a pile of generic exercises. RadixArk says it ran the original model on candidate tasks, then adjusted them to surface mistakes and land at a difficulty level where the model could still learn.

That curation has to be careful. If a task is too easy, it doesn't provide much useful signal. If it's effectively impossible, attempts won't tell you much either. The right difficulty depends on the starting model and the target behavior, so you can't set it just by reading task descriptions. Running the baseline model on candidate tasks gives the team evidence about where it succeeds and where it breaks.

Long-horizon tasks test the whole workflow

Each selected task chained multiple dependent steps. That pushes the agent to hold context across stages: understand the goal, decide what to do, use tools, verify results, and recover when something doesn't work. A model can look fine on isolated code snippets but still struggle to complete a realistic job with many steps.

Long tasks also cost more to run. One attempt can tie up a sandbox for a while and generate a lot of data. That's exactly why task quality matters here. When rollouts are expensive, collecting thousands of weak examples is usually a poor substitute for selecting a smaller set that produces meaningful learning signals.

Reward hacking is a data-quality problem

RadixArk says reviewers inspected tasks alongside model attempts and removed or fixed tasks that could be passed without actually solving the underlying problem. That's a central issue for reinforcement learning with agents. If a grader rewards a shortcut, the model can learn to exploit the measurement instead of producing the outcome a user actually needs.

The practical takeaway is to treat task design, environment design, and grading as one system. A task needs a clear success condition - but that condition has to match the intended outcome. For example, in a software task, credit shouldn't hinge on a plausible explanation if the required change doesn't work. Human review helps find these gaps, though it can't prove that every possible shortcut is eliminated.

How did the training infrastructure reduce cost?

RadixArk trained DaisyRose-27B with Miles, its open-source reinforcement learning framework, in a fully asynchronous setup. In broad terms, agent workers kept running tasks while the model trainer learned from completed trajectories. The system didn't have to pause training every time it waited for all jobs to finish.

For the run, RadixArk used 128 H200 GPUs for agent inference and 16 for training. After a training step, the updated model was sent to the inference group. This split reflects what long-horizon agent work looks like: generating a useful trajectory can take much longer than processing a short training example, so a synchronized workflow risks leaving parts of the system idle.

GPU utilization and end-to-end throughput

RadixArk reports 37% model FLOPs utilization (MFU) for the Qwen3.8-27B training backend, versus 16% for the open-source trainer in comparable runs. The company frames this as 57% less GPU time for the same training needs. It also reports end-to-end throughput of about 16,800 tokens per second across 144 GPUs, compared with about 8,300 for the open-source trainer.

Those numbers are interesting, but they need context. MFU is about how much theoretical GPU compute is used for model work; it doesn't directly measure business value or model quality. End-to-end throughput is more relevant when the training run includes agent work, but comparisons still depend on workload, configuration, and exactly what the metric includes. The source says the runs are comparable, but teams should check the details before applying the same conclusions to their own model and workload.

RadixArk also reports larger utilization differences for mixture-of-experts models: 6.2 times on Qwen3.6-35B-A3B and more than 10 times on the roughly 300B-parameter GLM-5.3-Flash. Those are specific comparisons, not a guarantee that every team will see the same multiplier. The broader point stands: training systems have to be tuned for the workload they actually run, especially when agent rollouts and model updates have very different runtimes.

Stability is part of efficiency

The release run used 144 H200 GPUs over 18 days, which RadixArk describes as 63,000 GPU-hours. The source says speed and efficiency stayed steady throughout, with median training-step speed of 19,300 tokens per second and median MFU of 37%.

A good start doesn't help if the infrastructure degrades over a long run. If jobs stall, sandboxes fail, or the team has to step in repeatedly, the theoretical advantage of a faster backend can disappear fast. For a production-minded team, sustained throughput and solid failure recovery matter because they determine whether the training budget stays predictable.

What do the benchmark results actually show?

RadixArk reports that DaisyRose-27B beat its Qwen3.8-27B base model on all seven benchmarks in the release comparison. The biggest absolute change was on Terminal-Bench 4.1, which is aimed at longer terminal-based agent work.

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

Terminal-Bench 4.1 goes from 5.6 to 12.0, more than doubling the score in that comparison. That's a real relative improvement, but the absolute number still needs interpretation. A score of 12.0 doesn't mean the model reliably finishes every difficult terminal task. At best, this reads as progress on a hard evaluation - not a blanket claim about overall agent reliability.

Evaluation details affect interpretation

For Terminal-Bench 4.1, the source says the score averaged eight runs per task using an internal mini-swe-agent harness with summarization enabled. Terminal-Bench 2.1 averaged five runs using the Terminus 2 harness. DeepSWE v1.1 and SWE-Bench Pro v2 used eight and five runs, respectively, with the mini-swe-agent harness.

Other benchmarks used different methods. HLE text-only was averaged over five runs per problem and used no tools. IFBench averaged four runs for each of 300 prompts and used the official scorer. GPQA Diamond used eight runs on each of 198 questions, with answer order reshuffled.

These details matter because scores depend on the harness, number of runs, tool setup, and grading rules. If you're comparing models, it's worth logging the evaluation conditions alongside the score and then running representative tests in the environment your product actually uses. Benchmarks can suggest direction, but they can't replace testing on your own tasks, your own users, and your own failure costs. That's especially true for agent systems, where tool configuration and execution reliability can change what the score is really measuring.

What can AI teams learn from this release?

The first lesson is to start with a capability gap, not with a training recipe. RadixArk selected tasks by running the base model first and then targeting the failures it showed. That's more actionable than collecting a large dataset without a clear story about what the model can't do.

Second, plan for the whole learning loop. Agent training includes task generation, rollout execution, grading, data processing, model updates, and infrastructure operations. If you only optimize the trainer, you can miss where the real bottleneck lives. If sandboxes are slow or flaky, a faster learner can end up waiting for trajectories. If grading is weak, extra compute can efficiently reinforce the wrong behavior.

A practical sequence for a specialized post-training project

  1. Define the target behavior. Spell out what "success" looks like in observable terms, including which mistakes are most costly.
  2. Measure the starting point. Run the base model on representative tasks. Capture failure modes - not just aggregate accuracy - so training examples target the weaknesses you care about.
  3. Build tasks with meaningful difficulty. Keep tasks solvable but challenging, and make sure each one forces the behavior you want.
  4. Audit graders and shortcuts. Review both successful and failed attempts, and look for ways to earn reward without delivering the intended result.
  5. Measure the full pipeline. Track rollout throughput, training utilization, sandbox success, time spent on failures, and total cost per useful trajectory.
  6. Validate on held-out, real workflows. Keep evaluation tasks separate from training and test in the environment where the model will actually run.

This doesn't guarantee benchmark gains. It just reduces the odds of spending heavily on data and infrastructure before you're sure what problem you're trying to solve. The right scale depends on the product: a narrow internal coding assistant and a general-purpose research agent have different risk profiles and different evaluation needs.

Sandboxes are production infrastructure

RadixArk says its sandbox service ran about 944,000 environments for the project, with as many as 1,566 running concurrently. It reports 99% successful sandbox creations across nine weeks, improving to more than 99.95% from late October. The service grew from one machine to as many as 12, with ten upgrades during the project.

That's the kind of detail people gloss over when they focus only on model quality. A sandbox is part of the agent's effective training environment: it affects whether actions can run, whether state is isolated, and whether results can be graded consistently. Failures here waste GPU time and produce noisy training data. So treating sandbox capacity and reliability as first-class engineering isn't just an infrastructure choice - it feeds back into model quality.

RadixArk also reports sandbox infrastructure costs about 80% below popular cloud sandbox providers for similar workloads. One technique was letting sandbox memory allocation expand or shrink based on actual use, since environments often need less memory than they request. That can improve density, but it requires monitoring and safeguards: aggressive overcommitment can turn cost savings into contention or failures when load spikes.

Key takeaways

  • DaisyRose-27B is a Qwen3.8-27B model post-trained with reinforcement learning, not a model trained from scratch.
  • RadixArk links the gains to three connected elements: curated tasks, asynchronous training infrastructure, and reliable sandboxes.
  • Terminal-Bench 4.1 pass@1 rose from 5.6% to 12.0%; other benchmarks also improved, though the evaluation methods vary.
  • Metrics like MFU, throughput, and cost savings are workload-specific. Validate them with your own model, hardware, and task mix.
  • For teams, the best starting point is a measured capability gap and a trustworthy evaluation loop - not just more tasks or more GPUs.

Conclusion

DaisyRose-27B is a solid case study in post-training as a systems problem. The reported gains didn't come from benchmark tuning alone: the team connected task selection, reward design, model updates, and sandbox operations into one training loop. That integration is the main idea worth borrowing for other projects.

The numbers are promising, but they're also company-reported results under specific evaluation conditions. If you're considering post-training, start by identifying a real failure mode, build tasks that expose it, and measure the end-to-end cost and reliability of the learning loop. More compute helps only when the system is producing useful evidence for the model to learn from.

Frequently Asked Questions

DaisyRose-27B is RadixArk’s post-trained version of Qwen3.8-27B. The company used reinforcement learning with Miles on long-horizon agent tasks. It reports releasing BF16, FP8 and NVFP4 checkpoints for developers to evaluate and build on.
RadixArk says the model was trained on about 1,200 curated tasks over 18 days using 144 H200 GPUs. The source describes the run as totaling 63,000 GPU-hours and says agent attempts could last up to 1.5 hours.
The reported pass@1 score increased from 5.6% for the Qwen3.8-27B base model to 12.0% for DaisyRose-27B. The result is a substantial improvement in that evaluation, but it does not establish reliable performance across every terminal task or deployment setting.
RadixArk points to an asynchronous training setup, a backend optimized for long agent trajectories and a sandbox service designed to run many tasks reliably. It reports 37% MFU and about 16,800 tokens per second end to end, while noting comparisons with its open-source trainer.

Related articles