Edge0 145B is an open-weight coding and agent model with 145 billion parameters, 10.12 billion of them active per token. The Edge0 project ships it on edge0-strata, an MIT-licensed engine fork, in release v0.2.0, dated 11 November 2026; I read its model page at commit 7b60076641cc, 20 commits after that tag. If you type “best local llm for coding 24gb vram” into Google, this is the first answer I have seen that claims a 145-billion-parameter model fits in 24GB VRAM.
On the project’s numbers it does fit. What the page buries is the host memory: about 31 GiB of ordinary RAM for the Q3_K build and 38 GiB for NVFP4, on top of the card. I add up the numbers on that page, list the files in the Hugging Face repos, and say who should try it. Verdict: a 24 GB card plus 64 GB of RAM makes this the best local LLM for coding 24GB VRAM can hold today, going by the project’s own tables. On 32 GB of RAM the 120B sibling is the faster pick.

What the page says about the best local LLM for coding 24GB VRAM
All of this comes from the model page pinned at that commit. The Q3_K build has 40.81 GiB of weights. With what the page calls residency on, the card holds them as 23.14 GiB of VRAM plus 31.28 GiB of RAM. The NVFP4 build has 47.79 GiB of weights, held as 23.25 GiB of VRAM plus 38.27 GiB of RAM.
Bon, I added those up. 23.14 plus 31.28 is 54.42 GiB, which is 13.61 GiB more than the weights. For NVFP4, 61.52 minus 47.79 is 13.73. The page says the expert sets are disjoint and nothing is counted twice, so the surplus is something else, and the page does not itemise it.
The surplus is almost the same in every build. The same page’s 120B sums give 41.33 minus 27.98 for Q3_K, which is 13.35 GiB, and 46.42 minus 32.96 for NVFP4, which is 13.46. That reads like a fixed cost of 13 to 14 GiB that does not grow with the experts. On a card with 24 GiB, 23.14 GiB of VRAM leaves 0.86 GiB, and NVFP4 leaves 0.75.
Why 40.81 GiB is not the size of the download
I listed the files in both Hugging Face repos through the API and summed the bytes. The Q3_K repo, Edge0-145B-q3k, has 93 files and 98.13 GiB. The NVFP4 repo has 45 files and 105.12 GiB.
The biggest file in both is ple-fp8.gguf at 47.68 GiB, the 51.2-billion-parameter n-gram embedding table the page says is fp8 and memory-mapped. It alone is bigger than the 40.81 GiB weights figure, which is experts.bin (37.32 GiB) plus latent_dense_q8.bin (3.49 GiB), which I checked to the byte. For NVFP4 it is 44.30 plus 3.49 for 47.79.
So the sizes on the page count the experts and the Q8 dense part. The table, the model skeleton at 5.58 GiB and the draft-model head at 0.66 GiB sit outside them. Plan on about 100 GiB of free disk per build, on a fast NVMe drive, because the table is read from there by memory mapping.
What the 16 GiB plus 20 GiB row means
The v0.2.0 notes for the Windows x64 package say the 145B needs an NVIDIA card of compute capability 7.5 or newer, “at least 16 GiB of GPU memory, 20 GiB of system memory”, and CUDA Toolkit 13. I took the date from the release page: 11 November. The README news line says 13 November.
The model page says that 16 plus 20 row is a measured test budget and not a general minimum. Look at the sum anyway. 16 plus 20 is 36 GiB, and the Q3_K weights are 40.81, so at least 4.81 GiB of them were coming off disk in that run.
Here are the project’s own measurements for the Q3_K build, from its speed table. These are the Edge0 project’s measurements, not mine. Agent decode, in tokens per second: 121.2 on an RTX 5090 D 24 GB, 91.7 on an RTX 4090 24 GB, 57.0 on an Apple M2 Ultra, 44.9 for the 5090 D constrained to 16 GiB of VRAM and 20 GiB of RAM. The 4090 row is the one most of us can compare against.
By my division, 44.9 is 37 percent of 121.2, 2.7 times slower in decode. Prefill hurts more. The project reports 4K-token prefill at 2169.9 tokens per second on the open card and 249 on the constrained one, 8.7 times slower. At 16K it is 3554.9 against 335, or 10.6 times.
A coding agent reads files before it writes a line, so I weigh prefill above decode. Take 16K as 16,384 tokens and divide by the project’s 16K prefill rates: about 5 seconds on the 4090 (3179.4 tokens per second), 20 on the M2 Ultra (800.3), 49 on the constrained card (335). Forty-nine seconds before the first word is a batch job, not an assistant.
32 GB of RAM or 64 GB: which build to pick
Host RAM sets the experience. From the same page:
With 24 GB of VRAM and 64 GB of RAM, the 145B Q3_K holds 31.28 GiB in RAM and leaves room for the operating system and a browser. NVFP4 holds 38.27 GiB, is slower on the same card (98.3 agent decode against 121.2, per the project), and does not run on macOS. Take Q3_K.
With 24 GB of VRAM and 32 GB of RAM, the 145B runs once host RAM is capped. Residency is off by default (--resident-budget-gib is 0); the 44.9 row ran under a cgroup cap of 20 GiB of RAM with an 8192 MiB VRAM reserve, and the card’s low-RAM recipe adds --resident-budget-gib 20 with a static expert profile. The page has no row for your exact machine. The 120B is faster there: 73.3 agent decode at the same 16 plus 20 cap, 104.9 on the 4090.
What do you give up? The project’s quality table, model-level and not a separate evaluation of the Q3_K file, lists terminal-bench 2.1 at 86.5 for the 145B, 75.3 for the 120B and 73.0 for Qwen3.8-27B. On deepswe 1.1 it is 64.6, 51.3 and 42.2. The 120B beats the 27B by 2.3 points on terminal-bench and 9.1 on deepswe; the 145B leads by 13.5 and 22.4. On 11 November I wrote about the other extreme, a 284-billion-parameter model squeezed into 64 GB of RAM with no graphics card at all.
The licence sits in section 4
The framework code is Apache-2.0, which GitHub’s licence field confirms. The weights are not: both Hugging Face repos carry the licence tag “other”, with the name edge0-community-model-1.0, the Edge0 Community Model License dated 12 November 2026. The README says personal use and commercial use of outputs are allowed, and Qwen’s upstream terms still apply: the Qwen Community License 1.0 wants a separate licence from Qwen for an AI Work Assistant business, meaning coding or office productivity, and Edge0’s grant does not cover it.
Read paragraph (c) of section 4 if you build developer tools. It requires a separate written commercial licence for “an independent product primarily designed for AI-assisted coding or office productivity” that uses the model and is financed by fees, whether inference is hosted or on the user’s device. Simply working for a company is excluded.
What I would do with 24GB VRAM
Check the RAM first: free -g on Linux takes two seconds. If it says 62 or more, download Edge0-145B-q3k, keep 100 GiB of disk for it, install CUDA 13, and run edge0-infer serve --model /path/to/Edge0-145B-q3k from the v0.2.0 Windows zip; on Linux there is no package, so build edge0-infer and edge0-strata from source. Then time the first token on a 16K prompt from your own repo. My sum from the project’s rates says about 5 seconds on a 4090, so that is the number to beat or miss.
If it says 31 or 32, download the 120B Q3_K. If it says 16, buy RAM before you buy a bigger card; I will not quote a price, because I have no primary source for one.
If the project’s table holds on your box, the 145B decodes at 91.7 tokens per second on a 4090, on RAM you may already own.