Ornith-1.5-122B: Open MoE model for coding and agents under MIT license

Ornith AI has released Ornith-1.5-122B, a 122-billion-parameter mixture-of-experts model built on Qwen3.5. It reportedly runs on a single 80 GB GPU and, according to the maker, excels at coding and agent benchmarks.

Model releases Try it yourself Oct 16, 2026 4 min read Source: Hugging Face Trending
Illustrative image, AI-generated

What it's about

The Ornith AI team has released Ornith-1.5-122B on Hugging Face. It is a mixture-of-experts (MoE) model with a nominal 122B parameters (Hugging Face counts 125.1B), licensed under MIT. MoE means the model consists of many sub-networks ("experts"), and only some of them are active for each token. That makes it faster than a dense model of the same size. According to the model card, it is the most capable and efficient member of the Ornith-1.5 family and is designed to run on a single GPU. A quantized variant called Ornith-1.5-122B-Mobile is said to be usable on mobile devices; the card gives no details. The model is a reasoning model: it first writes a thinking block inside <think> tags before giving its answer.

How the model was built

Ornith-1.5 extends Ornith-1.0, which was built on Qwen3.5 and Gemma4, with additional continued pretraining, mid-training and post-training. According to the maker, the new feature in 1.5 is an expanded self-improvement loop: instead of optimizing only scaffolds and rollouts, it now optimizes task generation, scaffold building and rollouts together. The model continuously generates new training tasks, searches for effective solution strategies and improves through reinforcement learning, i.e. learning by reward. This replaces fixed, human-curated task sets and hand-built test environments. According to the card, more details are in the maker's blog. The claims here are the maker's own.

Benchmarks (vendor-reported)

The comparison covers Qwen3.8-Flash-Next (125B), Qwen3.8 (27B dense), Nemotron 3.5 Super VL (120B), DeepSeek-V4-Flash-0731 (284B) and Beam (501B). Selected results:

Benchmark Ornith-1.5-122B Qwen3.8-Flash-Next Qwen3.8 27B DeepSeek-V4-Flash Beam
TerminalBench 2.1 81.2 83.4 71.9 82.7 80.1
SWE-bench Pro 76.9 43.9 65.5 – 57.0
SWE-bench Verified 84.5 82.8 76.8 – –
HLE (with tools) 48.0 38.0 31.3 50.8 51.1
BrowseComp 78.5 75.3 71.4 80.2 67.6
ClawEval 79.4 76.5 75.4 – –

In some tests, larger models lead, such as DeepSeek-V4-Flash on BrowseComp and HLE with tools. The high SWE-bench Pro score stands out. As for the test conditions: the SWE-bench runs used OpenHands with 256K context, and solutions that used reward hacking (gaming the scoring system) were counted as failures. Claude 4.6 Opus served as the judge for HLE, and Claude 4.8 Opus for MCP-Atlas. TerminalBench ran with Claude Code 2.1.126, averaged over 5 runs.

Running it and context

According to the card, the model runs on a single 80 GB GPU. For multiple GPUs, there is tensor parallelism. You need fairly recent runtimes: Transformers ≥ 5.8.1, vLLM ≥ 0.19.1, SGLang ≥ 0.5.9. The context is 262,144 tokens. With YaRN (a context-extension technique) and a factor of 4.0, about 1M tokens are possible. Because runtimes apply YaRN statically, it can slightly reduce quality on short inputs. So you should choose the factor to fit your needs, such as 2.0 for up to roughly 524,288 tokens.

Recommended sampling values: for general tasks, temperature 1.0, top_p 0.95, top_k 20, presence_penalty 1.5. For precise coding, temperature 0.6 and presence_penalty 0. The server returns the reasoning separately in the reasoning_content field and tool calls in OpenAI format. The card names Hermes Agent, OpenClaw, OpenCode, Unsloth Studio and llama.cpp as example agents. For Ollama, the card lists the command ollama run ornith-1.5:122b; whether the tag exists in the official library is unconfirmed. GGUF builds are mentioned as ornith-ai/Ornith-1.5-122B-GGUF, but the card only lists them in a comment as yet to be published.

