Edge0-145B specs — 145 billion parameters in 29GB? The download is 106GB
Edge0-145B is a 145-billion-parameter model that Edge0 released on November 12, 2026. It is a mixture-of-experts design that uses about 10.1 billion parameters per token, and it is derived from Alibaba's Qwen3.8-Flash-Next. The company blog claims 29GB peak memory and more than 80 tokens per second on a laptop, but does not name the machine or the settings. A fully resident Q3_K run documented in the repository used 23.14 GiB of GPU memory plus 31.28 GiB of system RAM on an RTX 5090 D. The Q3_K model folder is about 106GB to download. The engine code is Apache 2.0, the weights are under a custom license that restricts commercial offerings, and all benchmark scores are Edge0's own.
The three lines
- The arithmetic — fitting all 145 billion parameters in 29GB would take 1.6 bits each. The actual files are a 40GB expert pool plus a 51GB embedding table, about 106GB in total
- The conditions — Linux and Windows need an NVIDIA GPU with CUDA 13; Mac support was merged on November 14, for the Q3_K build only. The machine behind the 29GB figure is not named
- License and scores — the weights are under the Edge0 Community Model License 1.0, with Qwen's license layered on top. All six benchmarks are self-reported, with no independent replication
Key questions
- edge0-145b specs
- **145 billion total parameters, about 10.1 billion active per token, 48 layers with 512 experts each. It is a mixture-of-experts model derived from Alibaba's Qwen3.8-Flash-Next.** | Item | Detail | Source | |---|---|---| | Total parameters | 145B | Company blog, model card | | Active per token | 10.12B | Model card | | Architecture | 48 layers, 512 experts per layer, 10 routed + 1 shared per token | Model card | | Base model | Qwen3.8-Flash-Next | GitHub, Hugging Face | | Context | 256K (the Mac template defaults to 32,768) | Model docs | | Builds | Q3_K and NVFP4 | GitHub | | Weight size | Q3_K 40.81 GiB, NVFP4 47.79 GiB (embedding table excluded) | GitHub | | Download folder | Q3_K about 106GB (98.98 GiB) | Sum of Hugging Face file sizes | | Weights license | Edge0 Community Model License 1.0 | Hugging Face |
- how to run edge0-145b
- **It runs only on Edge0's own engine. On Windows and Mac you download the Edge0 Chat app; on Linux you build the engine from the repository and point it at the model folder.** | Step | What to do | |---|---| | 1. Check the machine | Linux or Windows: NVIDIA GPU and CUDA 13. Mac: Apple Silicon, macOS 26 or later | | 2. Storage | About 106GB for the Q3_K folder, on an SSD | | 3. Engine | Edge0 Chat from GitHub release 0.2.0 on Windows or Mac; build edge0-strata and edge0-infer on Linux | | 4. Model | Download the Edge0/Edge0-145B-q3k folder from Hugging Face unchanged. Only Q3_K works on Mac | | 5. Run | edge0-infer serve --model with the folder path, or chat for a terminal session | | 6. Connect | 127.0.0.1:8000, model name edge0_145b, OpenAI- and Anthropic-compatible API |
- is edge0-145b open source
- **The engine code is. The weights are not: they come under a custom license that reserves three kinds of commercial offering, and Qwen's license applies as well.** | Component | License | Commercial use | |---|---|---| | Framework code | Apache 2.0 | Unrestricted | | edge0-strata engine | MIT (a fork of Strata) | Unrestricted | | Edge0's weight contributions | Edge0 Community Model License 1.0 | Selling the model, paid inference services and standalone coding or office assistants need written permission | | Qwen-derived parts | Qwen Community License 1.0 | Model-as-a-service and AI work assistant businesses need a separate Qwen license | | Generated outputs | No restriction in either license | May be sold |
On November 12, 2026, Edge0 released Edge0-145B and called it an open-source, 145-billion-parameter model that runs on a laptop. Take the numbers apart and what fits in 29GB is not the model, only the part of it held in memory at a given moment. The company blog claims 29GB of peak memory, prompt processing above 1,100 tokens per second and generation above 80 tokens per second. The same company's GitHub repository and Hugging Face model card carry different numbers. The folder you download is about 106GB, and a fully resident Q3_K run that Edge0 documents used 23.14 GiB of GPU memory plus 31.28 GiB of system RAM.
Each of the three words in the announcement, open source, laptop and frontier, comes with conditions. The engine code is Apache 2.0, but the weights are under a custom license that restricts commercial offerings. Mac support reached the repository two days after the launch and covers one build. Every benchmark score was produced by the company itself. Because the sources disagree in many places, including Edge0's own documents with each other, this article sets them side by side and says which document states what.
1. What was released — and where the documents disagree
Edge0 published two models, Edge0-145B and Edge0-120B, together with two inference engines (edge0-infer and edge0-strata) and a desktop app, Edge0 Chat. The weights are on Hugging Face in two builds, Q3_K and NVFP4. The release follows Edge0-35B, a phone-sized model from September 2026.
The architecture, as the model card describes it:
| Item | Edge0-145B | Edge0-120B |
|---|---|---|
| Total parameters | 145B | 120B |
| Active per token | 10.12B | 8.64B |
| Layers | 48 | 48 |
| Experts per layer | 512 (10 routed + 1 shared) | 512 (10 routed + 1 shared) |
| Expert pool | 84.6B, latent width 1,792 | 60.4B, latent width 1,280 |
| n-gram embedding table | 51.2B, 8-bit, read from SSD | 51.2B, 8-bit, read from SSD |
| Weight size (Q3_K / NVFP4) | 40.81 GiB / 47.79 GiB | 27.98 GiB / 32.96 GiB |
| Context | 256K | 256K |
A mixture-of-experts (MoE) model switches on only a few of its expert sub-networks for each token. Edge0 calls its variant a latent MoE: the token is projected down to a narrower width (1,792), the experts run there, and the result is projected back up to 2,560. Each expert becomes a fixed record of about 1.63 million bytes. The engine keeps a few thousand frequently used experts on the GPU and streams the rest from system memory or the SSD.
The difficulty is that the articles reporting the launch, and Edge0's own pages, say different things.
| Question | Company blog (November 12) | GitHub and Hugging Face | Other coverage |
|---|---|---|---|
| Origin of the model | Trained in its on-device architecture from the outset; Qwen appears only as a comparison | Derived from Qwen3.8-Flash-Next, with the expert layer rebuilt and post-trained | AIbase reported it as trained from scratch; Enjoy and DEV Community describe it as a Qwen derivative |
| Memory | 29GB peak (28GB in one paragraph) | 23.14 GiB + 31.28 GiB measured; 16 GiB + 20 GiB is a test limit | The release notes say at least 16 GiB GPU and 20 GiB system memory |
| Speed | 1,100+ prefill, 80+ decode tokens per second | Per-machine tables: 60.9 decode on an M2 Ultra, 99.7 on an RTX 5090 D | DEV Community presents the blog figures as a 48GB MacBook Pro result |
| Mac support | macOS and Apple M-series from day one | The November 13 news entry says NVIDIA GPU only; Metal support merged November 14, Q3_K only | Enjoy (November 13) recorded the Mac as unsupported |
| License | Described only as open source | Apache 2.0 code; weights under a custom license plus Qwen's | AIbase and Emergent do not mention a license |
| 120B scores | DeepSWE 53.6, Terminal-Bench 81.3 | 51.3 and 75.3 | Enjoy and FreeAnswers flag the mismatch |
| Release date | November 12 | README news entry dated November 13 | Mostly November 12 |
| Hugging Face repo | Links the NVFP4 repositories | Both Q3_K and NVFP4 | DEV Community points to the q3k repository |
The two accounts of the model's origin are less contradictory than they look. The blog's wording is that the model is trained in its on-device architecture from the outset, without treating local deployment as a compression or pruning step applied to a cloud model. The model card is more specific. In all 48 layers of Qwen3.8-Flash-Next, the routed experts were replaced with a latent MoE. Because the architecture changed, the model was post-trained on a long schedule over Edge0's own data, and it was trained natively at 4 bits. In short, it is a derivative that takes Qwen's skeleton, swaps in a new expert layer and retrains. Outlets that read only the blog wrote that it was trained from scratch because the blog never states the relationship to Qwen. The Hugging Face metadata lists Qwen/Qwen3.8-Flash-Next as the base model.
2. The arithmetic: how 145B becomes 29GB
Multiply the parameter count by the bits stored per parameter and divide by eight, and you get bytes. If all 145 billion parameters had to sit in memory at once, the sums would be as follows.
| Bits per parameter | Calculation | Size needed |
|---|---|---|
| 16 bits (a common training precision) | 145B × 16 ÷ 8 | 290GB |
| 8 bits | 145B × 8 ÷ 8 | 145GB |
| 4 bits | 145B × 4 ÷ 8 | 72.5GB |
| 3.44 bits (the stated Q3_K rate) | 145B × 3.44 ÷ 8 | about 62.4GB |
| In reverse: to fit everything in 29GB | 29GB × 8 ÷ 145B | 1.6 bits per parameter |
Even at 4 bits the total is 72.5GB. Fitting everything into 29GB would require storing each parameter in 1.6 bits, and no build Edge0 ships is that small. So 29GB is not the size of the model. It is the size of whatever is loaded in memory at one time.
The actual files show the structure. Adding up the file sizes in the Edge0-145B-q3k repository on Hugging Face gives this.
| Component | Parameters | Stored precision | File size | Where it normally lives |
|---|---|---|---|---|
| Expert pool (experts.bin) | 84.6B | about 3.8 bits on average | 40.08GB (37.32 GiB) | Frequent experts on the GPU, the rest in system memory or on SSD |
| n-gram embedding table (ple-fp8.gguf) | 51.2B | 8 bits | 51.20GB (47.68 GiB) | SSD, with only the needed rows read |
| Remainder (attention layers, shared parts, draft-prediction layer and so on) | about 9.2B (by subtraction) | Mixed, 4 to 16 bits | about 15GB | GPU and system memory |
| Whole folder | 145B | — | 106.28GB (98.98 GiB) | Disk |
The 3.8-bit average for the expert pool matches the model card's explanation. The Q3_K build is not a uniform 3-bit format. Of the three matrices that make up an expert, two are stored at 3.44 bits and one at 4.5 bits: (3.44 × 2 + 4.5) ÷ 3 is about 3.79 bits. And 84.6B × 3.79 ÷ 8 comes to about 40.1GB, which agrees with the 40.08GB file.
Two things follow. First, 51.2 billion of the 145 billion parameters are an embedding table. At 8 bits it takes 51GB, but it is never loaded whole; it stays on the SSD and only the rows needed are read. This is what the blog means by about 48GB of vocabulary data on the SSD (51.2GB is 47.68 GiB). Take the table out and roughly 93.8 billion parameters do the actual computing. Divide Edge0's stated Q3_K weight size of 40.81 GiB (about 43.8GB) by that, and the result is about 3.7 bits per parameter. Second, 43.8GB is still more than 29GB. Memory use drops below 29GB only if part of the expert pool is left on the SSD and read on demand.
Setting the memory figures Edge0 published in its repository beside the blog's figure makes the gap plain.
| Condition | GPU memory | System memory | Total | Decode speed | Source |
|---|---|---|---|---|---|
| RTX 5090 D 24GB, Q3_K, all experts resident | 23.14 GiB | 31.28 GiB | 54.42 GiB | 99.7 tokens/s | GitHub README |
| RTX 5090 D 24GB, NVFP4, all experts resident | 23.25 GiB | 38.27 GiB | 61.52 GiB | 79.6 tokens/s | GitHub README |
| Same card capped at 16 GiB + 20 GiB | 16 GiB | 20 GiB | 36 GiB | 36.8 tokens/s | GitHub README |
| Apple M2 Ultra, Q3_K | Unified memory (usage not stated) | — | — | 60.9 tokens/s | GitHub README |
| Blog figure | Not broken down | Not broken down | 29GB | 80+ tokens/s | Company blog |
The tightest test in the repository still totals 36 GiB, and under that cap the model generates 36.8 tokens per second, less than half the 80 the blog advertises. The repository row closest to 80 tokens per second is the NVFP4 build on an RTX 5090 D (79.6), a run that used more than 61 GiB in total. Nothing in the public material shows that 29GB and 80 tokens per second came from the same run. The blog attributes its numbers to internal testing and describes the machine only as a compatible laptop such as a MacBook Pro.
The blog is not consistent with itself either. The post that gives 29GB of peak memory also says an expert library of about 40GB sits in system memory, a point raised in the Hacker News discussion. And while the repository documentation calls 16 GiB + 20 GiB a test limit, not a minimum system requirement, the Windows release notes list at least 16 GiB of GPU memory and 20 GiB of system memory as requirements.
A comparison with the base model shows what Edge0 actually reduced.
| Item | Qwen3.8-Flash-Next | Edge0-145B | Edge0-120B |
|---|---|---|---|
| Routed expert parameters | 120.8B | 84.6B (−30%) | 60.4B (−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 + 20 GiB | 18.5 tokens/s | 36.8 tokens/s | 62.4 tokens/s |
These are all from Edge0's model card. The number in the name went up (Qwen calls its own model 125B), but the expert parameters went down by 30%. Qwen's model card lists 125B language-model parameters and then, separately, 51B of n-gram embedding and 4B of multi-token-prediction parameters. Edge0's 145B only adds up if the embedding table is included; counted the same way, the Qwen model would be about 180B. The 145B label does not mean a larger model than its base. It reflects a different counting boundary. Edge0 has not published an itemized breakdown of its total, so this reading rests on subtracting the two published components.
3. Three claims checked — open source, laptop, frontier
Open source. The blog calls Edge0-145B the world's first open-source on-device model with 145 billion parameters. The code and the weights are licensed differently.
| Component | License | Permitted | Needs separate permission |
|---|---|---|---|
| Framework code (edge0-infer and others) | Apache 2.0 | Everything, including commercial use | Nothing |
| edge0-strata engine | MIT | Everything, including commercial use | Nothing |
| Edge0's weight contributions | Edge0 Community Model License 1.0 (dated November 12, 2026) | Personal use, research and education, modification, noncommercial sharing, internal business use, commercial use of outputs | Selling or paid distribution of the model; inference or fine-tuning services funded by fees, subscriptions or advertising; standalone commercial coding or office assistants, even when they run on the user's device |
| Qwen-derived material | Qwen Community License 1.0 | Broad use | Companies running a model-as-a-service or AI work assistant business need a separate Qwen license before commercial use |
By the standards of such licenses, Edge0's terms are permissive. There is no duty to publish modifications and no revenue or user threshold. Employees and freelancers may use the model for paid work. What is reserved is selling the model itself, selling access to it as a service, and selling a coding or office assistant built on it. And Edge0's permission does not stand in for Qwen's: section 2 of the license says so directly. Qwen's license also requires commercial products above 100 million monthly active users or $20 million in monthly revenue to display the model name in the interface.
A license that excludes particular lines of business does not meet the usual definition of open source. A commenter in the Hacker News thread made the same point, calling the release open weights. The accurate description is an open-source engine and conditionally available weights.
Laptop. The blog uses a MacBook Pro as its example and says macOS, Windows and Linux were supported from day one. The repository's record differs.
| Platform | Support | Conditions |
|---|---|---|
| Linux | NVIDIA GPU | CUDA 13; build from source |
| Windows x64 | NVIDIA GPU | RTX 20, 30, 40 or 50 series, at least 16 GiB GPU memory and 20 GiB system memory, CUDA Toolkit 13 installed |
| Windows Arm64 | NVIDIA RTX Spark N1X class | Same memory conditions, CUDA Toolkit 13 for Arm64 |
| macOS (Apple Silicon) | Metal | macOS 26 or later; Q3_K folders only, NVFP4 does not run; default context 32,768 |
| iOS, Android | Not supported | Phones run Edge0-35B only |
The Mac was not supported on launch day. The README's news entry dated November 13 introduces the two models as built for a single NVIDIA GPU on Linux or Windows, and Enjoy's memo, checked against the documents that same day, recorded the Mac column as blank. The code that runs the 145B and 120B on Metal was merged on November 14, and a macOS package of Edge0 Chat was then added to release 0.2.0. The app is ad hoc signed and not notarized, so it must be allowed manually in System Settings on first launch. Several early write-ups said the Mac was unsupported. That was accurate on November 13 and is out of date as of November 16.
A question mark remains over the word laptop all the same. The machines Edge0 measured are an RTX 5090 D and an RTX 4090 (both 24GB desktop graphics cards), an RTX Spark N1X, and an Apple M2 Ultra. The M2 Ultra ships in the Mac Studio and Mac Pro and has never been used in a MacBook. The only MacBook Pro figures are the blog's 29GB and 80 tokens per second, with no model specified. On Windows or Linux, a laptop needs a discrete NVIDIA GPU with at least 16 GiB of its own memory, which rules out thin office machines. Storage matters too: the engine reads experts and the embedding table from disk continuously, so the 106GB needs to sit on a fast SSD.
Frontier. The blog says the model's coding and reasoning rival frontier cloud models. The evidence is six benchmarks.
| Model | DeepSWE 1.1 | Terminal-Bench 2.1 | AA-LCR | IFBench | GPQA-Diamond | HLE |
|---|---|---|---|---|---|---|
| Edge0-145B | 64.6 | 86.5 | 79.3 | 80.6 | 90.4 | 35.4 |
| Edge0-120B (GitHub) | 51.3 | 75.3 | 81.0 | 79.3 | 87.4 | 31.0 |
| Edge0-120B (blog) | 53.6 | 81.3 | 81.0 | 79.3 | 87.4 | 31.0 |
| Qwen3.8-Flash-Next | 58.7 | 83.3 | 79.1 | 81.3 | 91.7 | 35.9 |
| DeepSeek-V4-Flash-0731 | 54.4 | 82.7 | 79.7 | 79.2 | 90.8 | 33.8 |
| Qwen3.8-27B | 42.2 | 73.0 | 82.0 | 79.5 | 89.2 | 30.8 |
| Claude-Opus-4.6 (Max) | No score | 78.2 | 78.0 | 62.5 | 91.3 | 40.0 |
Bold marks the best score in each column. The blog gives the Terminal-Bench 2.1 score as 86.52 and GitHub as 86.5. Four caveats apply.
First, everything is self-reported. The blog states that the Edge0, Qwen, DeepSeek and Claude results all come from Edge0's internal evaluations, which means the party making the announcement also scored its competitors. The evaluation setup and reproduction steps are promised with a technical report. Second, the 145B leads on only two of the six, both coding tests. On the other four it trails at least one model, and its GPQA-Diamond score of 90.4 is below its own base model's 91.7. Third, the six-benchmark mean is 72.8 for the 145B and 71.7 for the base model, a gap of 1.1 points. What the blog is really claiming is not a lead in scores but similar scores at 40% of the memory. The numerator of that 40% is the 29GB discussed above, and the denominator, 70GB, is described by the blog itself as an estimate that remains to be measured. Fourth, the cloud model in the comparison is Claude Opus 4.6, which Enjoy notes is not the current flagship.
The mismatch in the 120B scores is also unresolved. Averaging the blog's numbers gives 68.9, the figure the blog prints; averaging GitHub's gives about 67.6. A six-point difference on Terminal-Bench 2.1 is not a rounding artifact.
4. How to run Edge0-145B, and what remains open
There is one way to run it. The model folder is an Edge0-specific format spread across several files, and Edge0's engine identifies the model from the model.json inside it. Enjoy's memo says Ollama, llama.cpp, LM Studio and vLLM cannot load it, and a Hacker News commenter noted that the release is not a single standard GGUF file. No hosted version exists.
| Step | Windows | Mac (Apple Silicon) | Linux |
|---|---|---|---|
| Prerequisites | NVIDIA GPU (16 GiB or more), CUDA Toolkit 13 | macOS 26 or later | NVIDIA GPU, CUDA 13, build tools |
| Engine | Edge0 Chat from release 0.2.0 (x64, about 276MB) | Edge0 Chat from release 0.2.0 (about 66MB; must be allowed on first launch) | Clone the repository and build edge0-strata and edge0-infer |
| Model | Edge0-145B-q3k or the NVFP4 folder | Edge0-145B-q3k only | Edge0-145B-q3k or the NVFP4 folder |
| Run | Choose the folder in the app, or edge0-infer.exe serve | Choose the folder in the app | edge0-infer serve --model with the folder path |
| Connect | 127.0.0.1:8000, model name edge0_145b | Same | Same |
The server answers both OpenAI-style (Chat Completions) and Anthropic-style (Messages) requests, so existing coding tools can be pointed at the local address. Only the serve and chat commands apply to the 145B and 120B. If memory is short, one option caps the expert cache in system RAM (--resident-budget-gib) and another reads the remaining experts from the SSD (--mmap-experts). Both lower memory use and speed together: the drop from 99.7 to 36.8 tokens per second in the 16 GiB + 20 GiB test is the example. The documentation lists further limits. Concurrent requests queue instead of running in parallel. Image input needs a separate component that is not in the repository. On a Mac, the first start writes a file into the model folder, so the folder must be writable.
That narrows the list of people for whom a trial makes sense. A desktop with a 24GB NVIDIA card and plenty of system memory matches the conditions Edge0 actually measured. Mac support has only just landed, and the single published Mac measurement is on an M2 Ultra.
| Open question | Status |
|---|---|
| Machine and settings behind 29GB | Not disclosed; described only as internal testing on a compatible laptop such as a MacBook Pro |
| Whether 29GB and 80 tokens/s are the same run | Cannot be confirmed; no repository row matches |
| Independent benchmark replication | None; the technical report is promised but not found |
| 120B score mismatch | Blog and GitHub still differ |
| Minimum requirements | The README says test limit; the release notes say at least 16 GiB and 20 GiB |
| MacBook Pro measurements | None published |
| NVFP4 on Mac | Not supported; no schedule given |
| Breakdown of the 145B | Only the 84.6B expert pool and 51.2B embedding table are published; the rest is known by subtraction |
| Company details | Location, founders and funding are absent from the blog and repository |
To sum up: Edge0-145B takes Qwen3.8-Flash-Next, rebuilds its expert layer in a smaller form, keeps the large table on the SSD and the busiest experts on the GPU, and in that way gets a model of more than 100GB running on consumer hardware. That it can be downloaded and run, and that the engine code is open, is confirmed. The line about 145 billion parameters in 29GB refers to the portion resident in memory, not the model, and the conditions under which that figure was measured have not been published. Open source applies to the engine only, and frontier rests on scores the company gave itself.
Our earlier explainers give the background: the one on mixture-of-experts models covers why activating only some experts cuts memory, using Qwen3.8-Flash-Next as the example, and the one on model quantization covers what happens to size and quality as bits are removed. The explainer on open-weight models sets out how releasing weights differs from open source, and the one on on-device AI covers the memory and power limits of running models on phones and laptops.
Sources
- Edge0 blog — Introducing Edge0-145B: Frontier AI Capabilities on Your Own Computer (2026-11-12)
- GitHub — Edge0-AI/Edge0 repository README (as of 2026-11-15)
- GitHub — Edge0 145B and 120B model documentation (docs/models/edge0-145b.md)
- GitHub — Edge0 release 0.2.0 notes (Windows and macOS package requirements)
- GitHub — Edge0 Community Model License 1.0, full text (2026-11-12)
- GitHub — Qwen Community License 1.0 (reproduced unchanged in the Edge0 repository)
- Hugging Face — Edge0/Edge0-145B-q3k model card
- Hugging Face API — Edge0/Edge0-145B-q3k file list and sizes
- Hugging Face — Qwen/Qwen3.8-Flash-Next model card
- Enjoy — Edge0-145B memo (2026-11-13)
- DEV Community — Edge0-145B: a 145B model that runs on your laptop (2026-11-13)
- FreeAnswers — Edge0-145B (2026-11-15)
- AIbase — Edge0 open-sources Edge0-145B and Edge0-120B (2026-11-13)
- Emergent — Edge0-145B open source 145B device model 29GB (2026-11-13)
- Hacker News — Edge0-145B: Frontier AI Capabilities on Your Own Computer (posted 2026-11-12)