Run Ornith 1.5 Locally on Windows 11 and Kali (9B vs 35B)

Ornith 1.5 is the open-source model family that has sat near the top of Hugging Face’s trending list all week, and the reason is a number: its 9-billion-parameter model scores 70.6 on SWE-bench Verified — higher than Google’s Gemma 4 at 31 billion (52.0) and within touching distance of Qwen 3.6’s 35-billion mixture-of-experts (73.4) — on a file that fits on a 16 GB laptop with room to spare. It is MIT-licensed, it comes in three sizes (9B dense, 35B-A3B mixture-of-experts, and a 397B flagship you will not be running at home), the official GGUF files landed on Hugging Face in mid-August, and this post walks through running the two small ones on Windows 11 and Kali Linux with Ollama and llama.cpp. And here is the thing that will catch most people who try today: ollama run ornith does not give you Ornith 1.5. The Ollama library entry is still Ornith 1.0 — last updated two months ago — and the 1.5 weights have to be pulled straight from Hugging Face with a one-line command that is below. The second catch is in the name of the bigger model: "35B-A3B" means three billion parameters are active per token, which is about speed. Memory is about all 35 billion, and at 4-bit that is a 21.7 GB file that does not fit a 16 GB machine at all.

What is Ornith 1.5, and who makes it?

Ornith is a small lab (Ornith AI, sometimes credited as Deep Reinforce) whose pitch is unusual among open-weight releases: they do not train a base model from scratch. Ornith 1.0, released earlier this year, took Qwen 3.5 and Gemma 4 as starting points, ran additional continued pretraining and mid-training on them, and then applied a reinforcement-learning method they call self-scaffolding, in which the model learns to write the instructions, tool set, and decomposition strategy it will use to solve a task, and is rewarded on whether the resulting solution works. Ornith 1.5, released August 18, 2026, extends that loop one step further: the model now also proposes its own training tasks, generating progressively harder problems at the edge of what it can already do, building a scaffold for each, and solving it — with reward flowing back to all three stages. The company’s blog calls the result "end-to-end self-improvement." Whether that framing holds up is a research question; what we can check is the output, and the output is a family of three models under an MIT license with official GGUF quantizations and, for the two smaller ones, no regional restrictions on who may download them.

The three sizes are a 9B dense model (every parameter used for every token), a 35B mixture-of-experts model that activates about 3B parameters per token, and a 397B mixture-of-experts flagship. The lab’s headline claims, from its own evaluations: the 397B matches Anthropic’s flagship model on Terminal-Bench 2.1 and DeepSWE; the 35B-A3B beats Qwen 3.6-35B-A3B on every coding and agentic benchmark they ran; and the 9B beats Gemma 4-31B and lands near Qwen 3.6-35B despite being a third to a quarter of the size. The 9B also ships in a quantized "Mobile" variant meant for phones. The context window on every size is 256K tokens, and the GGUF repositories include an mmproj file, which means the models accept images as well as text when you load that projector alongside them.

The 35B-A3B trap: "3B active" is a speed number, not a memory number

This is the paragraph I most want you to read before you download anything, because the naming convention that Qwen started and everyone has copied is genuinely misleading to a first-time reader. A mixture-of-experts model like Ornith-1.5-35B-A3B has 35 billion parameters in total, split across many small "expert" sub-networks. For each token it generates, a router picks a few experts and only those run — about 3 billion parameters’ worth. That is what "A3B" means: active 3B. It is why the model generates text roughly as fast as a 3B model would, which is very fast indeed.

But the router picks different experts for different tokens, so all 35 billion parameters have to be loaded and ready. Memory is the total, not the active count. At Q4_K_M quantization — the sensible default — Ornith-1.5-35B is a 21.7 GB file, and it needs about that much RAM or VRAM plus a couple of gigabytes for the context cache. On a 16 GB laptop it does not load; on a 16 GB laptop with a big swap file it loads and then produces roughly one token every few seconds while the disk light stays on. The 9B dense model, by contrast, is 5.8 GB at the same quantization, and on the same 16 GB machine it runs at a comfortable reading pace. If you have 32 GB of system RAM or a 24 GB graphics card, the 35B is the better model and the speed will be lovely. If you have 16 GB, the choice has been made for you, and it is the 9B — which, per the lab’s own numbers, is a strong model in its own right.

Which Ornith 1.5 fits your machine? RAM and VRAM tiers

File sizes below are the official GGUF files on Hugging Face as of August 30, 2026 (the Ollama-hosted 1.0 tags are within a few hundred megabytes of the same). Add roughly 1–2 GB on top for the context cache at a normal 8K–16K context; the 256K maximum will eat far more, and you should set the context you actually need rather than the maximum.