Our take

An open model under the MIT license that runs on a single 80 GB card and competes at the top in coding and agent tasks is interesting for teams with their own infrastructure. The caveat: all numbers come from the maker, and independent verification is missing. Some of the comparison and judge models are hard to place, and you should treat the big gap on SWE-bench Pro over Qwen3.8-Flash-Next (76.9 vs. 43.9) with caution. Because it builds on Qwen3.5 and Gemma4, you should also check those licensing terms. The card mentions only MIT.

What you need to try it

According to the maker, an 80 GB GPU (e.g. A100/H100) is enough, though in practice only when quantized. The original weights (BF16) come to around 250 GB and need several GPUs. With 4-bit quantization, expect roughly 75 GB for a 125B model. Smaller setups only work with heavy quantization and extra RAM (our estimate). Plan for several hundred gigabytes of disk space for the original weights. On a Mac or CPU, only a GGUF version with a lot of RAM is an option. Google Colab usually won't cut it.

Sources

#open-weights#moe#coding#agents#mit-license
Read the original source

Try it yourself: Ornith-1.5-122B

Explained step by step, no prior knowledge needed – on your own computer or free in your browser.

What can I do with it?

You can run it locally as a coding and agent assistant. It understands large codebases, calls tools and solves multi-step tasks in the terminal. It thinks in a separate reasoning block before answering.

Who is it worth it for?

For developers and teams with an 80 GB GPU or a server who want to run an open agent model themselves. It's too big for normal laptops.

Size125.1 B parameters
Download76 GB (about 1.7 hr at 100 Mbit/s)
Licensemit
TypeLanguage model (text chat)

What your computer needs

Graphics card (NVIDIA), fully in VRAM at least 84 GB VRAMe.g. multiple professional GPUs (2× A6000, H100) or DGX Spark – fastest; with less VRAM, see the next line
Graphics card + system memory (MoE offloading) from approx. 6 GB VRAM + 128 GB RAMdie Experten liegen im Arbeitsspeicher, nur der Kern auf der Grafikkarte (llama.cpp/LM Studio). Langsamer als komplett im VRAM, aber auf normalen PCs machbar
Mac (Apple Silicon M1–M5) from 128 GB unified memoryThe GPU and CPU share the memory – the model can use about 70% of it
CPU only (no graphics card) Possible; speed depends on the number of active expertsMoE-Modelle sind ohne Grafikkarte schneller, als ihre Größe vermuten lässt. Dafür mindestens 128 GB Arbeitsspeicher.
Storage approx. 78 GB freeModel download plus programs
Google Colab too big for Colabeven the largest Colab GPUs aren't enough

Which variant is right for me?

Many models come in several sizes or "quantizations." These are compressed versions: smaller and faster, but slightly less accurate. Rule of thumb: pick the largest variant whose memory requirement fits in your VRAM (video memory). The scripts below choose this for you automatically.

VariantDownloadNeeds approx.Compatible graphics cards
Q4_K_M Default 76 GB84 GBe.g. multiple professional GPUs (2× A6000, H100) or DGX Spark
Q5_K_M 89 GB99 GBservers only, with multiple data-center GPUs (e.g. 8× H100)
Q6_K 102 GB114 GBservers only, with multiple data-center GPUs (e.g. 8× H100)
Q8_0 133 GB147 GBservers only, with multiple data-center GPUs (e.g. 8× H100)
BF16 249 GB276 GBservers only, with multiple data-center GPUs (e.g. 8× H100)

