Ornith-1.0-9B

Parsing Reasoning from Answer

When using HuggingFace Transformers directly (without a serving runtime), split the reasoning trace from the final answer by parsing on the </think> marker:

text = tokenizer.decode(output_ids, skip_special_tokens=True)
if "</think>" in text:
    reasoning, answer = text.split("</think>", 1)
    reasoning = reasoning.replace("<think>", "").strip()
    answer = answer.strip()
else:
    reasoning, answer = "", text.strip()

This separates the model's internal reasoning (the <think> block) from the final user-facing answer.

Reasoning Mode and Thinking Blocks

Ornith-1.0-9B is a reasoning model: by default the assistant turn opens with a <think> … </think> block before the final answer.

Serving with Reasoning Parser

When served via vLLM or SGLang with --reasoning-parser qwen3, the chain-of-thought is returned in a separate reasoning_content field:

message = response.choices[0].message
print("reasoning:", getattr(message, "reasoning_content", None))
print("answer:", message.content)

Tool Call Parser

Ornith-1.0-9B also supports tool calling via the qwen3_xml (vLLM) or qwen3_coder (SGLang) tool-call parser, which surfaces <tool_call> blocks as OpenAI-style tool_calls.

License Information

License: MIT

Ornith-1.0-9B is MIT licensed, globally accessible, and free from regional limitations.

• Repository and weights: MIT licensed
• Commercial use: Allowed
• Open source: Yes
• Regional restrictions: None

This makes Ornith-1.0-9B suitable for both research and commercial applications without licensing constraints.

Model Tree and Community

Model Tree for ornith-ai/Ornith-1.0-9B

Quantizations are available for: llama.cpp, LM Studio, Jan, and Ollama.

Collection

Ornith-1.0 — A family of open-source LLMs specialized for agentic coding.

• 8 items in the collection
• Updated 5 days ago
• 388 views

Community

• Spaces using this model: 10
• Followers: 2,850
• Downloads (last month): 2,206,037
• Likes: 538
• Community discussions: 15

Base Model

This model is listed as a base model for finetunes, quantizations, and adapters. The Ornith-1.0 family includes:

• 9B-Dense (this model)
• 31B-Dense
• 35B-MoE
• 397B-MoE (post-trained on top of Gemma 4 and Qwen 3.5)

Citation

If you find this work helpful, please cite:

@misc{ornith_9b,
    title = {{Ornith-1.0-9B}: Agentic Coding, Open to All},
    url = {https://deep-reinforce.com/ornith_1_0.html},
    author = {{DeepReinforce Team}},
    year = {2026}
}

• Blog post: https://deep-reinforce.com/ornith.html
• Ornith 1.0 blog: https://deep-reinforce.com/ornith_1_0.html

Recommended Sampling Parameters

For optimal performance with Ornith-1.0-9B:

Benchmark Reproduction

To reproduce the reported benchmark scores, use:

⚠️ Note: Benchmark evaluation uses temperature=1.0 and top_p=1.0, while general usage recommends temperature=0.6 for more focused outputs.

Integration with Development Tools and Frameworks

Ornith-1.0-9B is optimized for terminal-based coding agents and works with any OpenAI-compatible endpoint.

Hermes Agent

export OPENAI_BASE_URL="http://localhost:8000/v1"
export OPENAI_API_KEY="EMPTY"
export MODEL="deepreinforce-ai/Ornith-1.0-9B"

Atomic.chat / Ollama / llama.cpp

## llama.cpp — serve an OpenAI-compatible API on port 8000
llama-server -hf deepreinforce-ai/Ornith-1.0-9B-GGUF --port 8000 -c 262144

## Ollama — pull and chat with the same GGUF straight from Hugging Face
ollama run hf.co/deepreinforce-ai/Ornith-1.0-9B-GGUF

OpenClaw

export OPENAI_BASE_URL="http://localhost:8000/v1"
export OPENAI_API_KEY="EMPTY"
export OPENAI_MODEL="deepreinforce-ai/Ornith-1.0-9B"

Unsloth Studio

pip install unsloth

from unsloth import FastLanguageModel
model, tokenizer = FastLanguageModel.from_pretrained(
    "deepreinforce-ai/Ornith-1.0-9B",
    max_seq_length=262144,
    load_in_4bit=True,
)

OpenHands

pip install openhands-ai
export LLM_MODEL="openai/deepreinforce-ai/Ornith-1.0-9B"
export LLM_BASE_URL="http://localhost:8000/v1"
export LLM_API_KEY="EMPTY"
openhands

OpenCode

// ~/.config/opencode/opencode.json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "ornith": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Ornith (local)",
      "options": { "baseURL": "http://localhost:8000/v1", "apiKey": "EMPTY" },
      "models": { "deepreinforce-ai/Ornith-1.0-9B": { "name": "Ornith-1.0-9B" } }
    }
  }
}

