ModelsRadixArkDaisyRose-27B
providerRadixArk /

DaisyRose-27B

70 DZD in 875 DZD out 17.5 DZD cached/ 1M tokens

RadixArk’s first model: an agent-tuned reasoning model built on Qwen3.8-27B with reinforcement learning alone on long-horizon agent tasks, keeping the base model’s architecture and image understanding. Reads text, images and PDFs; returns text across a 262K-token window. Deliberation runs by default at four effort levels and can be switched off, alongside tool calling, structured output and prompt caching. Open weights under Apache 2.0.

Publicfp8262144JSONApache 2.0
DaisyRose-27B
Capabilities
  • Tools
  • Vision
  • PDF input
  • Reasoning
  • Structured output
Reasoning
On by defaultreasoning_effort
  • none
  • low
  • medium
  • high

Can be turned off

Tool choice
  • required
  • function
ArchitectureDense Hybrid-Attention Transformer
Context Window262,144 tokensShared by input and output · up to 262,144 output tokens

Use DaisyRose-27B in VS Code, Cursor and Antigravity

DEVUP Code, the DEVUP AI extension, is free to install. Requests are paid from your DEVUP balance.

Explore DEVUP Code

DaisyRose-27B

DaisyRose-27B

DaisyRose-27B is RadixArk's agent-tuned reasoning model. It reads text, images and PDF documents, and writes text. The design target is narrow and deliberate: long-horizon agentic work — the kind of task that runs for hundreds of steps, calls tools repeatedly, and has to stay coherent the whole way.

It is not trained from scratch. DaisyRose-27B is RadixArk's first model: it starts from Qwen3.8-27B and is post-trained with reinforcement learning alone — no supervised fine-tuning, no distillation — on roughly 1,200 curated long-horizon agent tasks. Every capability it inherits, from vision to multilingual coverage to general knowledge, comes from the base model; what the training added is competence at sustained, tool-driven execution.

Architecture, tokenizer and chat template are the base model's, unchanged, so it drops into an existing Qwen3.8-27B integration without code changes.

Weights are open under Apache 2.0, in BF16, FP8 and NVFP4 checkpoints.


At a glance

Model typeMultimodal autoregressive transformer
Base modelQwen3.8-27B
Post-trainingReinforcement learning only, on long-horizon agent tasks
Total parameters27.8B
Vision encoder0.46B, 27 layers
Multi-token-prediction head0.42B, one layer
Layers64 decoder layers, 3:1 linear-attention (Gated DeltaNet) to full-attention
Hidden size5,120
InputText, images, PDF
OutputText
Maximum context size262,144 tokens
Released18 November 2026
LicenseApache 2.0

Maximum context size counts input and output together.


Getting started

BASH
curl https://api.devupai.com/v1/chat/completions \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "RadixArk/DaisyRose-27B",
    "messages": [
      { "role": "user", "content": "A deployment script fails only on the third retry. Where would you look first?" }
    ]
  }'

Python, using the OpenAI client:

PYTHON
from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ["DEVUP_API_KEY"],
    base_url="https://api.devupai.com/v1",
)

response = client.chat.completions.create(
    model="RadixArk/DaisyRose-27B",
    messages=[
        {"role": "user", "content": "A deployment script fails only on the third retry. Where would you look first?"}
    ],
)

print(response.choices[0].message.content)

Node.js:

JAVASCRIPT
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.DEVUP_API_KEY,
  baseURL: "https://api.devupai.com/v1",
});

const response = await client.chat.completions.create({
  model: "RadixArk/DaisyRose-27B",
  messages: [
    { role: "user", content: "A deployment script fails only on the third retry. Where would you look first?" },
  ],
});

console.log(response.choices[0].message.content);

Reasoning

Deliberation runs by default. It arrives as readable text in the response's reasoning field, with a count of the tokens it consumed, so you can show it, log it, or discard it.

Effort is set through reasoning_effort. There are four levels, and high is both the deepest and the default.

