How to Run Ornith 1.5 9B Locally: GGUF, Hardware and Benchmarks

In this guide, you'll learn:

• What Ornith 1.5 9B is and how it differs from the 35B and the 397B
• What hardware you need to run it
• How to run Ornith 1.5 9B locally with Atomic Chat or llama.cpp

If you're choosing a local coding model more broadly, see our guide to the best local LLMs for coding. This article is only about Ornith 1.5 9B.

What is Ornith 1.5 9B?

Ornith 1.5 9B is an open-weight dense language model developed by DeepReinforce, the smallest member of the new Ornith 1.5 family. The family is trained for agentic coding and ships in three sizes, a 397B MoE flagship, a 35B MoE, and this 9B, all under the MIT license. The 9B weights went public on Hugging Face on August 19, 2026.

Ornith 1.5 9B main specs:

The 9B is multimodal, meaning it can process images alongside text. It also uses the hybrid attention design of Qwen 3.5, the architecture it builds on: 24 of the 32 layers use linear attention, a form of attention whose memory use stays the same no matter how long the conversation gets. Only the other 8 layers keep a regular KV cache, the part that normally grows with every token. In practice, that means long chats and big documents cost far less memory here than on a typical 9B model. We'll put numbers on this in the hardware section.

Ornith is DeepReinforce's self-improvement project: the model proposes its own training tasks and learns from its own attempts. The 1.5 generation extends that loop beyond coding into reasoning and general agentic work. The 9B is also a reasoning model: it opens each answer with a thinking block before the final response, and you can switch thinking off entirely.

The Ornith 1.5 release includes three different models, and they're easy to confuse:

• Ornith 1.5 397B is the MoE flagship that DeepReinforce benchmarks against Claude Opus 4.8. At 397B parameters it takes a multi-GPU datacenter cluster to serve, the same class of hardware as Kimi K3.
• Ornith 1.5 35B is a 35B MoE with 3B active parameters, the same class as DeepSeek V4 Flash, and it carries a Multi-Token Prediction head. We publish separate GGUF builds for it.
• Ornith 1.5 9B is the dense vision-language model this guide is about, and the smallest of the three: it fits an 8 GB GPU or a 16 GB MacBook, the cheapest way to run Ornith locally.

Ornith 1.5 9B benchmarks

DeepReinforce's launch numbers, from the model card, compare the 9B with Ornith 1.0 9B, Qwen3.5-9B, Qwen3.6 35B A3B, and Gemma 4 31B:

The 9B comes out ahead of Gemma 4 31B, a dense model three times its size, on three of the four benchmarks.

Here's the same class of local models, each scored by its own vendor:

All scores in this second table come from each vendor's own model card or release blog, and every lab runs its own eval setup, so small gaps between columns don't mean much. A hyphen means the vendor didn't publish that number. On Terminal-Bench the versions differ: Ornith's card reports 2.1, OmniCoder's 2.0, and Apriel's states none.

The direct rival here is OmniCoder-9B: Tesslate's agentic-coding fine-tune of Qwen3.5-9B, released in March 2026. The two cards only overlap on GPQA Diamond, where Ornith leads 86.4 to 83.8. On SWE-bench Verified the nearest published score in the table is Muse Glimmer 30B's 76.0, and the 9B sits within six points of it.

The more useful reference for the 9B is its predecessor. Ornith 1.0 9B shipped in June 2026, and with a 69.4 on SWE-bench Verified it has been one of the strongest models for local coding you can fit on an 8 GB card. The 1.5 lands at the same size, so the hardware footprint is identical: if you run Ornith 1.0 today, every 1.5 build fits the same machine.

Ornith 1.5 9B GGUF: we quantized it ourselves

We built the AtomicChat Ornith 1.5 9B GGUF repository from DeepReinforce's original BF16 weights. The repository holds fourteen builds from 2.8 to 17.9 GB, plus the vision projector, a separate download shared by all of them. The AD prefix stands for Atomic Dynamic, and a double name like AD-Q5_K-Q4_K says what the two largest tensor groups got; when both match, the name collapses to one.

How to read the table: KL divergence measures the distance between the quant's output distribution and the original weights. Lower values are better, and zero means identical. Top-1 match is the percentage of positions where the quant selects the same next token as the reference. For a single summary measure, use top-1 match. In the next section we'll explain which file fits your hardware.