Agent Framework Integration via MCP

Ornith-1.0-9B exposes an OpenAI-compatible endpoint with tool calling, so it works out of the box with standard agent frameworks. Below is a minimal example connecting Ornith to tools through an MCP server:

import os
from openai import OpenAI

client = OpenAI(
    base_url=os.getenv("OPENAI_BASE_URL", "http://localhost:8000/v1"),
    api_key=os.getenv("OPENAI_API_KEY", "EMPTY"),
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "run_shell",
            "description": "Run a shell command and return its output.",
            "parameters": {
                "type": "object",
                "properties": {
                    "command": {"type": "string", "description": "The command to run"}
                },
                "required": ["command"],
            },
        },
    }
]

messages = [{"role": "user", "content": "List the Python files in the current directory."}]

response = client.chat.completions.create(
    model="deepreinforce-ai/Ornith-1.0-9B",
    messages=messages,
    tools=tools,
    temperature=0.6,
    top_p=0.95,
)
print(response.choices[0].message)

Tool Calling via Chat Completions API

Ornith-1.0-9B emits well-formed function calls that the serving runtime parses into the standard tool_calls field:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="EMPTY",
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather for a city",
            "parameters": {
                "type": "object",
                "properties": {"city": {"type": "string"}},
                "required": ["city"],
            },
        },
    }
]

response = client.chat.completions.create(
    model="Ornith-1.0-9B",
    messages=[{"role": "user", "content": "What is the weather in Paris right now?"}],
    tools=tools,
    tool_choice="auto",
    temperature=0.6,
    max_tokens=2048,
)

tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.function.name, tool_call.function.arguments)
## -> get_weather {"city": "Paris"}

Any OpenAI-compatible SDK (Python, Node.js, etc.) or curl can target the same endpoint.

Basic Chat Completions API Usage

Once a vLLM or SGLang server is running, talk to it with any OpenAI-compatible client:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="EMPTY",  # any non-empty string works for a local server
)

response = client.chat.completions.create(
    model="Ornith-1.0-9B",
    messages=[
        {"role": "user", "content": "Write a one-line Python lambda that squares a number."}
    ],
    temperature=0.6,
    top_p=0.95,
    max_tokens=1024,
)

message = response.choices[0].message
## reasoning_content holds the <think> trace; content holds the final answer.
print("reasoning:", getattr(message, "reasoning_content", None))
print("answer:", message.content)

You can also stream tokens, or use curl with the same /v1/chat/completions endpoint.

Serving with Hugging Face Transformers

For quick local testing or offline generation, load the model directly with Transformers (≥ 5.8.1):

from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "deepreinforce-ai/Ornith-1.0-9B"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    dtype="auto",
    device_map="auto",
)

messages = [
    {"role": "user", "content": "Write a Python function is_prime(n). Keep it short."}
]
text = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True,
)

inputs = tokenizer(text, return_tensors="pt").to(model.device)
generated = model.generate(
    **inputs,
    max_new_tokens=512,
    do_sample=True,
    temperature=0.6,
    top_p=0.95,
    top_k=20,
)
output_ids = generated[0][inputs.input_ids.shape[1]:]

## The reply contains a <think> ... </think> reasoning block followed by the answer.
content = tokenizer.decode(output_ids, skip_special_tokens=True)
print(content)

See the Transformers installation guide for setup instructions.

Serving with SGLang

Ornith-1.0-9B can be served via SGLang with an OpenAI-compatible API:

python -m sglang.launch_server \
    --model-path deepreinforce-ai/Ornith-1.0-9B \
    --served-model-name Ornith-1.0-9B \
    --host 0.0.0.0 --port 8000 \
    --context-length 262144 \
    --mem-fraction-static 0.85 \
    --tool-call-parser qwen3_coder \
    --reasoning-parser qwen3