LevelBehaviourFits
noneReasoning switched offClassification, extraction, routing, formatting
lowShort deliberationLight judgement calls
mediumBalancedChat, drafting, everyday analysis
highDeepest deliberation — the defaultPlanning, debugging, long agent runs, hard problems

The levels are genuinely graded, not a switch wearing four labels: on a constraint-satisfaction puzzle, low spent around 1,600 reasoning tokens and high around 4,000, with no overlap between repeated runs.

Values above high, such as xhigh, are accepted rather than refused — but they are not extra levels. Measured on the same puzzle, xhigh produced the same volume of deliberation as high, their sample ranges overlapping almost entirely. Passing one costs what high costs and buys nothing more. An unrecognised value is refused outright.

BASH
curl https://api.devupai.com/v1/chat/completions \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "RadixArk/DaisyRose-27B",
    "reasoning_effort": "high",
    "messages": [
      { "role": "user", "content": "Four services each depend on two others, with no cycles. Service A is down. Which can still serve traffic?" }
    ]
  }'

Reading the deliberation and its cost:

PYTHON
response = client.chat.completions.create(
    model="RadixArk/DaisyRose-27B",
    reasoning_effort="high",
    messages=[{"role": "user", "content": "Why would this migration lock the table?"}],
)

message = response.choices[0].message
print(getattr(message, "reasoning", None))
print(response.usage.completion_tokens_details.reasoning_tokens)
print(message.content)

Two ways to switch deliberation off, both producing a response with no reasoning:

JSON
{ "reasoning_effort": "none" }
JSON
{ "reasoning": { "enabled": false } }

Budgeting around deliberation

This model was trained to think at length, and left on its own it will. Reasoning tokens are drawn from the same output budget as the answer, and they are spent first — so a request with a tight max_tokens and effort left high can stop before the answer begins, returning finish_reason: "length" with empty or truncated content.

Three ways out, in order of preference:

  1. Raise max_tokens so the budget covers deliberation plus the answer.
  2. Lower reasoning_effort for work that does not need it.
  3. Set reasoning_effort to none for anything purely mechanical.

Switching deliberation off matters more here than on most models: output tokens are the expensive side of this model's bill, and reasoning is made of output tokens. For extraction, classification and formatting, none is not merely faster — it is the difference between a trivial charge and a large one.

The same logic applies between levels. On the puzzle above, moving from low to high roughly doubled the cost of a single answer. Pick the level the task needs rather than the highest one available.

For genuinely hard problems the opposite advice applies: leave max_tokens unset entirely. Deliberation on those can run to tens of thousands of tokens, and a cap set "just to be safe" is what cuts the answer off.

Carrying reasoning across turns

In a multi-turn conversation, send each earlier assistant turn back with its reasoning intact, not just its final content. The model was trained to read its own prior deliberation, and dropping it degrades later turns.

This is easy to get wrong, because most OpenAI-compatible clients keep only content when they append an assistant message to history. Append the message object as it came back, or copy the reasoning field across yourself.

PYTHON
messages.append(response.choices[0].message)   # keeps content and reasoning

Sampling

With deliberation on, the model's own recommended settings are temperature: 1.0, top_p: 0.95, top_k: 20, min_p: 0 — the same configuration used for its published benchmark runs. Lowering temperature in the hope of steadier reasoning tends to work against a model tuned at these values.


Images

Images are passed as image_url content parts.

BASH
curl https://api.devupai.com/v1/chat/completions \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "RadixArk/DaisyRose-27B",
    "messages": [{
      "role": "user",
      "content": [
        { "type": "text", "text": "This is a failing dashboard. Which panel is the outlier?" },
        { "type": "image_url", "image_url": { "url": "https://example.com/dashboard.png" } }
      ]
    }]
  }'

A data URI works in place of a hosted link:

JSON
{ "type": "image_url", "image_url": { "url": "data:image/png;base64,iVBORw0KGgo..." } }

Several images in one message, each as its own part:

PYTHON
response = client.chat.completions.create(
    model="RadixArk/DaisyRose-27B",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "These are two versions of the same screen. List every difference."},
            {"type": "image_url", "image_url": {"url": "https://example.com/before.png"}},
            {"type": "image_url", "image_url": {"url": "https://example.com/after.png"}},
        ],
    }],
)

Vision comes from the base model rather than from this model's own training, which was text-driven agent work. It handles layout, shapes, charts and screenshots; for dense small text — serial numbers, fine print, tightly packed tables — send a larger or higher-contrast crop, and verify anything you plan to act on. Audio and video are not accepted inputs.


PDF documents

PDF files are passed as file content parts, so a document can go in whole rather than page by page.

JSON
{
  "type": "file",
  "file": {
    "filename": "contract.pdf",
    "file_data": "data:application/pdf;base64,JVBERi0xLjQK..."
  }
}
PYTHON
import base64

with open("report.pdf", "rb") as f:
    pdf_b64 = base64.b64encode(f.read()).decode()

response = client.chat.completions.create(
    model="RadixArk/DaisyRose-27B",
    max_tokens=8192,
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "Which clauses in this contract create an automatic renewal?"},
            {"type": "file", "file": {
                "filename": "report.pdf",
                "file_data": f"data:application/pdf;base64,{pdf_b64}",
            }},
        ],
    }],
)

A long PDF consumes a large share of the window, so send the relevant section rather than an entire archive, and leave headroom for deliberation and the answer.

PDF is not in the model's own published input list, which names text and images only — the documents are read through the same vision pathway. It works, and was verified here, but treat it as a capability of the serving stack rather than a guarantee from the model card.


Tool calling

Functions are declared in tools, and tool_choice accepts auto, required, none or a named function.

BASH
curl https://api.devupai.com/v1/chat/completions \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "RadixArk/DaisyRose-27B",
    "messages": [{ "role": "user", "content": "Which pods in the staging namespace restarted today?" }],
    "tools": [{
      "type": "function",
      "function": {
        "name": "list_pods",
        "description": "List pods in a namespace; call this whenever the user asks about running workloads, restarts or pod health",
        "parameters": {
          "type": "object",
          "properties": {
            "namespace": { "type": "string" },
            "status": { "type": "string", "enum": ["running", "restarted", "failed", "all"] }
          },
          "required": ["namespace"]
        }
      }
    }],
    "tool_choice": "auto"
  }'

The full round trip

PYTHON
import json

messages = [{"role": "user", "content": "Which pods in the staging namespace restarted today?"}]

first = client.chat.completions.create(
    model="RadixArk/DaisyRose-27B",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)

reply = first.choices[0].message
messages.append(reply)

for call in reply.tool_calls or []:
    args = json.loads(call.function.arguments)
    result = list_pods(**args)              # your function
    messages.append({
        "role": "tool",
        "tool_call_id": call.id,
        "content": json.dumps(result),
    })

second = client.chat.completions.create(
    model="RadixArk/DaisyRose-27B",
    messages=messages,
    tools=tools,
)

print(second.choices[0].message.content)

The assistant message carrying the tool calls must go back into the history before the tool results, and every tool_call_id must match. A missing one breaks the turn.

Forcing a named function, when the next step is fixed and you only want the arguments filled in:

JSON
{ "tool_choice": { "type": "function", "function": { "name": "list_pods" } } }

tool_choice: "required" forces some call without naming which; "none" keeps the tools visible as context while blocking the model from calling them.

Building agent loops

This is the workload the model was trained for, so it rewards being given real room to work. Its training tasks ran past a hundred tool calls per attempt.

  • Let the loop run. A cap of three or four iterations cuts short the behaviour the training optimised for. Budget for tens of steps on genuinely long tasks.
  • Describe when to call, not just what. "List pods in a namespace" is weaker than the same line followed by "call this whenever the user asks about running workloads, restarts or pod health."
  • Return errors as data. {"error": "namespace not found", "available": [...]} keeps the loop going; an exception ends it.
  • Keep the tool surface tight. A handful of well-described functions beats thirty overlapping ones.
  • Use enum for closed sets instead of describing the options in prose.