AD-Q5_K-Q4_K is smaller than stock Q5_K_M and more accurate at the same time: 5.9 GB against 6.5 GB, and 0.0255 against 0.0299 on KL divergence.

We measured every number in the table ourselves. The reference is the original BF16 weights, the calibration corpus is public, and the raw logs are in the metrics repo, so you can check any of it yourself. The full recipe is on the model card.

Ornith 1.5 9B hardware requirements

For Ornith 1.5 9B, the system requirement to check is memory. The table below shows the total usable RAM plus VRAM you need:

On Apple Silicon, count about 75 percent of unified memory as available: a 16 GB Mac reads the 12 GB row.

Note: if you are choosing between two neighbouring files, take the larger one. It costs half a gigabyte or so more and picks the wrong token noticeably less often, especially below 5 GB, where quality falls fastest.

How much memory does the context window add?

The figures above only cover the model weights. On top of that, the engine allocates a KV cache: the longer you chat, the more context the model holds in memory, and the more gigabytes that takes. The same goes for pasting big documents or codebases into the conversation.

In a conventional dense transformer, all 32 layers would store attention data for every token. Here, 24 of the 32 layers use linear attention with a fixed-size state, and the 8 full-attention layers use just 4 KV heads. Measured on our builds, the model keeps 32 KB of attention cache per token, about a quarter of what a standard transformer of this shape would store:

The full 262K window fits on a 24 GB card: with AD-Q8_0-Q6_K, the weights and the cache together come to about 17 GB.

What hardware can run Ornith 1.5 9B?

• 8 GB GPUs (RTX 3050, RTX 4060): can run AD-Q5_K-Q4_K entirely in VRAM with room for about 32K of context.
• 12 GB GPUs (RTX 3060, RTX 4070): can run AD-Q8_0-Q6_K entirely in VRAM, and at that quant the model behaves close to the original.
• 16 GB GPUs (RTX 4060 Ti 16 GB, RTX 5060 Ti): can run Q8_0 with room for about 128K of context.
• 24 GB GPUs (RTX 3090, RTX 4090): can run the unquantized BF16 file entirely in VRAM.
• MacBook (16 GB unified memory): can run AD-Q8_0-Q6_K through Metal with room for about 64K of context. macOS caps GPU-addressable memory at roughly 75 percent of unified memory by default, so a 16 GB Mac gives the model about 12 GB to work with.
• MacBook Pro M4/M5 Max, Mac Studio (32 GB and up): can run Q8_0 or BF16 with room to spare. On Apple Silicon the GGUF builds run natively through Metal; see our GGUF vs MLX guide if you're choosing between formats.

Measured throughput

We measured the BF16 build on a single RTX 5090 with full GPU offload:

Smaller files generate faster: the 5.9 GB AD-Q5_K-Q4_K lands near 280 tokens per second.

How to run Ornith 1.5 9B locally with Atomic Chat

Atomic Chat is a free, open-source local AI app we built. It includes a Hugging Face model browser and a built-in chat, with no manual llama.cpp build required.

Here's how to run Ornith 1.5 9B with Atomic Chat:

Step 1: Install Atomic Chat

Download Atomic Chat from atomic.chat and install the build for your platform:

• macOS: a universal .dmg (Intel and Apple Silicon), macOS 13.6 or later
• Windows: an .exe installer for x64
• Linux: a self-contained .AppImage for x86_64, which needs no root
• iOS: through the App Store
• Android: through Google Play

On Linux, mark the AppImage executable with chmod +x and run it directly. If the app asks about FUSE on first launch, install it with sudo apt install fuse libfuse2 on Debian or Ubuntu, or sudo dnf install fuse fuse-libs on Fedora.

Step 2: Find our Ornith 1.5 9B GGUF

Open the Models tab and search for:

AtomicChat/Ornith-1.5-9B-GGUF

The catalog is backed by Hugging Face, so you'll also see builds from other publishers as they appear. Choose the result published by AtomicChat, then expand the Download Options picker to list the available quantizations.

Note: third-party Ornith 1.5 repositories appeared on Hugging Face within hours of the release. If you're downloading from anywhere other than the app catalog, see the Troubleshooting section for how to check what you're pulling.