Why ollama run ornith gives you the wrong model, and the one-line fix

Ollama’s library has an ornith entry with 9b and 35b tags and about 433,000 downloads. Its page says "Updated 2 months ago" and its readme describes Ornith 1.0. As of today, nobody has published a 1.5 tag there. So the obvious command hands you the June model, and you would have no way of knowing unless you asked the model its version and it happened to know, which it does not.

The fix is Ollama’s ability to pull any GGUF straight from a Hugging Face repository. The repo is ornith-ai/Ornith-1.5-9B-GGUF (or -35B-A3B-GGUF), and the tag after the colon is the quantization file you want:

ollama run hf.co/ornith-ai/Ornith-1.5-9B-GGUF:Q4_K_M

That is the whole trick. The first run downloads 5.8 GB and drops you into a chat; afterwards the model is cached locally under that long name, and ollama list shows it beside anything else you have. Swap Q4_K_M for Q5_K_M, Q6_K, or Q8_0 per the table above, and 9B for 35B-A3B if you have the memory. If you would rather have a short name, ollama cp hf.co/ornith-ai/Ornith-1.5-9B-GGUF:Q4_K_M ornith15 makes a copy called ornith15 without downloading anything twice. When a 1.5 tag does appear in the Ollama library — check the "Updated" line on the library page — this workaround stops being necessary, but it will keep working.

Run Ornith 1.5 on Windows 11, step by step

1. Check your memory first: press Ctrl + Shift + Esc, open the Performance tab, and read the total under Memory and, if you have a discrete card, the Dedicated GPU memory under GPU. Pick your row in the table above. Sixteen gigabytes means the 9B; do not talk yourself into the 35B.
2. Install Ollama from ollama.com/download — the Windows installer, no admin rights needed. It runs as a small tray app. If you already have it, open a terminal and run ollama -v; anything from 2025 onward pulls from Hugging Face fine.
3. Open Windows Terminal (or PowerShell) and run:

   ollama run hf.co/ornith-ai/Ornith-1.5-9B-GGUF:Q4_K_M

   The download is 5.8 GB. On a 100 Mbps connection, expect eight or nine minutes.
4. When the >>> prompt appears, ask it something you can judge — a small PowerShell script, a regex, a bug in a function you paste — rather than "hello." The model is trained for coding and agent work; that is where the difference from the previous generation shows.
5. Set a sane context length. Ollama defaults to a few thousand tokens; the model supports 256K but every extra thousand tokens of context costs memory. Inside the chat, /set parameter num_ctx 16384 is a good working size on 16 GB; type /bye to leave.
6. Optional, for apps that talk to a local model: Ollama serves an OpenAI-compatible API at http://localhost:11434 the moment it runs. Point VS Code extensions or any local-LLM front end at it and choose the hf.co/ornith-ai/… model name.

Run Ornith 1.5 on Kali Linux (Ollama, or llama.cpp if you want control)

On Kali 2026.3 the Ollama path is identical to Windows once Ollama is installed, and the install is one line:

1. free -g for RAM and, if you have an NVIDIA card, nvidia-smi for VRAM. Same table, same rule.
2. Install Ollama: curl -fsSL https://ollama.com/install.sh | sh — it registers a systemd service and detects CUDA or ROCm on its own. Read the script first if piping to a shell bothers you; it should, a little, and the script is short.
3. ollama run hf.co/ornith-ai/Ornith-1.5-9B-GGUF:Q4_K_M — same command, same 5.8 GB.
4. If you prefer llama.cpp directly (more control, no background service): sudo apt install llama.cpp is not yet a thing on Kali, so build it — git clone https://github.com/ggml-org/llama.cpp && cd llama.cpp && cmake -B build && cmake --build build -j — then download the GGUF with huggingface-cli download ornith-ai/Ornith-1.5-9B-GGUF Ornith-1.5-9B-Q4_K_M.gguf --local-dir . and run ./build/bin/llama-cli -m Ornith-1.5-9B-Q4_K_M.gguf -c 16384 -ngl 99. The -ngl 99 offloads every layer to the GPU if you have one and is harmlessly ignored if you do not.
5. For image input, download the mmproj-Ornith-1.5-9B-BF16.gguf file from the same repository (0.9 GB) and pass it with --mmproj to llama-mtmd-cli; Ollama’s Hugging Face pull does not fetch the projector automatically.