Structured output

Both json_object and json_schema are accepted. Prefer json_schema with strict: true — it constrains the shape rather than merely requesting it.

BASH
curl https://api.devupai.com/v1/chat/completions \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "RadixArk/DaisyRose-27B",
    "reasoning_effort": "none",
    "max_tokens": 4096,
    "messages": [
      { "role": "user", "content": "Extract the service, severity and first-seen time from: checkout-api, SEV2, first seen 2026-11-18T09:14Z." }
    ],
    "response_format": {
      "type": "json_schema",
      "json_schema": {
        "name": "incident",
        "strict": true,
        "schema": {
          "type": "object",
          "properties": {
            "service": { "type": "string" },
            "severity": { "type": "string" },
            "first_seen": { "type": "string" }
          },
          "required": ["service", "severity", "first_seen"],
          "additionalProperties": false
        }
      }
    }
  }'

Notes that save debugging time:

  • Keys may arrive in a different order from the schema. The values and types follow it; the order does not. Parse, never pattern-match on position.
  • additionalProperties: false is what stops extra keys appearing.
  • Set reasoning_effort to none for pure extraction. On this model that is the single largest saving available.
  • Always check finish_reason. "length" means the budget ran out and the JSON is incomplete.

Streaming

PYTHON
stream = client.chat.completions.create(
    model="RadixArk/DaisyRose-27B",
    messages=[{"role": "user", "content": "Walk through how a write-ahead log recovers after a crash."}],
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta
    if delta.content:
        print(delta.content, end="", flush=True)

With reasoning on, deliberation streams before the answer. Render it in a separate region from the final content, or hide it until the answer begins — mixing the two confuses readers who do not expect the model to think out loud.


Prompt caching

A repeated opening section of a conversation is served from cache and billed at the cached-input rate. The rule is simple: stable content first, variable content last.

PYTHON
messages = [
    {"role": "system", "content": LONG_SYSTEM_INSTRUCTIONS},   # unchanged every call
    {"role": "user", "content": REFERENCE_DOCUMENTS},          # unchanged every call
    {"role": "user", "content": todays_question},              # changes
]

The cache matches on an exact prefix. One edited character near the top invalidates everything after it, so anything that varies — a timestamp, a user ID, a request counter — belongs at the end, never in the system message.

This pays off especially in agent loops, where the same system prompt and tool definitions are resent on every iteration.


Long context

The window holds 262,144 tokens across input and output combined — enough for a large codebase section, a full document set, or a long agent transcript with everything it has read along the way.

Practical limits worth knowing:

  • Images and PDFs count against the same budget as text, and consume it quickly.
  • Leave headroom for the answer and for deliberation tokens when reasoning is on.
  • Position still matters. Put the question near the end, after the material it refers to.
  • In a long agent run, the transcript grows with every tool result. Summarise or drop old steps before the window fills, rather than after.

Performance

Benchmark comparison across seven benchmarks

The interesting comparison is against the base model, since the two differ only by reinforcement learning. Figures are RadixArk's own.

BenchmarkQwen3.8-27B baseDaisyRose-27B
Terminal Bench 4.1 (pass@1)5.612.0
Terminal Bench 2.173.075.5
DeepSWE v1.142.246.2
SWE Bench Pro v291.394.7
HLE (text only)33.934.3
IFBench79.582.4
GPQA Diamond89.290.7

Read the shape, not just the numbers. Terminal Bench 4.1 more than doubles; SWE Bench Pro and the agentic rows move several points; HLE — raw knowledge-heavy reasoning — barely moves at all. That is what post-training on agent tasks does and does not buy. If your workload is long-horizon tool use, the gain is real; if it is one-shot factual reasoning, expect the base model's behaviour.

Against larger models

RadixArk also publishes a comparison against models several times its size. The figures for other models are those their own developers or leaderboards report.

BenchmarkDaisyRose-27BInkling 2 SmallMuse Spark OpenGPT-6 Luna
Activated parameters27B17B42B—
Total parameters27B594B816B—
Terminal Bench 4.112.013.06.615.2
Terminal Bench 2.175.581.376.473.0
DeepSWE v1.146.272.160.066.6
SWE Bench Pro v294.797.795.0—
HLE (text only)34.344.143.938.5
GPQA Diamond90.793.089.090.5

It does not win most rows, and the gap on DeepSWE and HLE is wide. The claim worth taking from this table is narrower and more useful: a dense 27B model stays within a few points of systems with twenty to thirty times its parameter count on several agentic and reasoning rows, and beats some of them outright. That is an argument about cost and deployability, not about being the strongest model available.

All DaisyRose figures come from runs in thinking mode at the recommended sampling settings, with no output cap, repeated four to eight times per benchmark. They are self-reported. Measure on your own task before relying on any column.


How it was trained

Training stability across 18 days on 144 H200 GPUs

The release run used 63,000 GPU-hours: 18 days on 144 H200s, split between 128 running the agent against its tasks and 16 training on the finished trajectories. Training was fully asynchronous, over roughly 1,200 curated long-horizon agent tasks — each a set of interdependent problems, each attempt exceeding a hundred tool calls and 256K output tokens, with sessions reaching a million tokens. Every task was reviewed alongside the model's attempts at it.

The vision encoder and the multi-token-prediction head were left as the base model's throughout; reinforcement learning touched the language model only.

The point of publishing that figure is efficiency rather than scale — the claim is that this much capability gain is reachable with a modest post-training budget on an existing open base. For anyone evaluating the model, the useful implication is that its strengths are concentrated exactly where that training pointed.


Choosing settings

TaskSuggested configuration
Classification, routing, extractionreasoning_effort: "none"
Chat and draftingreasoning_effort: "medium"
Planning, hard debugging, multi-step analysisreasoning_effort: "high", max_tokens unset
Multi-turn conversationAppend each assistant message whole, reasoning included
Agent loopstools plus tool_choice: "auto", generous iteration budget
Machine-readable resultsresponse_format with json_schema, strict: true, reasoning_effort: "none"
Screenshots, charts, diagramsimage_url parts
Contracts, reports, scanned documentsfile parts with a PDF
Repeated long preamblesStable content first, variable content last
Interactive interfacesstream: true, deliberation rendered separately

Common pitfalls

SymptomCauseFix
Empty or truncated reply, finish_reason: "length"Deliberation consumed the output budgetRaise max_tokens or lower reasoning_effort
Invalid JSON from a schema requestSame cause — the object was cut offCheck finish_reason before parsing; raise the budget
Unexpectedly large output chargesReasoning left on for mechanical workSet reasoning_effort: "none"
Tool results ignoredThe assistant message with the calls was not added back, or an id mismatchedAppend the assistant message, then one tool message per tool_call_id
Agent gives up earlyIteration cap too low for the taskRaise the loop budget; this model is built for long runs
Later turns in a conversation get worseEarlier reasoning was dropped from the historyAppend the whole assistant message, not just its content
xhigh costs more than expected but answers no betterIt is not a level above highUse high
A digit or code misread from an imageSmall or low-contrast textSend a larger crop; verify before acting
Caching never seems to hitSomething variable sits near the top of the promptMove every changing value to the end
Keys in the wrong orderOrder is not constrained by the schemaParse the JSON; do not read by position

Limits to keep in mind

Like any model of this kind, DaisyRose-27B can state something false with confidence, miss part of a precise instruction, and lose coherence over very long multi-turn exchanges. Quality varies across languages and domains, and its knowledge ends at its base model's training cutoff — reinforcement learning on agent tasks adds skill, not facts.

Its strengths are concentrated in long-horizon tool use. For one-shot factual questions, straight knowledge recall, or fine-detail reading of dense images, expect the behaviour of a 27B base model rather than the benchmark headlines.

For consequential work, measure it on your own task before relying on it, add checks in your application, and keep a person in the loop.


References