There is the base model Ornith-1.5-122B (80 GB GPU). A Mobile variant is mentioned, and a GGUF build is announced (ornith-ai/Ornith-1.5-122B-GGUF), but the card doesn't confirm it.

  • According to the maker, a single 80 GB GPU is enough. You can spread it across several GPUs with --tensor-parallel-size.
  • The full context of 262,144 tokens costs extra memory (KV cache). If VRAM (video memory) is tight, set a shorter context.
  • With a YaRN factor of 4, about 1M tokens are possible, which needs significantly more memory.
  • On a Mac or CPU, only a GGUF build with plenty of RAM is realistic. Free Colab GPUs aren't enough.

Groß (125,1 B parameters, MoE): running entirely on the GPU takes a lot of VRAM (video memory). With MoE offloading, a regular graphics card plus plenty of RAM is enough (see table). Colab Free isn't enough.

How do I find out what my computer has?
  • Windows: Press Ctrl + Shift + Esc → Task Manager → Performance tab → click GPU on the left. At the bottom you'll see Dedicated GPU memory (that's your VRAM). You'll find system memory under Memory.
  • Mac: Apple menu at the top left → About This Mac. You'll see your chip (e.g. M2) and memory (e.g. 16 GB). On Apple chips, graphics and processor share this memory.
  • Linux: Type nvidia-smi in the terminal (shows your graphics card and its memory) and free -h for system memory.

Guide

Google Colab (in your browser, no installation)

Google Colab is a free service from Google. It gives you a computer with a graphics card in your browser for a few hours. All you need is a Google account. For this model: too big for Colab – even the largest Colab GPUs aren't enough.

  1. Download the notebook. Click the button and save the file.

    Download colab.ipynb

  2. Open Colab. Go to colab.research.google.com and sign in with your Google account.
  3. Upload the notebook. In the window that appears, click Upload on the left (or choose File → Upload notebook at the top) and select the file colab.ipynb.
  4. Turn on the GPU. In the top menu, go to Runtime → Change runtime type → under Hardware accelerator, select T4 GPU (with Colab Pro: L4 or A100) → Save.
  5. Start everything. Runtime → Run all (keyboard shortcut Ctrl + F9). If you see the warning “This notebook was not authored by Google,” click Run anyway.
  6. Wait. The cells run one after another. A green checkmark appears to the left of each cell when it's done. Installation and download take about 29 minutes here.
  7. Try it out. The result appears below the last cell. To test something else, change the text in the cell and run it again with Shift + Enter. The last cell starts a proper chat with an input field.
  8. Clean up. When you're done: Runtime → Disconnect and delete runtime. This saves your free quota.

Good to know: The free GPU is limited (usually a few hours per day). After about 90 minutes of inactivity, Colab disconnects, and you'll have to start everything over.

Windows 10 / 11

The easiest way is Ollama, a free program that launches AI models with a single command.

  1. Update your graphics driver (NVIDIA cards only): Install the NVIDIA app or the latest driver. For AMD cards, use the latest Adrenalin driver.
  2. Install Ollama. Download the file OllamaSetup.exe from ollama.com/download/windows, double-click it, and choose Install. Afterward, a small llama icon appears in the taskbar at the bottom right.
  3. Open a terminal window. Press the Windows key, type PowerShell and press Enter. A blue or black window opens.
  4. Start the model. Copy this command ("Copy" button), paste it into the window with a right-click, and press Enter:
    ollama run hf.co/ornith-ai/Ornith-1.5-122B-GGUF:Q4_K_M
    The first time, Ollama downloads the model (76 GB (about 1.7 hr at 100 Mbit/s)). After that, it's instant.
  5. Start typing. Once >>> Send a message appears, type your question and press Enter. Type /bye to end the chat.

Not enough memory? Pick a smaller variant from the table above, e.g. ollama run hf.co/ornith-ai/Ornith-1.5-122B-GGUF:Q4_K_M.

Prefer automatic? A script that picks the right variant for you
  1. Download both files into the same folder: try_windows.ps1 demo.py
  2. Open the folder in File Explorer, right-click an empty spot and choose Open in Terminal.
  3. Paste this command and press Enter:
    powershell -ExecutionPolicy Bypass -File try_windows.ps1