Jake tries it: the spreadsheet macro, the wrong model, and the swap file

Jake runs a phone repair shop and keeps his stock in a spreadsheet that has grown a personality. He wanted a macro that flags any part under its reorder level and emails him a list on Friday, and he wanted it written by something that would not send his stock sheet to a server in another country. So he did what a sensible person does: he opened a terminal on his 16 GB laptop and typed ollama run ornith, because that was the name on the trending list.

It worked, and it wrote a perfectly reasonable macro, and he was happy for two days until he read the model card and realized he had been using the June release. "Is the new one actually better?" he asked. Ethan, who had been waiting for this, said the lab’s own table says the 9B went from 69.4 to 70.6 on SWE-bench and from 43.1 to 46.2 on Terminal-Bench between 1.0 and 1.5 — real but modest — and that the honest answer is "better at agent-style tasks, about the same at writing a macro from a clear description." Jake pulled the 1.5 file with the Hugging Face command anyway, because knowing you are on the current version is worth eight minutes of download.

Then he tried the 35B, because the table said it was better still, and because 3B sounded small. The laptop thought about it for four minutes, the fan came on, Windows quietly grew the page file to 22 GB, and the model produced the word "Sure" and then one more word roughly every six seconds. He killed it. "A3B," said Ethan, "is how many it uses. You still have to invite all thirty-five billion to the party." Jake went back to the 9B, wrote the macro, and it has emailed him every Friday since. His only complaint is that it suggested a column he did not have, twice, which is a fair summary of local models in 2026: excellent at the shape of the thing, occasionally confident about a detail that does not exist. Read what they write.

What the benchmarks say — and what they cannot

These are the lab’s own figures from the model cards, published August 18, 2026. They are not independent, they are chosen by the people who built the model, and the comparison models were run by the same people. That is normal and it is also a reason to treat every row as a claim rather than a measurement until someone else reproduces it. With that said:

Three honest readings. First, the 9B is the interesting one for readers of this blog: a model that fits in 6 GB scoring within three points of a 35B on SWE-bench Verified is either a real advance in what small models can do or a benchmark that has become familiar to the training pipeline, and probably some of each. Second, the biggest jump from 1.0 to 1.5 is on SWE-bench Pro and Terminal-Bench — the agentic, multi-step tasks — which is consistent with the lab’s story about what the new training loop targets. Third, none of these numbers measure the thing Jake cared about: whether the model invents a spreadsheet column. Benchmarks reward getting tests to pass; your work rewards not being confidently wrong. Run it on your own task before you believe a table, including this one.

What breaks, and the fix for each

Ornith 1.5 vs Qwen3.8-27B vs GLM-5.3-Flash: which one this week?

Last week’s post covered running Qwen3.8-27B and GLM-5.3-Flash locally, and the question in the comments was which to keep. My take, with the caveat that all three labs grade their own homework:

• 16 GB laptop, coding and terminal tasks: Ornith-1.5-9B. Nothing else at 6 GB is claiming these numbers, and it is MIT-licensed with no usage restrictions.
• 16 GB laptop, general chat, writing, and questions: Qwen3.8-27B at a low quant, or Gemma 4 — Ornith is tuned for code and agents and is a merely decent conversationalist by its own reasoning scores.
• 32 GB or a 24 GB GPU: Ornith-1.5-35B-A3B for anything agentic; it is the fastest of the three per token because only 3B parameters run, and it posts the highest coding numbers of any model under 40B.
• GLM-5.3-Flash: still, as last week, a cloud model in practice — the smallest GGUF is 93 GB. Nothing changed.
• Kimi K3, Hy4 preview, DeepSeek-V4-Flash: the other names on the trending list this week are 770-billion-parameter-class models; the Hy4 Q4 GGUF is 467 GB. They are excellent and they are not for your laptop. Ollama’s :cloud tags or a hosted API are the way to try them.

License, privacy, and what "self-improving" does not mean

Ornith 1.5 is released under the MIT license, which is about as permissive as software licenses get: use it commercially, modify it, redistribute it, with attribution. That is a cleaner position than several competing models whose "open" licenses carry usage policies or user-count thresholds. Running it locally means nothing you type leaves the machine; Ollama makes no outbound connection after the download unless you ask it to. And the phrase "self-improving" describes how the lab trained it — the model on your disk is a fixed set of weights that does not learn from your conversations, does not update itself, and will be exactly as good next month as it is today. If you want the next improvement, it will arrive as Ornith 1.6 and another download.

FAQ — Ornith 1.5, answered straight

What is Ornith 1.5?

