Ornith · VRAM requirements
Ornith-1.5-122B VRAM requirements: can you run it locally?
- Parameters125B
- Context256K
- 4-bit file79.7 GB
- Checked2026-10-25
Quick answer
Ornith-1.5-122B's 4-bit UD-Q4_K_XL download is 79.7 GB, and an 8K-token context adds only about 0.2 GB of KV cache, so plan for roughly 79.9 GB plus your engine's overhead.[4][3] That is right at the limit of an 80 GB A100 or H100, and fits comfortably on a 96 GB RTX PRO 6000 or a 128 GB Mac or DGX Spark. On an 80 GB card, the 3-bit UD-Q3_K_XL (59.8 GB) leaves room for long contexts. Ollama's default ornith-1.5:122b download is 73–77 GB.[5]
Ornith-1.5-122B is a mixture-of-experts (MoE) model from Ornith, built for coding agents and tool use. Its Hugging Face repo was created on October 16, 2026, it is MIT licensed, and Hugging Face lists 125,086,497,008 parameters.[1] The model card says Ornith-1.5 builds on Ornith-1.0, which was developed on top of Qwen3.5 and Gemma 4, and its config.json uses the Qwen3.5 MoE architecture: 48 layers, 256 experts with 8 picked per token, and a context of 262,144 tokens.[2][3] The card does not give an active-parameter count. Ornith reports 84.5% on SWE-bench Verified, 81.2% on TerminalBench 2.1 and 76.9% on SWE-bench Pro (developer-reported scores).[2]
Because it is an MoE, only some experts work on each token, which keeps it fast. But all 125B parameters still have to sit in memory (VRAM, or VRAM plus system RAM), so memory decides whether it runs for you. The card says it "serves on a single 80GB GPU"; with the BF16 weights at about 249 GB, that only works with a quantized build.[2][4]
Memory needed at each quantization
Quantization stores each weight in fewer bits. Smaller files fit on smaller GPUs, at some cost in quality, and the cost grows below about 4 bits. Below is every GGUF build in Unsloth's Ornith-1.5-122B repo, from 1-bit to the original BF16, using the exact file sizes on Hugging Face (1 GB = 1,000,000,000 bytes, multi-file builds summed), largest first.[4] Unsloth uses its own "UD" dynamic quants here, so there is no plain Q4_K_M file; UD-Q4_K_XL is the 4-bit build. The repo also has a separate vision projector file (mmproj-BF16.gguf, 0.9 GB) that you only need for image input.[4]
| Quantization | Weights | |
|---|---|---|
BF16 (original) | 249.4 GB | |
Q8_0 | 132.6 GB | |
UD-Q6_K_XL | 114.2 GB | |
UD-Q5_K_XL | 94.6 GB | |
UD-Q4_K_XL Unsloth 4-bit (3 files) | 79.7 GB | |
UD-Q3_K_XL | 59.8 GB | |
UD-IQ3_XXS | 49.5 GB | |
UD-Q2_K_XL | 44.5 GB | |
UD-IQ2_XXS | 42.0 GB | |
UD-IQ1_M | 40.4 GB |
Notice how close the small builds are: even the 1-bit UD-IQ1_M is 40.4 GB, only about 4 GB smaller than the 2-bit UD-Q2_K_XL (44.5 GB).[4] Ollama's ornith-1.5 tags are 73–77 GB for the default 122b, 77 GB for 122b-q4_K_M, and 73 GB for the MLX 122b-nvfp4 build.[5]
Which quant should you pick? UD-Q4_K_XL is the usual balance of size and quality if you have 96 GB or more. On an 80 GB card, UD-Q3_K_XL is the practical choice. On 64 GB, UD-IQ3_XXS fits. Treat 1-bit and 2-bit builds as a last resort.
Context length adds memory (the KV cache)
On top of the weights, the engine keeps a key/value cache for the conversation. Ornith-1.5-122B is cheap here. From config.json, only 12 of its 48 layers use full attention; the other 36 use linear attention, which keeps a fixed-size state instead of a cache that grows.[3] The full-attention layers (2 KV heads, head size 256) take 2 × 12 × 2 × 256 × 2 bytes = 24,576 bytes per token at FP16:
| Context | KV cache (FP16, full-attention layers) |
|---|---|
| 4,096 tokens | 0.10 GB |
| 8,192 tokens | 0.20 GB |
| 32,768 tokens | 0.81 GB |
| 262,144 tokens | 6.44 GB |
The linear-attention layers add a fixed amount that does not grow with context; we have not sized it, so it is not in the tables.[3] Even the full 262,144-token context needs only about 6.4 GB of KV cache (our calculation from the config, not a published figure).
| Total with UD-Q4_K_XL weights | 8K context | 32K context | 128K context | 256K context |
|---|---|---|---|---|
| Weights + FP16 KV cache | 79.9 GB | 80.5 GB | 82.9 GB | 86.2 GB |
| With UD-Q3_K_XL weights instead | 60.0 GB | 60.6 GB | 63.0 GB | 66.2 GB |
Which GPUs and Macs it fits on
Each cell compares the weights plus an 8K-token KV cache with the device's memory.[7][8][9][10][11][12][13][14]
| Device | BF16 (original)249.6 GB | Q8_0132.8 GB | UD-Q6_K_XL114.4 GB | UD-Q5_K_XL94.8 GB | UD-Q4_K_XL79.9 GB | UD-Q3_K_XL60.0 GB | UD-IQ3_XXS49.7 GB | UD-Q2_K_XL44.7 GB | UD-IQ2_XXS42.2 GB | UD-IQ1_M40.6 GB |
|---|---|---|---|---|---|---|---|---|---|---|
| RTX 6000 Ada48 GB | No | No | No | No | No | No | No | Tight | Fits | Fits |
| Mac64 GB unified | No | No | No | No | No | Tight | Fits | Fits | Fits | Fits |
| A10080 GB | No | No | No | No | Tight | Fits | Fits | Fits | Fits | Fits |
| H100 (PCIe/SXM)80 GB | No | No | No | No | Tight | Fits | Fits | Fits | Fits | Fits |
| RTX PRO 600096 GB | No | No | No | Tight | Fits | Fits | Fits | Fits | Fits | Fits |
| Mac or DGX Spark128 GB unified | No | No | Fits | Fits | Fits | Fits | Fits | Fits | Fits | Fits |
| H200141 GB | No | Tight | Fits | Fits | Fits | Fits | Fits | Fits | Fits | Fits |
| Mac Studio256 GB unified | Tight | Fits | Fits | Fits | Fits | Fits | Fits | Fits | Fits | Fits |
Column headers show weights + 8,192-token KV cache.
How to read it: "Fits" means weights + 8K cache use under 90% of memory. "Tight" means 90–100%: it may load, but the engine's own working memory or a longer context can push it over. "No" means it won't fit on the GPU alone. The 90% line is our own rule of thumb, not a vendor figure. On a Mac or DGX Spark, the operating system also needs some of the unified memory, so treat those rows as optimistic.
Our recommendations
These follow from the tables above.
| Your memory | Best quant that fits comfortably | Context it leaves room for |
|---|---|---|
| 32 GB (RTX 5090) | Not on the GPU alone; even UD-IQ1_M is 40.4 GB | Offload to system RAM instead (see below) |
| 48 GB (RTX 6000 Ada) | UD-IQ2_XXS (42.0 GB) | 8K (about 42.2 GB); expect a quality loss |
| 64 GB Mac | UD-IQ3_XXS (49.5 GB) | 128K (about 52.7 GB); leave a few GB for macOS |
| 80 GB (A100 / H100) | UD-Q3_K_XL (59.8 GB) | The full 256K (about 66.2 GB) |
| 96 GB (RTX PRO 6000) | UD-Q4_K_XL (79.7 GB) | The full 256K (about 86.2 GB, just under our 90% line) |
| 128 GB (Mac or DGX Spark) | UD-Q6_K_XL (114.2 GB), or UD-Q4_K_XL for the full 256K | 8K at UD-Q6_K_XL; 256K at UD-Q4_K_XL |
| 141 GB (H200) | UD-Q6_K_XL (114.2 GB) | 128K (about 117.4 GB); Q8_0 (132.6 GB) is tight |
| 256 GB Mac Studio | Q8_0 (132.6 GB) | The full 256K (about 139.0 GB); BF16 is tight |
How it compares with similar models
4-bit file sizes and KV cache per token come from each model's Hugging Face GGUF repo and config.json, the same data as our comparison table.[16]
| Model | Parameters | 4-bit file | KV cache per 1K tokens (FP16) | 4-bit + 8K context |
|---|---|---|---|---|
| Llama 3.1 70B | 70.6B | 42.5 GB | 328 MB | 45.2 GB |
| gpt-oss-120b | 116.8B | 62.8 GB | 37 MB | 63.1 GB |
| Ornith-1.5-122B | 125.1B | 79.7 GB† | 25 MB* | 79.9 GB |
| Qwen3.8 Flash Next | 180.0B | 119.6 GB | not yet sourced | — |
*Counts only the 12 full-attention layers. †Ornith's 4-bit file is Unsloth UD-Q4_K_XL; the others are Q4_K_M. In Ornith's own benchmark table, Qwen3.8-Flash-Next scores 83.4 on TerminalBench 2.1 against Ornith's 81.2, while Ornith leads on SWE-bench Pro (76.9 against 43.9).[2]
How to run it
The easiest way is Ollama: ollama run ornith-1.5:122b pulls the default build (73–77 GB).[5][2] With llama.cpp or LM Studio, download a GGUF build from Unsloth's repo, such as the three UD-Q4_K_XL files (or UD-Q3_K_XL on an 80 GB card).[4] For a server, the model card lists vLLM 0.19.1 or newer, SGLang 0.5.9 or newer, or Transformers 5.8.1 or newer, and recommends temperature 1.0, top-p 0.95 and top-k 20 for general tasks (temperature 0.6 for precise coding).[2] It is a reasoning model, so answers start with a thinking block.[2]
If the model is bigger than your VRAM, llama.cpp can keep some experts in system RAM. Because only a few experts work on each token, an MoE handles this better than a dense model of the same size. One user on X reported about 40 tokens per second with a 16 GB GPU and 64 GB of system RAM using a GGUF they built themselves, and another reported about 60 tokens per second on two Intel Arc Pro B65 cards with a custom 3-bit quant (third-party reports we have not tested).[17][18]
Cheapest GPU to rent for Ornith-1.5-122B
An 80 GB A100 or H100 runs UD-Q3_K_XL, and a 96 GB RTX Pro 6000 runs UD-Q4_K_XL with the full context. On-demand prices listed on Runpod's pricing page (checked October 31, 2026; Community Cloud is cheaper but runs on shared hosts):[15]
| GPU (Runpod (on-demand, as listed)) | VRAM | Price |
|---|---|---|
| A100 PCIe (Community) | 80 GB | $1.19/hr |
| RTX Pro 6000 (Community) | 96 GB | $1.69/hr |
| A100 PCIe | 80 GB | $1.79/hr |
| H100 PCIe (Community) | 80 GB | $1.99/hr |
| RTX Pro 6000 | 96 GB | $2.49/hr |
| H100 PCIe | 80 GB | $2.89/hr |
| H200 (Community) | 141 GB | $3.59/hr |
| H200 | 141 GB | $5.29/hr |
Prices checked on 2026-10-25. They change often, so confirm on the provider's page. Rent on Runpod Referral link
Don't want to host it yourself? Compare AI APIs and Sandboxes.
See all GPU rental prices for more providers and multi-GPU setups.
Where to rent or buy
Run it on a cloud GPU
Vast.ai Affiliate partner Consumer GPU marketplace (4090/3090-class rentals)
Runpod Affiliate partner Pods and serverless GPUs (referral link)
E2E Networks Works with India GPU cloud (official site)
Run it via API instead
Novita AI Affiliate partner Open-model APIs and Sandbox for AI agents (no GPU rental)
Buy this GPU (or a Mac)
- B&H Photo Works with GPUs and computing gear (official site)
We may earn from links marked Affiliate partner. Disclosure.
Frequently asked questions
Can I run Ornith-1.5-122B on one 80 GB GPU?
Yes, with a quantized build. UD-Q3_K_XL (59.8 GB) plus an 8K cache is about 60.0 GB, or 75% of 80 GB, and even the full 256K context brings it only to about 66.2 GB.[4][3] The 4-bit UD-Q4_K_XL (79.7 GB) plus an 8K cache is about 79.9 GB, which leaves no room for the engine's own buffers.
Can I run it on a 24 GB or 32 GB GPU like the RTX 4090 or 5090?
Not on the GPU alone: the smallest build, UD-IQ1_M, is 40.4 GB.[4] You need to split the model between the GPU and system RAM. A user on X reports about 40 tokens per second on a 16 GB GPU with 64 GB of RAM (third-party report).[17]
Will it run on a 128 GB Mac, DGX Spark or Strix Halo machine?
On 128 GB of unified memory, UD-Q4_K_XL (79.7 GB) runs with the full 256K context (about 86.2 GB), and UD-Q6_K_XL (114.2 GB) fits at an 8K context.[4][11][13] How much of the 128 GB the GPU can actually use depends on the machine and OS settings, so leave headroom.
How much VRAM does it need for the full 256K context?
The FP16 KV cache for 262,144 tokens is about 6.4 GB, because only 12 layers keep a full cache.[3] With UD-Q4_K_XL weights that's about 86.2 GB, and with UD-Q3_K_XL about 66.2 GB, before engine overhead. The model card says YaRN scaling can stretch the window to about 1M tokens.[2]
Ornith-1.5-122B or gpt-oss-120b?
At 4-bit, gpt-oss-120b is smaller (62.8 GB against 79.7 GB), so it fits an 80 GB card with more room.[16][4] Ornith's KV cache is smaller per token (25 MB against 37 MB per 1K tokens), so the gap narrows a little at long contexts.
How we calculated
- Weights are the exact GGUF file sizes on Hugging Face, checked October 25, 2026, with multi-file builds added up.[4] The vision projector (0.9 GB) is not included.
- KV cache is calculated from
config.jsonfor the 12 full-attention layers at FP16.[3] The fixed linear-attention state is not in the tables. - Device memory is from NVIDIA and Apple spec pages. We compare in decimal GB, so the results lean conservative.
- Rental prices are the listed on-demand Runpod rates from our GPU price data, checked October 31, 2026.[15]
- Not included: engine working buffers, the OS and display. These vary by engine and settings, so leave headroom.
Sources
All sources checked on .
- Hugging Face, ornith-ai/Ornith-1.5-122B (parameter count, license, repo date). https://huggingface.co/ornith-ai/Ornith-1.5-122B
- Ornith-1.5-122B model card (lineage, benchmarks, single-80GB-GPU claim, runtimes, sampling settings, YaRN, Ollama command). https://huggingface.co/ornith-ai/Ornith-1.5-122B/blob/main/README.md
- Hugging Face, config.json (layer types, experts, KV heads, head size, context). https://huggingface.co/ornith-ai/Ornith-1.5-122B/blob/main/config.json
- Hugging Face, unsloth/Ornith-1.5-122B-GGUF file list. https://huggingface.co/unsloth/Ornith-1.5-122B-GGUF/tree/main
- Ollama, ornith-1.5 tags. https://ollama.com/library/ornith-1.5/tags
- NVIDIA, GeForce RTX 5090 specs (32 GB). https://www.nvidia.com/en-us/geforce/graphics-cards/50-series/rtx-5090/
- NVIDIA, RTX 6000 Ada Generation (48 GB). https://www.nvidia.com/en-us/products/workstations/rtx-6000/
- NVIDIA, A100 (80 GB). https://www.nvidia.com/en-us/data-center/a100/
- NVIDIA, H100 (80 GB). https://www.nvidia.com/en-us/data-center/h100/
- NVIDIA, RTX PRO 6000 Blackwell (96 GB). https://www.nvidia.com/en-us/products/workstations/professional-desktop-gpus/rtx-pro-6000/
- NVIDIA, DGX Spark (128 GB unified memory). https://www.nvidia.com/en-us/products/workstations/dgx-spark/
- NVIDIA, H200 (141 GB). https://www.nvidia.com/en-us/data-center/h200/
- Apple, MacBook Pro tech specs (up to 128 GB unified memory). https://www.apple.com/macbook-pro/specs/
- Apple, Mac Studio tech specs (256 GB and 512 GB unified memory). https://www.apple.com/mac-studio/specs/
- Runpod, GPU pricing (checked October 23, 2026). https://www.runpod.io/pricing
- VRAMNeeded comparison table (sources listed per model). https://vramneeded.com/compare/
- X post by @zephel01_vc (16 GB GPU + 64 GB RAM, about 40 tok/s, October 25, 2026). https://x.com/zephel01_vc/status/2114345133139440086
- X post by @csalinas (two Intel Arc Pro B65, custom 3-bit quant, about 60 tok/s, October 25, 2026). https://x.com/csalinas/status/2114179841763193342