Key flags:

• --reasoning-parser qwen3 — separates thinking blocks into reasoning_content field
• --tool-call-parser qwen3_coder — parses tool calls into standard format
• --context-length 262144 — full 256K context window
• --mem-fraction-static 0.85 — static memory fraction for KV cache

Minimum version: SGLang ≥ 0.5.9

Serving with vLLM

Ornith-1.0-9B serves comfortably on a single 80GB GPU via vLLM with an OpenAI-compatible server:

vllm serve deepreinforce-ai/Ornith-1.0-9B \
    --served-model-name Ornith-1.0-9B \
    --host 0.0.0.0 --port 8000 \
    --max-model-len 262144 \
    --gpu-memory-utilization 0.90 \
    --enable-prefix-caching \
    --enable-auto-tool-choice --tool-call-parser qwen3_xml \
    --reasoning-parser qwen3 \
    --trust-remote-code

Key flags:

• --reasoning-parser qwen3 — separates thinking blocks into reasoning_content field
• --tool-call-parser qwen3_xml — parses tool calls into OpenAI-style tool_calls
• --enable-prefix-caching — optimizes repeated prompt prefixes
• --max-model-len 262144 — full 256K context window

Add --tensor-parallel-size N to shard across multiple GPUs.

Runtime Requirements

Serving Ornith-1.0-9B requires recent runtime versions:

Hardware Requirements

• Model size in memory: ~19 GB in bf16
• Recommended GPU: Single 80GB GPU (serves comfortably)
• Optional: --tensor-parallel-size / --tp for multi-GPU sharding

Model Tags

• qwen3_5 — based on Qwen 3.5 architecture
• image-text-to-text — multimodal input support
• conversational — chat interface support
• safetensors — distributed in Safetensors format

Agentic Coding Benchmark Results

Evaluation Setup

• Terminal-Bench 2.1 (Terminus-2): Harbor/Terminus-2 framework, parser=json, temperature=1.0, top_p=1.0, 128K context, 4h timeout, 32 CPU cores, 48GB RAM, avg of 5 runs. Qwen chat template adjusted for consistency.
• Terminal-Bench 2.1 (Claude Code): Claude Code 2.1.126, parser=json, temperature=1.0, top_p=1.0, max_new_tokens=131072, avg of 5 runs.
• SWE-bench Verified/Pro/Multilingual: OpenHands harness, temp=1.0, top_p=0.95, 256K context window.
• SWE Atlas QnA/RF/TW: mini SWE agent harness, temp=1.0, top_p=0.95, 128K context, avg of 5 runs.
• NL2Repo: temp=1.0, top_p=1.0, 400K context, 48K output, anti-hacking filters.
• ClawEval: Agentic code benchmark over real-user task distributions, temp=0.6, 256K context.

Source: HuggingFace Model Card

Model Architecture

Architecture Type: Dense decoder-only (post-trained on Qwen 3.5 9B)

Key Capabilities:

• Reasoning model (generates thinking blocks before final answer)
• Tool-calling support (emits well-formed function calls)
• Multimodal: accepts text and image inputs, outputs text
• Conversational interface support

Post-Training: RL-based post-training on Qwen 3.5 9B base, jointly optimizing scaffold and solution rollouts for agentic coding.

Key Highlights

Ornith-1.0-9B is part of the Ornith-1.0 family — a self-improving family of open-source models for agentic coding.

State-of-the-Art Coding Agents

Available in 9B-Dense, 31B-Dense, 35B-MoE, and 397B-MoE (post-trained on top of Gemma 4 and Qwen 3.5), achieving state-of-the-art performance among open-source models of comparable size on coding benchmarks such as Terminal-Bench 2.1, SWE-Bench, NL2Repo and OpenClaw.

Self-Improving Training Framework

Ornith-1.0 employs RL to learn to generate not only solution rollouts, but also the scaffold that drives those rollouts. By jointly optimizing the scaffold and the resulting solution, the model discovers better search trajectories and generates higher-quality solutions.

MIT License

MIT licensed, globally accessible, and free from regional limitations.

Lightweight Design

Ornith-1.0-9B is the most lightweight member of the Ornith family, designed for efficient single-GPU deployment.