RadixArk released its first public model post-trained solely with reinforcement learning on November 18, 2026. In its official evaluations, Terminal Bench 2.1 rose from the base model's 73.0 to 75.5. DeepSWE v1.1 rose from 42.2 to 46.2. Developers can retain their existing runtime and swap in the new weights, the learned numerical values that determine model behavior. They can then test performance on agent tasks involving multiple steps of tool use.
1. Training on long tasks instead of teaching correct answers
DaisyRose-27B is an image-understanding and reasoning model based on Qwen3.8-27B. It used reinforcement learning alone, without supervised fine-tuning on example answers or distillation from another model's outputs. It retains the base model's architecture, chat template, image-understanding capabilities, and 256K-token context length.
The training data consists of about 1,200 tasks selected from thousands of candidates developed with Eigent AI. Tasks targeted the base model's failures. Tasks that could be passed without solving the intended problem were revised or removed. Each attempt allowed up to 1.5 hours in an isolated execution environment, a space separated from other tasks. It also allowed over 100 tool calls and over 256K output tokens.
2. Running agents and training simultaneously
The open-source training tool Miles kept training running while agents worked. A total of 128 H200 GPUs executed tasks, while 16 trained on completed task records and sent updated weights back to the execution side at each step. Sessions of up to 1 million tokens were summarized and split into multiple training records.
According to the company blog, training used about 63,000 GPU-hours over 18 days on 144 H200 GPUs. Its in-house backend, the internal component that processes computation requests, achieved 37% GPU compute utilization. A Megatron-based open-source trainer, software that runs model training, achieved 16% in a comparable run. The in-house backend reduced GPU time for the same training by 57%. Throughput, the number of tokens processed per unit of time, includes agent task execution time here. On the same 144 GPUs, it reached about 16,800 tokens per second versus about 8,300 for the comparison system.
3. Check repetition counts and evaluation versions for official scores
According to the model card, the new model's scores are the higher results from BF16 and FP8 runs, two numerical precision formats for weights. Scores differ by less than 1 point on evaluations run in both formats. The company evaluated the new model at its default highest reasoning effort, with no separate output-length cap within the context window.
The company reports a single-attempt success rate of 12.0% on Terminal Bench 4.1. It averaged 8 attempts per task, with summarization enabled in mini-swe-agent, its internal evaluation runner.
Selected evaluations from the official comparison table are shown alongside the base model below.
Table: Selected evaluation scores for the base model and DaisyRose-27B
Conditions: Reported scores for matching evaluation versions in the model card; base-model scores are from external sources, and new-model scores are the higher of BF16 and FP8
Unit: points
| Evaluation | Qwen3.8-27B | DaisyRose-27B |
|---|---|---|
| Terminal Bench 2.1 | 73.0 | 75.5 |
| DeepSWE v1.1 | 42.2 | 46.2 |
| HLE text | 33.9 | 34.3 |
Terminal Bench 2.1 improved by 2.5 points and DeepSWE v1.1 by 4.0 points, while the HLE text difference is 0.4 points. Gains vary by task, so users should examine evaluations relevant to their intended work.
For Terminal Bench 2.1, the new model was evaluated with Terminus 2 over 5 attempts per task.
For DeepSWE v1.1, the new model was evaluated with mini-swe-agent over 8 attempts per task.
The new model scored 94.7 on SWE Bench Pro v2, using the same evaluation tool over 5 attempts per task.
HLE text evaluates the ability to answer text questions without tools. The new model answered each question 5 times, with GPT-6 Luna grading the responses.
IFBench, which measures instruction following, scored the base model at 79.5 and the new model at 82.4. The new model answered 300 prompts 4 times each, with final responses evaluated by the official scorer.
GPQA Diamond, a science knowledge and reasoning evaluation, scored the base model at 89.2 and the new model at 90.7. The new model answered 198 questions 8 times each, shuffling the answer choices each time.
However, the base model's 5.6% in the comparison table is a Terminal Bench 4.0 result, so its evaluation version differs from the new model's. The base model's 91.3 on SWE Bench Pro v2 came from a separate paper covering all 642 tasks. Models reporting only a difficult subset were left blank in this table.
4. Choose a weight format and call an existing server
The company recommends SGLang and DSpark speculative decoding, which generates subsequent tokens in advance and verifies them. The official deployment guide provides runtime settings for each GPU and weight format.
The weights are released under the Apache-2.0 license. The model card lists the following weight sizes by format.
Table: Released weight sizes by format
Conditions: DaisyRose-27B weights, approximate sizes by format listed in the model card
Unit: GB
| Format | Weight size |
|---|---|
| BF16 | 52 |
| FP8 | 29 |
| NVFP4 | 23 |
For weights alone, FP8 is about 23GB smaller than BF16, and NVFP4 is about 29GB smaller, so the space needed to store weights varies by format. This does not indicate total runtime memory requirements or speed differences. The company says the model can run on a single GPU, and NVFP4 requires a Blackwell GPU. Developers can choose a format suited to their hardware, start a server, and call it using this model-card example.
from openai import OpenAI
client = OpenAI(base_url="http://localhost:30000/v1", api_key="none")
SAMPLING = dict(temperature=1.0, top_p=0.95, extra_body={"top_k": 20, "min_p": 0.0})
resp = client.chat.completions.create(
model="DaisyRose-27B",
messages=[{"role": "user", "content": "How many positive divisors does 360 have?"}],
**SAMPLING,
)By default, the model reasons before answering, returning its reasoning in reasoning_content and its final response in content. In multi-turn conversations, sending earlier reasoning along with the conversation lets the chat template preserve it.
5. Compute savings versus task and reasoning costs
The company blog reports cloud infrastructure costs for its in-house sandbox, a restricted space for running programs. These costs were about 80% lower than running the same work with a popular cloud sandbox provider. However, this required task selection and review as well as execution-environment operations. The project operated about 944,000 sandboxes. During use, reasoning that stretches to tens of thousands of tokens increases response time and token consumption. Conversations that resend earlier reasoning also increase request size.
DaisyRose-27B lets teams test RL post-training in existing runtimes, with adoption depending on task-specific gains versus the costs of long reasoning.