An MIT-licensed family of open-weight language models from Ornith AI, released August 18, 2026, built on Qwen 3.5 and Gemma 4 with additional training and a self-improving reinforcement-learning loop, aimed at coding and agentic tasks. Sizes: 9B dense, 35B-A3B mixture-of-experts, and 397B.

How much RAM does Ornith 1.5 need?

The 9B at Q4_K_M is a 5.8 GB file and runs on a 16 GB laptop (8 GB is possible but tight). The 35B-A3B at Q4_K_M is 21.7 GB and needs about 32 GB of RAM or a 24 GB GPU. Add 1–2 GB for context in either case.

Can I run Ornith 1.5 35B on 16 GB of RAM?

Not usefully. All 35 billion parameters must be in memory even though only about 3 billion are active per token; on 16 GB it pages to disk and produces a word every few seconds. Use the 9B.

What does A3B mean in Ornith-1.5-35B-A3B?

"Active 3B": a mixture-of-experts router uses roughly 3 billion of the 35 billion parameters for each token. It makes generation fast; it does not reduce the memory needed, which is set by the full 35B.

Is Ornith 1.5 on Ollama?

Not as a library tag at the time of writing — ollama run ornith gives you Ornith 1.0. Pull 1.5 directly from Hugging Face: ollama run hf.co/ornith-ai/Ornith-1.5-9B-GGUF:Q4_K_M.

How do I run Ornith 1.5 on Windows 11?

Install Ollama from ollama.com, open Windows Terminal, and run ollama run hf.co/ornith-ai/Ornith-1.5-9B-GGUF:Q4_K_M. The 5.8 GB download happens once. Set /set parameter num_ctx 16384 for a working context size.

How do I run Ornith 1.5 on Kali Linux?

curl -fsSL https://ollama.com/install.sh | sh, then the same ollama run hf.co/… command. Or build llama.cpp and run the GGUF with llama-cli -m Ornith-1.5-9B-Q4_K_M.gguf -c 16384 -ngl 99.

Is Ornith 1.5 better than Qwen 3.5 9B?

By the lab’s own numbers, substantially, on coding: 70.6 vs 53.2 on SWE-bench Verified and 46.2 vs 21.3 on Terminal-Bench 2.1. Those are self-reported; try your own task.

Is Ornith 1.5 better than Gemma 4?

On the coding and agent benchmarks the lab reports, the 9B beats Gemma-4-31B (70.6 vs 52.0 on SWE-bench Verified) despite being a third of the size. Gemma 4 remains the more general model for chat and writing.

What is Ornith 1.5’s license?

MIT. Commercial use, modification, and redistribution are allowed with attribution, and the lab states there are no regional restrictions.

Does Ornith 1.5 support images?

Yes — the GGUF repositories include an mmproj vision projector file. You need to load it explicitly (llama.cpp --mmproj); the Ollama Hugging Face pull does not fetch it on its own.

What is the context length of Ornith 1.5?

256K tokens. Running at that size needs far more memory than the model file itself; set the context you need (8K–16K for most work) rather than the maximum.

Which Ornith 1.5 quantization should I use?

Q4_K_M is the default balance of size and quality. Q5_K_M or Q6_K if you have the memory to spare; Q8_0 only when the whole file fits in VRAM. The official repository does not ship Q2/Q3 files; community repos do, at a visible quality cost.

Does Ornith 1.5 learn from my conversations?

No. "Self-improving" describes the training method. The weights on your disk are fixed and nothing you type changes them or leaves the machine.

Can I run Ornith 1.5 397B locally?

Not on consumer hardware. It is a 397B mixture-of-experts model measured in hundreds of gigabytes even quantized; use it through a hosted API if you need it.

Ornith 1.5 vs Qwen3.8-27B — which should I run?

Ornith-1.5-9B for coding and terminal work on a 16 GB machine; Qwen3.8-27B (or Gemma 4) for general chat and writing. With 32 GB, Ornith-1.5-35B-A3B is the strongest and fastest local coder of the three.

Where to go next

Revision note. Written August 30, 2026,. File sizes are from the official GGUF repos and the Ollama library page that day; the benchmark numbers are the lab’s own and I have said so wherever they appear. Two things will go stale first: someone will add a 1.5 tag to the Ollama library, and then plain ollama run ornith is fine again; and independent tests will show up and may not agree with the tables. Tell me through the contact page when either happens and I will update this. If you already tried the 35B on a 16 GB laptop and watched it crawl — you did nothing wrong, the name does that to everyone. Delete it, pull the 9B, and give it a real task. It is a good little model.