TL;DR
- Not a Qwen requant: the routed MoE experts in all 48 layers were replaced with a latent MoE and the model was post-trained and quantization-aware trained at 4 bits.
- Routed expert parameters drop 30%, from 120.8B to 84.6B, and Edge0 measure decode at 36.8 tok/s against Qwen's 18.5 on a 16 GiB VRAM budget.
- The engine is Apache 2.0 with 11,859 stars. The weights are not: a paid coding assistant needs separate permission from both Edge0 and Qwen.
System Requirements
| RAM | 38.3 GiB host RAM at NVFP4 with residency on, 31.3 GiB for Q3_K; 20 GiB works with SSD offload |
| GPU | RTX 5090 D or RTX 4090 24 GB, and it runs capped at 16 GiB VRAM. NVFP4 is CUDA-only |
| VRAM | 23.25 GiB measured at NVFP4, 23.14 GiB at Q3_K |
✓ Apple Silicon
Edge0 published four model folders on 11 November and the press ran with "145 billion parameters on a laptop." The number is real and the laptop claim is nearly real, but neither is the interesting part. The interesting part is that Edge0 did not get there by quantizing Qwen harder. They tore out the expert layer of Qwen3.8-Flash-Next in all 48 layers, replaced it with a narrower latent MoE, post-trained the result, and ship weights that were trained at 4 bits rather than squeezed down to them afterwards. On a 16 GB VRAM budget their own measurements put decode at twice the speed of the model they started from. Then they wrapped it in a licence that reserves exactly the product most of our readers would want to build.
What actually shipped
Four repositories went up on Hugging Face on 11 November 2026, two model sizes in two quantization formats each. The engine that runs them is a separate, older project.
| Item | Value |
| Model repositories | Edge0-145B-NVFP4, Edge0-145B-q3k, Edge0-120B-NVFP4, Edge0-120B-q3k |
| All created | 2026-11-11 |
| Downloads at time of writing | 145B-q3k 92,228 · 145B-NVFP4 55,335 · 120B-q3k 28,610 · 120B-NVFP4 6,287 |
| Model licence | Edge0 Community Model License 1.0, dated 12 November 2026 |
| Base model | Qwen/Qwen3.8-Flash-Next, under Qwen Community License 1.0 |
| Engine repository | github.com/Edge0-AI/Edge0, created 2026-09-08, Apache 2.0, C++ |
| Engine stars / forks | 11,859 / 1,857 |
| Engine releases | v0.1.0 (21 Oct), v0.1.1 (29 Oct), v0.2.0 (11 Nov) |
| Issues / discussions | Both open, 43 issues outstanding |
Note the split, because it governs everything below. The inference engine is Apache 2.0 and has nearly twelve thousand stars. The weights are not Apache 2.0 and never were. Two different legal objects in one product.
Hugging Face labels these repositories base_model:quantized:Qwen/Qwen3.8-Flash-Next. That tag is wrong, or at least badly incomplete, and it cost us a wrong first read of this release before we opened the model card.
The card is blunt about it: "Edge0 is not a relabelled Qwen3.8-Flash-Next, and not a re-quantization of it: we rebuilt the model's expert layer." In all 48 layers the routed MoE experts were replaced. The token now gets projected down to a narrow latent width, 1792 on the 145B and 1280 on the 120B, the experts run at that width, and the result is projected back up to the model's 2560 hidden dimension. One expert becomes a fixed 1,630,720 byte record on the 145B instead of a full-width block. Because the architecture changed, the model was then post-trained on Edge0's own data on what the card calls a long schedule, and the weights were trained natively at 4 bits.
Edge0's own NOTICE file anticipates the confusion in a sentence that reads like it was written for exactly this situation: "An erroneous metadata label also cannot grant upstream rights that the publisher did not possess." They are talking about licensing rather than architecture, but the principle holds both ways. Read the card, not the tag.
What a latent MoE actually buys you
The reason this matters has nothing to do with parameter counts and everything to do with bytes moved per token. Edge0 state the case plainly: on-device inference runs out of memory capacity and memory bandwidth long before it runs out of compute. The expert bytes a token pushes through set both decode speed and how much machine you need.
So shrinking the expert pool while keeping the rest of the model intact is the whole trick. Everything outside the expert pool stays at 2560 width, the down-projection and up-projection are shared with one copy per layer, and only the 512 experts work at the narrow latent width. The engine keeps a few thousand expert records on the card and streams the rest from host memory, at a cost that tracks how many experts are resident rather than how big the model is.
| Measure | Qwen3.8-Flash-Next | Edge0-145B | Edge0-120B |
| Routed expert parameters | 120.8B | 84.6B (down 30%) | 60.4B (down 50%) |
| Expert parameters per token | 2.36B | 1.65B | 1.18B |
| Expert pool on disk, NVFP4 | 63.2 GiB | 44.3 GiB | 31.6 GiB |
| Decode at 16 GiB VRAM + 20 GiB RAM | 18.5 tok/s | 36.8 tok/s | 62.4 tok/s |
That bottom row is the claim worth repeating: on a constrained budget, 2.0x the parent model's decode on the 145B and 3.4x on the 120B. All four columns are Edge0's own figures, measured by Edge0, on hardware Edge0 chose. We have not reproduced them.
The architecture, in the numbers Edge0 publishes
| Property | Edge0-145B |
| Total parameters | 145B, 10.12B active per token |
| Layers | 48, hybrid attention, full every 4 layers plus sparse indexer |
| Experts | 512 per layer, 10 routed plus 1 shared active per token, SwiGLU width 640 |
| Expert pool | 84.6B parameters at latent width 1792 |
| PLE | 51.2B n-gram embedding table, fp8, memory-mapped |
| MTP head | 1.26B draft model with 512 experts, for speculative decode |
| Context | 256K, KV cache at int8 with 32K resident |
| Builds | Q3_K 40.81 GiB · NVFP4 47.79 GiB |
The 51.2B n-gram embedding table is inherited thinking rather than Edge0's invention. Qwen3.8-Flash-Next introduced n-gram embedding as a way to scale parameters along an axis that needs less computation and offloads more easily than MoE does, indexing 20 million bigrams and trigrams at layer 2. Edge0 kept that idea, kept the 48 layers and the 2560 hidden dimension, and changed the part that moves the most bytes.
Which raises an accounting point nobody covering this release has made. Qwen quotes its model as "125B with 6B activated, plus 51B n-gram embedding and 4B MTP," listing the embedding table and the draft head separately. Edge0 quotes a single headline figure of 145B that has the 51.2B table folded into it. Add Qwen's three numbers together and you get roughly 180B of weights on disk against Edge0's 145B. Edge0's model is smaller than the one it derives from. The bigger-sounding headline number is a difference in how the two teams count, not a difference in size.
Quality held on two benchmarks, and the card says level elsewhere
A 30% cut to the expert pool is the kind of change that usually costs accuracy. Edge0 report that it did not, and give two numbers where the rebuilt model is ahead of its parent: deepswe 1.1 at 64.6 against 58.7, and terminal-bench 2.1 at 86.5 against 83.3. For everything else the card's own phrase is "level elsewhere."
Take that carefully. Two agentic benchmarks moving up is a real result and consistent with post-training on your own data for a coding and agent workload. It is not a claim that the model is broadly better than Qwen3.8-Flash-Next, and Edge0 do not make that claim. The card names deepswe 1.1, terminal-bench 2.1, HLE, GPQA-Diamond, IFBench and AA-LCR as the evaluation set, but publishes most of the comparison only inside a chart image, so the two text figures above are the only ones we can quote as numbers.
The speed table, and what it looks like next to what we already published
Here is every machine and build Edge0 report. Prefill figures use a 16K-token input where marked. All of it is self-reported.
| Machine | Build | 4K prefill | 16K prefill | Chat decode | Agent decode |
| RTX 5090 D 24 GB | Q3_K | 2169.9 | 3554.9 | 99.7 | 121.2 |
| RTX 5090 D 24 GB | NVFP4 | 1839.6 | 3165.7 | 79.6 | 98.3 |
| RTX 4090 24 GB | Q3_K | 2042.0 | 3179.4 | 69.9 | 91.7 |
| RTX Spark N1X 60 GiB | Q3_K | 674.0 | 770.3 | 37.7 | 36.7 |
| RTX Spark N1X 60 GiB | NVFP4 | 821.2 | 922.4 | 40.1 | 46.0 |
| Apple M2 Ultra (Metal) | Q3_K | 755.6 | 800.3 | 60.9 | 57.0 |
| 16 GiB VRAM + 20 GiB RAM | Q3_K | 249 | 335 | 36.8 | 44.9 |
The last row is the same RTX 5090 D as the first two, not a weaker card. VRAM is capped with --vram-reserve-mib 8192 and system RAM is capped by a cgroup at 20 GB with no swap. That is an honest way to publish a constrained-hardware number and we will give them credit for it.
Now the comparison that puts this in context, because we have covered this exact model on this exact kind of hardware before. When we wrote up Strata running a 125B model on a 12 GB gaming GPU, the figure was 94 tok/s for Qwen3.8-Flash-Next in a GSQ-RCO quantization, and Colibri 2.1 reported the same 94 tok/s for the same model. Edge0's headline is 98.3 tok/s agent decode, on a newer and larger card.
So the speed headline is not a record against what is already on this site. What changed is the quality you pay for it. Strata hit 94 tok/s on 12 GB at roughly 2 bits per weight, and we flagged at the time that fast wrong tokens are not a bargain. Edge0 reach comparable throughput at 4 bits with quantization-aware training behind the weights. Same speed, more bits, and the bits are where the argument is.
There is also a family connection here that the NOTICE file spells out: the bundled edge0-strata fork "retains the MIT license of Niko1221 and the Strata contributors." Edge0's engine is a Strata fork extended with latent MoE support. The project we covered in October is the foundation of the project we are covering now.
The memory budget, measured
Residency is the feature that makes the laptop claim work, and Edge0 publish the split rather than a single number. With residency on, the same card holds Q3_K, 40.81 GiB of weights, as 23.14 GiB of VRAM plus 31.28 GiB of host RAM. NVFP4, 47.79 GiB, comes out as 23.25 GiB of VRAM plus 38.27 GiB of host RAM. The card notes the expert sets are disjoint, so nothing is being counted twice.
For machines with less RAM than that, the documented route is SSD offload via --mmap-experts, which is the same trick the n-gram table already uses by being memory-mapped fp8. That is how 20 GiB of system RAM is enough to serve a model whose weights are twice that size.
One platform caveat worth having before you plan an afternoon around this: the NVFP4 build is CUDA-only. Apple Silicon runs the Q3_K build through Metal, which is why the M2 Ultra row exists and the M2 Ultra NVFP4 row does not. Windows and Linux on x64 or ARM64 need CUDA 13.
Two licences, stacked, and only one of them is Edge0's
This is the section to read before you build anything commercial, and it is the reason we are covering the licence at length rather than in a footnote.
The Edge0 Community Model License 1.0 is, on its own terms, a careful and in several ways generous document. It grants a no-charge, royalty-free licence to use, run, study, modify, fine-tune, quantize, prune, convert, merge and redistribute. It states explicitly that no user-count threshold and no revenue threshold applies unless you are making what it calls a Commercial Model Offering. It does not require you to publish your modifications, show a badge in your interface, send telemetry, or ask permission to benchmark. It claims no ownership of outputs and lets you train other models on them. It even includes a cure period: a first breach reinstates automatically if fixed within 30 days.
Against the licences we have been tracking, that is a different and arguably better shape. MiniMax M3.1 Flash arrived under a licence gated on a 20 million dollar threshold. Edge0 deliberately rejects threshold gating and reserves three specific activities instead.
Those three reservations need a separate written licence from Edge0: selling or paid-distributing the model or an adapter containing Edge0 material; operating a commercial inference or fine-tuning service where customers meaningfully control the inputs; and offering a commercial, independent product primarily designed for AI-assisted coding or office productivity. The licence is careful to exclude the cases that would otherwise swallow everything: earning income, working for a company, selling outputs, doing client work, or shipping a single-purpose tool with an incidental assistant feature are all fine.
Read that third reservation again, though, and then look at how this model is marketed. The card's headline is "A 145B agent, running on one consumer GPU." The benchmarks that moved are terminal-bench and deepswe. This is a coding and agent model, and a commercial independent coding assistant is precisely the category that requires a negotiation.
What Qwen reserves, with no threshold at all
Here is the part that the Edge0 licence cannot fix, and to Edge0's credit, says so.
Qwen Community License 1.0 has two conditions. The first is attribution at scale: above 100,000,000 monthly active users or 20 million US dollars in monthly revenue, you must display the model name in your interface. The second has no threshold whatsoever. If you or your affiliates conduct a "Model as a Service" or an "AI Work Assistant" business, you must obtain a separate licence from Qwen before any commercial use. Qwen defines AI Work Assistant as an independent product primarily designed for AI-assisted coding or office productivity, naming its own Qoder and QwenWork as the examples, and excludes single-purpose tools, assistants for other domains, and assistant features of products with a different primary purpose.
| Question | Edge0 Community 1.0 | Qwen Community 1.0 |
| Personal, research, internal company use | Permitted, no threshold | Permitted, no threshold |
| Selling outputs, paid client work | Permitted | Permitted |
| Redistribute modified weights for free | Permitted with attribution | Permitted with notice |
| Paid inference API where users control inputs | Separate Edge0 licence | Separate Qwen licence |
| Paid independent coding assistant | Separate Edge0 licence | Separate Qwen licence, no threshold |
| Revenue or user threshold before a gate applies | None, by design | None for clause 2 |
| UI attribution duty | Not required by Edge0 | Above 100M MAU or $20M monthly revenue |
So a paid coding assistant built on Edge0-145B needs permission from two separate rights holders, and Edge0 states the position without hedging: "An activity that is free of an Edge0 fee may still require Qwen authorization," and "Permission from Edge0 is not permission from Qwen." Its NOTICE goes further than most releases bother to, pinning the exact Qwen licence revision it read, 812d96e1, dated 12 November 2026, while admitting that "No verified training-source commit is asserted in this release record." It also insists that Qwen's contact address must not be replaced with Edge0's.
That is unusually honest drafting. It is also a two-party negotiation standing between an indie developer and the obvious product.
What it does not do
The vision path is half-shipped. There is an mmproj-BF16.gguf encoder in the folder, but reading pictures also needs a helper program called strata-vision that is not in this repository and that the Edge0 source tree does not build. You get it from a prebuilt engine archive or by building it out of a Strata checkout, then wire two entries into model.json. The Hugging Face pipeline tag says text-generation, which is the honest label for what works out of the box.
The desktop app is Windows only. There is no Ollama or llama.cpp path, because the expert-streaming format is the engine's own. The 256K context is a quarter of what Qwen3.8-Flash-Next offers, and only 32K of KV cache is resident. There is no published training-data description, no technical report, and no paper. A third-party CMF build exists for cortiq, which Edge0 explicitly did not make or endorse. And every performance and quality number in this article came from the publisher.
Running it
The engine is two components built from one repository, and the command-line server speaks both the OpenAI and Anthropic wire formats on port 8000.
nvidia-smi --query-gpu=name,memory.total --format=csv
free -g | head -2
# the engine: edge0-strata plus edge0-infer, Apache 2.0
git clone https://github.com/Edge0-AI/Edge0.git edge0
cd edge0 && ls edge0-strata/EDGE0.md edge0-infer/docs/getting-started.md
# serve ONE model folder, not a parent holding several
build/cpu/bin/edge0-infer serve --model /path/to/Edge0-145B-NVFP4
# it prints: Listening: http://127.0.0.1:8000 model=edge0_145b
curl localhost:8000/v1/chat/completions \
-H 'content-type: application/json' \
-d '{"model":"edge0_145b","messages":[{"role":"user","content":"hi"}],"max_tokens":64}'
# cap the budget to reproduce the constrained row yourself
build/cpu/bin/edge0-infer serve --model /path/to/Edge0-145B-q3k \
--vram-reserve-mib 8192 --mmap-experts
# read BOTH licences before you plan a product around it
curl -sL https://huggingface.co/Edge0/Edge0-145B-NVFP4/raw/main/LICENSE | head -80
curl -sL https://huggingface.co/Edge0/Edge0-145B-NVFP4/raw/main/NOTICE
Pick Q3_K at 40.81 GiB if you want Metal, the fastest reported decode, or the smaller download. Pick NVFP4 at 47.79 GiB if you are on CUDA and want the format the quantization-aware training targeted.
Who should run this
If you have a 24 GB card and want a large agent model locally, this is the most interesting thing to land in weeks. The constrained-budget row is the one to test first, because it is the claim that distinguishes Edge0 from every other way of running a model this size. Cap the VRAM yourself, run the same prompt against the same model through Strata or Colibri, and see whether the doubling holds on your hardware rather than theirs.
If you are building a paid coding assistant, stop at the licence. Both rights holders reserve your exact product, and Qwen's reservation has no revenue floor to hide under. A hobby project or an internal company tool is clearly fine under both documents. A subscription product is a two-party conversation you should have before you write the integration, not after you have customers.
If you maintain an inference engine, read the latent MoE design rather than the benchmark table. The fixed-size expert record is the part that generalises: making an expert a predictable 1.63 MB object is what lets a scheduler keep a few thousand resident and stream the rest, and that property is worth more than any single throughput figure. It is also why this works as a Strata fork rather than a rewrite.
Sources and further reading
The ten-minute version: download the Q3_K build of the 120B rather than the 145B, cap your VRAM with --vram-reserve-mib, and run one long agent task through it. The 120B is the size where Edge0's own numbers claim 3.4x the parent model's decode on a constrained budget, which makes it the cheapest honest test of whether the latent MoE rebuild does what they say it does.
Not independently tested. Every repository statistic, file size, download count, star count, commit, release date and licence clause above was read from the public Hugging Face and GitHub APIs and from the raw model card, LICENSE and NOTICE files on the date below. All performance, memory and quality figures are Edge0's own self-reported measurements on hardware they selected, and we have not reproduced any of them. The Strata and Colibri comparison figures are those projects' self-reported numbers as published in our earlier coverage. Licence summaries are our reading of the operative English text and are not legal advice.
Date checked: 2026-11-16