Step 3: Pick a quant for your memory

Use the hardware table above. For the most common configurations:

• 8 GB GPU: download AD-Q5_K-Q4_K.
• 12 GB GPU or 16 GB Mac: download AD-Q8_0-Q6_K.
• 24 GB GPU and up: download BF16.

The picker lists each build under its short tag, without the AD prefix, and a double name like AD-Q5_K-Q4_K shows up under the tag of its smaller half: on an 8 GB card, the file to take is the Q4_K row at 6.4 GB. The sizes shown in the picker differ a little from the file sizes in our tables; when two rows share a name, go by size. Select the largest quant that fits with context headroom. If you're not sure what the quant names mean, see our guide to what GGUF is and how quantization works.

Step 4: Set the context, thinking, and sampling

The model declares a 262K context window, but configuring the maximum allocates the KV cache up front. Start with 8,192 tokens for chat or 32,768 for code and document work, and increase it only when the workload requires it.

The context control sits next to the chat input: the percentage shows how much of the window the conversation has used, and clicking it opens the Context Size slider. The maximum comes from the model, 256K for this build (the same 262,144 tokens the specs table lists), and 0 loads the value from the GGUF.

Two more settings live on the model itself: open Settings → Model Providers → Llama.cpp, find the Ornith 1.5 build in the model list, and click the gear icon on its row.

• Auto Increase Context Size: on by default. It grows the context when a conversation runs out of room, which can push a build that only just fit past your memory limit. Turn it off when you're working close to that limit.
• GPU Layers: -1 offloads every layer, which is what you want with a dense model that fits in VRAM.

Changing Context Size or GPU Layers restarts the model, so set them before a long conversation.

Thinking is on by default. For models that support reasoning, Atomic Chat shows a lightbulb icon next to the chat: click it to switch thinking on and off.

Sampling is a separate panel: click the sliders icon next to the model name at the top of the chat. DeepReinforce ships no default sampling with the model, so set it yourself: temperature 1.0, top_p 0.95, and top_k 20 for general work, or temperature 0.6 with the same top_p and top_k for coding. For general work DeepReinforce also recommends a presence penalty of 1.5. These settings are saved on the assistant, your chat profile, not on the model, so they stay the same when you switch models.

Step 5: Chat locally

After the download completes, Atomic Chat loads the model and opens it in the built-in chat.

Since the 9B is a native vision-language model, you can attach an image to the chat and ask about it. The image, the weights, and your prompts stay on your machine.

Atomic Chat also exposes an OpenAI-compatible API server at http://localhost:1337/v1. Any tool that speaks the OpenAI API, including coding agents like Claude Code and Cline, can use the local model as a drop-in replacement for a cloud one.

How to run Ornith 1.5 9B with llama.cpp

You might prefer to run the model directly through llama.cpp if you need:

• An OpenAI-compatible local endpoint with explicit flags
• Precise control over GPU offload
• A reproducible server configuration

The 9B uses the same hybrid attention design as Qwen 3.5, which upstream llama.cpp has supported since February 2026, so the release-day GGUFs run on a current build with no patches.

Step 1: Build current llama.cpp

For NVIDIA CUDA:

git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
cmake -B build -DCMAKE_BUILD_TYPE=Release -DGGML_CUDA=ON
cmake --build build -j --target llama-cli llama-server

For Apple Silicon, Metal is enabled by default:

cmake -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build -j --target llama-cli llama-server

Step 2: Run the model

The following command downloads AD-Q5_K-Q4_K from Hugging Face, offloads all layers to the GPU, applies DeepReinforce's coding sampling, and limits the context to 8K:

./build/bin/llama-cli \
  -hf AtomicChat/Ornith-1.5-9B-GGUF:AD-Q5_K-Q4_K \
  --jinja -fa on \
  --temp 0.6 --top-p 0.95 --top-k 20 \
  -ngl 99 \
  -c 8192

Replace AD-Q5_K-Q4_K with another quant name if your system has a different memory capacity. Keep the --jinja flag on every run: it applies the model's own chat template. For general chat rather than coding, DeepReinforce recommends temperature 1.0 with a presence penalty of 1.5 (--presence-penalty 1.5).

Step 3: Expose a local OpenAI-compatible API

Replace llama-cli with llama-server:

./build/bin/llama-server \
  -hf AtomicChat/Ornith-1.5-9B-GGUF:AD-Q5_K-Q4_K \
  --alias ornith-1.5-9b \
  --jinja -fa on \
  --temp 0.6 --top-p 0.95 --top-k 20 \
  -ngl 99 \
  -c 8192 \
  --host 127.0.0.1 --port 8080

Test it with:

curl http://127.0.0.1:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{ "model": "ornith-1.5-9b", "messages": [ { "role": "user", "content": "Summarize what linear attention changes about memory use." } ] }'

Bind the server to 127.0.0.1 unless other machines on your network need access.

Running vision through llama.cpp

Image input needs one extra file, the vision projector, which is shared by all quants. Download mmproj-Ornith-1.5-9B-F16.gguf from the repository once and pass it alongside whichever quant you picked:

llama-mtmd-cli \
  -m Ornith-1.5-9B-AD-Q5_K-Q4_K.gguf \
  --mmproj mmproj-Ornith-1.5-9B-F16.gguf \
  --image your-photo.jpg --image-min-tokens 1024 \
  -ngl 99 -c 8192 \
  -p "What is in this image?"

Keep --image-min-tokens 1024: without it, dense images such as charts and screenshots get too few visual tokens.

Running it with Ollama or LM Studio

Both apps run llama.cpp underneath. Ollama added ornith-1.5 to its library within a day of the release, so the official tag works: ollama run ornith-1.5:9b pulls a 6.6 GB build. The library tag ships one build per size; for a specific quant from our table, pull it from Hugging Face directly:

ollama run hf.co/AtomicChat/Ornith-1.5-9B-GGUF:Q5_K_M

In LM Studio, search for the repository name in the model catalog; our files load there as well.

Troubleshooting

The GGUF you downloaded is not the real model

Repositories from other publishers claimed the Ornith 1.5 name on Hugging Face within hours of the release. Before downloading from an unfamiliar repo, check that the publisher is either the official ornith-ai organization or a quantizer you recognize, that the model card exists, and that the file list actually contains GGUF files of a plausible size. A 9B model at 4-bit cannot weigh 400 MB.

The model loops or repeats itself in thinking mode

The repository ships no default sampling, so the engine falls back to its own defaults, and near-greedy settings make the model repeat itself. Set DeepReinforce's recommended values yourself: temperature 1.0, top_p 0.95, top_k 20, and a presence penalty of 1.5 for general work, or temperature 0.6 for coding. In Atomic Chat, sampling lives behind the sliders icon next to the model name; for chat tasks you can also switch thinking off with the lightbulb icon.

Image input produces gibberish or endless punctuation

Vision needs the projector file, mmproj-Ornith-1.5-9B-F16.gguf, downloaded from the same repository and passed with --mmproj; Atomic Chat picks it up automatically. And keep --image-min-tokens 1024, because charts and screenshots get too few visual tokens without it.

You run out of memory at long context

The weights fit, then a long conversation crashes the model. That's the KV cache growing past your headroom. Set an explicit Context Size instead of 0, turn off Auto Increase Context Size when you're near the limit, and if you need more room, step one quant down: at 32 KB of cache per token, every gigabyte you free adds about 32K of context.

Frequently asked questions

The questions that come up most often about running Ornith 1.5 9B on your own hardware.

How much VRAM does Ornith 1.5 9B need?

About 6 GB for AD-Q5_K-Q4_K, the build for 8 GB cards, at 93.10% top-1 agreement against the original. A 6 GB card takes AD-IQ3_S-IQ3_XXS, and from 24 GB you can skip quantization and run BF16. For that hardware class, see our best local LLM for 8GB roundup.

Can you run Ornith 1.5 9B on a Mac?

Yes. macOS caps GPU-addressable memory at roughly 75 percent of unified memory, so a 16 GB Mac gives the model about 12 GB: enough for AD-Q8_0-Q6_K. From 24 GB of unified memory, run Q8_0; from 32 GB, the BF16 reference. For what else runs well in that class, see our best local LLM for a 16GB Mac roundup.

Has Ornith 1.5 been released yet?