If needed, the script installs Ollama via winget, measures your VRAM (video memory) and downloads the matching variant.

macOS

Macs with an Apple chip (M1 to M5) are ideal. Older Intel Macs are very slow.

  1. Install Ollama. Download it from ollama.com/download/mac, open the file, and drag Ollama into your Applications folder. Launch Ollama once – a llama appears in the menu bar at the top.
  2. Open Terminal. Press Cmd + Space, type Terminal, and press Enter.
  3. Start the model. Paste the command (Cmd + V) and press Enter:
    ollama run hf.co/ornith-ai/Ornith-1.5-122B-GGUF:Q4_K_M
    The first time, the model is downloaded (76 GB (about 1.7 hr at 100 Mbit/s)).
  4. Start typing. Type your question and press Enter. Quit with /bye.
Pick the right variant automatically

try_mac.sh

cd ~/Downloads
bash try_mac.sh

Linux

  1. Check your GPU. nvidia-smi should show your card. If it doesn't, install the driver on Ubuntu and restart:
    sudo ubuntu-drivers install
  2. Install Ollama:
    curl -fsSL https://ollama.com/install.sh | sh
  3. Start the model:
    ollama run hf.co/ornith-ai/Ornith-1.5-122B-GGUF:Q4_K_M
    Exit with /bye. Use ollama ps to check whether the model is running on the GPU.
  4. Or let it pick the right variant automatically:

    try_linux.sh

    bash try_linux.sh
    # mit Python/transformers statt Ollama:
    MODE=hf bash try_linux.sh

Try it

Write a Python function that reads a CSV file and removes duplicate rows, including tests.
Analyze this repository and explain its architecture to me in five points.
Find the bug in this stack trace and suggest a patch.

If something goes wrong

It needs up-to-date software: Transformers ≥ 5.8.1, vLLM ≥ 0.19.1 or SGLang ≥ 0.5.9.

As a reasoning model, it outputs a thinking block. Start the server with --reasoning-parser qwen3.

For tool calls, start vLLM with --enable-auto-tool-choice and --tool-call-parser qwen3_xml.

Only enable YaRN if you really need very long contexts, as it can slightly degrade short inputs.

For Terminal-Bench, the card says you must adjust the Qwen chat template.

“out of memory,” a crash, or your computer freezes

The model is too big for your VRAM (video memory). Pick a smaller variant from the table above and close other programs, especially games and browsers with lots of tabs.

It runs, but extremely slowly

Your CPU is probably doing the work instead of your graphics card. In Ollama, the PROCESSOR column of ollama ps shows how much runs on the GPU. If it says "100% CPU", update your graphics driver or pick a smaller variant that fits entirely into VRAM (video memory).

“ollama” or “python” is not found

Close the terminal window and open it again so it recognizes the newly installed program. For Python on Windows: reinstall it and check Add python.exe to PATH.

Windows: "Running scripts is disabled on this system"

Run the script with exactly the command above: powershell -ExecutionPolicy Bypass -File try_windows.ps1. This allows execution for this one time only.

Error message when loading the model (version, "trust_remote_code", unknown architecture)

Brand-new models often need the latest software version. With Ollama: update Ollama. With Python: pip install -U transformers in the activated environment. The Model Card usually lists the exact version.

Tokenstrom generates the scripts and notebook automatically. Please take a quick look before running them – they're plain, readable text. Mind the model's license: mit.

Ask the AI assistant

Questions about this article, installation or background? Our assistant knows this page and runs on our own machine, not in someone else's cloud.

Connecting …

The Assistant is an AI (Gemma 4) and can make mistakes – please check important details against the source. Questions are used only to generate an answer and are deleted after one hour. Please don't enter any personal data.

Comments

What do you think? Already tried it? Write it here, no sign-up needed.

  1. Loading comments …

Comments are public. Links aren't allowed, and we delete abusive posts. You can delete your own comment at any time in this browser. Learn more in the Privacy Policy.