Short answer: Edge0-145B is an open weights AI model with 145 billion parameters that its maker, Edge0, built to run on your own computer instead of in the cloud. Edge0 released it on November 12, 2026, together with a smaller sibling, Edge0-120B, an inference framework and a desktop app (Edge0). Only about 10 billion of those parameters work on each token, which is how Edge0 says it fits in 29GB of memory on a compatible laptop. That figure, like its speed and benchmark numbers, is the lab's own claim. The first independent test we found tells a more mixed story, and the license isn't Apache or MIT, so read both sections before you build on it.
The launch post drew 357 points on Hacker News, so plenty of developers are asking the same thing you probably are: can I really run a 145B model on my machine, and should I? This guide covers what the model is, what Edge0 claims, what an outside tester measured, how to try it, and what the license lets you do.
What is Edge0-145B?
You've probably used an AI model through a website or an API. Your prompt goes to someone else's servers, and you pay per token. A local model flips that: the weights sit on your disk, and your own hardware does the work.
Edge0-145B is a local model that aims much bigger than usual. Edge0 points out that most models built for phones and laptops stayed under about 10 billion parameters until recently, because memory runs out first. Edge0, a newer lab whose earlier Edge0-35B ran on a phone, pushed that to 145 billion. It's pitched at coding, reasoning and agent work, meaning tasks where the model plans steps, writes and runs code, and checks the result.
The model is derived from Alibaba's Qwen3.8-Flash-Next. Edge0 says it isn't a relabel or a simple compression: it rebuilt the expert layers and then trained the model again on its own data (Hugging Face model card).
How can a 145B model run on a laptop?
Think of a big help desk. Every question doesn't go to every agent. A dispatcher sends it to the few people who know that topic. The model works the same way.
That design is called a mixture of experts (MoE). Edge0-145B has 512 small expert blocks in each of its 48 layers. For each token, a router picks 10 of them, plus one shared expert that always runs. So only about 10.12 billion parameters do work per token, even though 145 billion exist.
Edge0 adds two tricks on top. First, groups of experts share large matrices, so there's less to store and move. Edge0 calls this a latent MoE. Second, the engine spreads the model across three tiers: the experts you use most stay on the graphics card, a larger pool sits in system memory, and a big vocabulary table is read from your SSD only when needed. That's why the real question isn't "how big is the model" but "how much GPU memory, RAM and disk speed do I have."
Specs at a glance
From the Hugging Face model card, checked November 18, 2026:
| Spec | Value |
|---|---|
| Total parameters | 145B |
| Active per token | 10.12B |
| Layers | 48 |
| Experts | 512 per layer, 10 routed + 1 shared active per token |
| Context window | 256K tokens |
| Builds | Q3_K (40.81 GiB of weights) and NVFP4 (47.79 GiB) |
| Base model | Qwen3.8-Flash-Next |
| Sibling | Edge0-120B, a smaller version of the same design |
Q3_K and NVFP4 are two compressed formats of the same weights. Compression trades a little precision for a lot less memory.
What Edge0 claims
Here are the headline numbers from Edge0's launch post. They come from Edge0's own testing on hardware it chose.
| Claim | Edge0's number |
|---|---|
| Peak memory on a compatible laptop | 29GB |
| Generation speed | 80+ tokens per second |
| Prompt reading speed | 1,100+ tokens per second |
| Typical power draw | About 120W |
| Context | 128K to 256K tokens |
| DeepSWE 1.1 (coding agent tasks) | 64.6 |
| Terminal Bench 2.1 | 86.52 |
| GPQA Diamond (science questions) | 90.4 |
Edge0 also says the model is competitive with some cloud models, and its table puts it ahead of Qwen3.8-Flash-Next on DeepSWE (64.6 vs 58.7). Those comparison scores also come from Edge0's internal evaluations. Edge0 says the full evaluation setup will come with its technical report.
The model card adds its own speed table. On an RTX 5090 D with 24GB, the Q3_K build reports 99.7 tokens per second for chat and 121.2 for an agent prompt.
What an independent test found
A few days after launch, MAJOR//minor published CUDA Recipes 006, a test of the Q3_K build on one RTX 3090 with 24GB, using Edge0's own stack and default settings. It's the most detailed outside test we found.
The good news: it works, and it's fast. Chat generation ran at 48.6 tokens per second, the median of three runs. That's about 70% of Edge0's published RTX 4090 chat number, on an older card.
The catches:
- It needed more RAM than you might expect. The engine process peaked at 43.4 GiB of system memory, on a machine with plenty to spare. The tester didn't run a capped test, so the true minimum is still unknown.
- The graphics card was full. Peak use was 23,929 MiB out of 24,576 MiB.
- Agent output was shaky. In three runs of the same agent prompt, only one tool call was valid. One wrapped its arguments wrong, and one called a tool that didn't exist.
- The download is big. The Q3_K snapshot was 106 GB on disk, including a 51 GB table the engine reads straight from storage.
The tester is clear that this was one machine, one session and three runs per workload, and that no quality benchmark was run. So treat it as a reality check, not a verdict.
What hardware do you need?
There's no simple minimum yet. Here's what the sources actually say.
Edge0's launch post talks about a compatible laptop such as a MacBook Pro, and its chart marks a 48GB laptop. It lists day one support for macOS, Windows and Linux, including Apple M series chips and NVIDIA RTX cards.
The model card says Q3_K was tested with a budget of 16 GiB of VRAM plus 20 GiB of RAM on a 24GB RTX 5090 D. The card states plainly that these are test limits, not minimum system requirements. On that budget, chat speed dropped to 36.8 tokens per second.
Put that next to the 3090 test's 43.4 GiB and the safe reading is this: plan for a 24GB graphics card or a high memory Mac, a lot of system RAM, and well over 100 GB of fast disk. If you have less, expect to experiment.
How to try Edge0-145B
You have two routes, both linked from the model card.
- The Edge0 App. Edge0 says its core features work offline, with no account or usage quota. On Windows, the desktop app is called Edge0 Chat and you point it at a downloaded model folder.
- The command line. Build Edge0's engine from its GitHub repository, download a model folder from Hugging Face, and run
edge0-infer serve --model /path/to/Edge0-145B-q3k. It starts a local server with OpenAI compatible and Anthropic compatible endpoints, so code you already wrote for a cloud API can point at your own machine instead.
One tip from the model card: if replies come back empty, the model may have spent its whole token budget thinking. Setting "reasoning_effort": "none" skips that thinking pass.
What does the license allow?
The weights are open, but this isn't an Apache or MIT license, and commercial use isn't free across the board. Two licenses apply at once (model card, license text):
- The Edge0 Community Model License 1.0 covers Edge0's own changes.
- The Qwen Community License still covers the Qwen materials the model is built on, with its own commercial conditions.
Under Edge0's license you can run the model for personal use, research, internal use at a company, and noncommercial sharing. You can also use what it generates commercially.
You need a separate written license from Edge0 before you sell or bundle the model, run a paid service that gives others access to it (like an API), or offer a paid coding or office assistant built on it. Edge0's permission doesn't replace anything Qwen requires. If you're thinking about a product, read both license texts in full, and ask Edge0 at info@edge0.ai if your case isn't clear.
When does a local model beat a cloud API for an agent?
Agents call the model over and over: plan, act, check, repeat. That's where local inference gets interesting.
A local model can make sense when:
- Your code or data can't leave your machine.
- Your agent makes so many calls that per token fees add up.
- You need it to keep working offline.
A cloud API still makes more sense when:
- You need dependable tool calls today. One valid call out of three, as in the outside test, isn't something you'd ship.
- You don't have the hardware, or you'd need to buy it just for this.
- You need fresh web results or memory across devices. Edge0 itself says those still need cloud services.
Local isn't free, either. Edge0 notes that hardware and electricity still cost money.
Go deeper
- What is Qwen4-Max: Alibaba's flagship model, from the same family Edge0 built on.
- Reflection AI's Beam: another open weights model aimed at coding and agents.
- What is Mistral AI: the open model family from the French lab.
- What is OpenClaw: an open source agent you run on your own machine.
- AI tools for developers: the 2026 tools, sorted by what they do.
The skill behind picking a model
Running a model is the easy part. The harder part is building something useful on top: an agent that calls tools correctly, checks its own work and fails safely. If you want to learn to build and ship AI apps and agents, not just run models, see how the AI Engineering program works.