Yes. The Ornith 1.5 9B weights went public in the official ornith-ai organization on Hugging Face on August 19, 2026, with the 35B and the 397B alongside. Our GGUF builds are in the AtomicChat/Ornith-1.5-9B-GGUF repository and in the Atomic Chat catalog, so you can run Ornith 1.5 locally today.

What is the difference between Ornith 1.5 9B, 35B, and 397B?

The difference is size and hardware class. The 397B is the MoE flagship that DeepReinforce benchmarks against Claude Opus 4.8, and it needs a datacenter cluster. The 35B is a 3B-active MoE for a high-end desktop; the 9B is a dense vision-language model that runs from a 6 GB GPU up, with the smallest text-only build fitting 4 GB.

Is Ornith 1.5 a fine-tune of Qwen?

Not officially: the card doesn't name a starting checkpoint. The architecture is Qwen 3.5, and DeepReinforce says it adjusted the Qwen chat template for training consistency. The training itself is DeepReinforce's own reinforcement learning, where the model proposes its own tasks and learns from them, and the launch numbers against Qwen3.5-9B in the benchmarks section show what that training changed.

How does Ornith 1.5 9B compare to Qwen 3.8 27B?

Qwen 3.8 27B needs a 24 GB GPU for its 4-bit build; Ornith 1.5 9B runs on 8 GB. On Terminal-Bench 2.1, the 27B scores 73.0 against the 9B's 46.2. If your machine fits the 27B, run the 27B: see our guide to running Qwen 3.8 locally. The 9B is the pick for the hardware below that.

Is Ornith 1.5 9B better than Ornith 1.0 9B?

Yes, by DeepReinforce's launch numbers: Terminal-Bench 2.1 goes from 43.1 to 46.2, SWE-bench Verified from 69.4 to 70.6, GPQA Diamond from 82.5 to 86.4, and MCP-Atlas from 49.4 to 54.2. The two models share the same size, so the hardware math transfers one to one.

Does Ornith 1.5 9B support vision locally?

Yes. The 9B ships a vision encoder, and the projector file it needs, mmproj-Ornith-1.5-9B-F16.gguf, is in our repository. In Atomic Chat you attach an image to the chat and ask about it, with nothing leaving your machine; through llama.cpp you pass the mmproj file alongside whichever quant you picked.

Does Ornith 1.5 work with Ollama or LM Studio?

Yes. Ollama has an official ornith-1.5 entry: ollama run ornith-1.5:9b. Our GGUF builds also load directly: point Ollama at hf.co/AtomicChat/Ornith-1.5-9B-GGUF, or search the repository name in LM Studio.

Can I use Ornith 1.5 9B with Claude Code or Cline?

Yes. Atomic Chat exposes the model through an OpenAI-compatible API server at http://localhost:1337/v1, and llama-server does the same on the port you choose, so Claude Code and Cline connect as a drop-in for a cloud endpoint. For agent work, use the coding sampling: temperature 0.6, top_p 0.95, top_k 20.

Can I turn off thinking mode?

Yes. Thinking is on by default. In Atomic Chat, the lightbulb icon next to the chat toggles it; over the API, enable_thinking: false switches it off.

Is Ornith 1.5 9B free for commercial use?

Yes. The whole Ornith 1.5 family ships under the MIT license: commercial use, modification, and redistribution are all allowed.

Bottom line

If your machine has an 8 GB GPU or 16 GB of unified memory, Ornith 1.5 9B is the Ornith model to run locally: download AD-Q5_K-Q4_K on an 8 GB GPU, or AD-Q8_0-Q6_K on a 16 GB Mac, start at 8K context, and raise it as the work demands. On a 24 GB card, skip quantization and take the BF16 file. The llama.cpp route serves the same files behind a local OpenAI-compatible API.

Key takeaways:

• Ornith 1.5 9B is a dense 9B vision-language model trained for agentic coding, with a 262K native context window.
• The weights went public on August 19, 2026, under the MIT license; the 35B and the 397B shipped alongside it.
• Our GGUF builds run from 2.8 to 17.9 GB. For an 8 GB card, take AD-Q5_K-Q4_K; from 24 GB, run BF16.
• By DeepReinforce's launch numbers, the 9B beats Gemma 4 31B, a model three times its size, on three of four benchmarks.
• The model ships no default sampling: set temperature 1.0 for general work or 0.6 for coding, with top_p 0.95 and top_k 20.