Skip to content
TEN Brief Ten verified stories a day 2026.11.16 KO

이 기사는 한국어로도 읽을 수 있습니다 →

Tech · 15 min read · Breaking

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.

A sunlit desk by a window with an open laptop beside a small desktop computer whose glass panel shows a graphics card, and a person seen from behind reaching for the keyboard

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:

ItemEdge0-145BEdge0-120B
Total parameters145B120B
Active per token10.12B8.64B
Layers4848
Experts per layer512 (10 routed + 1 shared)512 (10 routed + 1 shared)
Expert pool84.6B, latent width 1,79260.4B, latent width 1,280
n-gram embedding table51.2B, 8-bit, read from SSD51.2B, 8-bit, read from SSD
Weight size (Q3_K / NVFP4)40.81 GiB / 47.79 GiB27.98 GiB / 32.96 GiB
Context256K256K

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.

QuestionCompany blog (November 12)GitHub and Hugging FaceOther coverage
Origin of the modelTrained in its on-device architecture from the outset; Qwen appears only as a comparisonDerived from Qwen3.8-Flash-Next, with the expert layer rebuilt and post-trainedAIbase reported it as trained from scratch; Enjoy and DEV Community describe it as a Qwen derivative
Memory29GB peak (28GB in one paragraph)23.14 GiB + 31.28 GiB measured; 16 GiB + 20 GiB is a test limitThe release notes say at least 16 GiB GPU and 20 GiB system memory
Speed1,100+ prefill, 80+ decode tokens per secondPer-machine tables: 60.9 decode on an M2 Ultra, 99.7 on an RTX 5090 DDEV Community presents the blog figures as a 48GB MacBook Pro result
Mac supportmacOS and Apple M-series from day oneThe November 13 news entry says NVIDIA GPU only; Metal support merged November 14, Q3_K onlyEnjoy (November 13) recorded the Mac as unsupported
LicenseDescribed only as open sourceApache 2.0 code; weights under a custom license plus Qwen'sAIbase and Emergent do not mention a license
120B scoresDeepSWE 53.6, Terminal-Bench 81.351.3 and 75.3Enjoy and FreeAnswers flag the mismatch
Release dateNovember 12README news entry dated November 13Mostly November 12
Hugging Face repoLinks the NVFP4 repositoriesBoth Q3_K and NVFP4DEV 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 parameterCalculationSize needed
16 bits (a common training precision)145B × 16 ÷ 8290GB
8 bits145B × 8 ÷ 8145GB
4 bits145B × 4 ÷ 872.5GB
3.44 bits (the stated Q3_K rate)145B × 3.44 ÷ 8about 62.4GB
In reverse: to fit everything in 29GB29GB × 8 ÷ 145B1.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.

ComponentParametersStored precisionFile sizeWhere it normally lives
Expert pool (experts.bin)84.6Babout 3.8 bits on average40.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.2B8 bits51.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 bitsabout 15GBGPU and system memory
Whole folder145B—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.

ConditionGPU memorySystem memoryTotalDecode speedSource
RTX 5090 D 24GB, Q3_K, all experts resident23.14 GiB31.28 GiB54.42 GiB99.7 tokens/sGitHub README
RTX 5090 D 24GB, NVFP4, all experts resident23.25 GiB38.27 GiB61.52 GiB79.6 tokens/sGitHub README
Same card capped at 16 GiB + 20 GiB16 GiB20 GiB36 GiB36.8 tokens/sGitHub README
Apple M2 Ultra, Q3_KUnified memory (usage not stated)——60.9 tokens/sGitHub README
Blog figureNot broken downNot broken down29GB80+ tokens/sCompany 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.

ItemQwen3.8-Flash-NextEdge0-145BEdge0-120B
Routed expert parameters120.8B84.6B (−30%)60.4B (−50%)
Expert parameters per token2.36B1.65B1.18B
Expert pool on disk (NVFP4)63.2 GiB44.3 GiB31.6 GiB
Decode at 16 GiB + 20 GiB18.5 tokens/s36.8 tokens/s62.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.

ComponentLicensePermittedNeeds separate permission
Framework code (edge0-infer and others)Apache 2.0Everything, including commercial useNothing
edge0-strata engineMITEverything, including commercial useNothing
Edge0's weight contributionsEdge0 Community Model License 1.0 (dated November 12, 2026)Personal use, research and education, modification, noncommercial sharing, internal business use, commercial use of outputsSelling 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 materialQwen Community License 1.0Broad useCompanies 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.

PlatformSupportConditions
LinuxNVIDIA GPUCUDA 13; build from source
Windows x64NVIDIA GPURTX 20, 30, 40 or 50 series, at least 16 GiB GPU memory and 20 GiB system memory, CUDA Toolkit 13 installed
Windows Arm64NVIDIA RTX Spark N1X classSame memory conditions, CUDA Toolkit 13 for Arm64
macOS (Apple Silicon)MetalmacOS 26 or later; Q3_K folders only, NVFP4 does not run; default context 32,768
iOS, AndroidNot supportedPhones 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.

ModelDeepSWE 1.1Terminal-Bench 2.1AA-LCRIFBenchGPQA-DiamondHLE
Edge0-145B64.686.579.380.690.435.4
Edge0-120B (GitHub)51.375.381.079.387.431.0
Edge0-120B (blog)53.681.381.079.387.431.0
Qwen3.8-Flash-Next58.783.379.181.391.735.9
DeepSeek-V4-Flash-073154.482.779.779.290.833.8
Qwen3.8-27B42.273.082.079.589.230.8
Claude-Opus-4.6 (Max)No score78.278.062.591.340.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.

StepWindowsMac (Apple Silicon)Linux
PrerequisitesNVIDIA GPU (16 GiB or more), CUDA Toolkit 13macOS 26 or laterNVIDIA GPU, CUDA 13, build tools
EngineEdge0 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
ModelEdge0-145B-q3k or the NVFP4 folderEdge0-145B-q3k onlyEdge0-145B-q3k or the NVFP4 folder
RunChoose the folder in the app, or edge0-infer.exe serveChoose the folder in the appedge0-infer serve --model with the folder path
Connect127.0.0.1:8000, model name edge0_145bSameSame

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 questionStatus
Machine and settings behind 29GBNot disclosed; described only as internal testing on a compatible laptop such as a MacBook Pro
Whether 29GB and 80 tokens/s are the same runCannot be confirmed; no repository row matches
Independent benchmark replicationNone; the technical report is promised but not found
120B score mismatchBlog and GitHub still differ
Minimum requirementsThe README says test limit; the release notes say at least 16 GiB and 20 GiB
MacBook Pro measurementsNone published
NVFP4 on MacNot supported; no schedule given
Breakdown of the 145BOnly the 84.6B expert pool and 51.2B embedding table are published; the rest is known by subtraction
Company detailsLocation, 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

  1. Edge0 blog — Introducing Edge0-145B: Frontier AI Capabilities on Your Own Computer (2026-11-12)
  2. GitHub — Edge0-AI/Edge0 repository README (as of 2026-11-15)
  3. GitHub — Edge0 145B and 120B model documentation (docs/models/edge0-145b.md)
  4. GitHub — Edge0 release 0.2.0 notes (Windows and macOS package requirements)
  5. GitHub — Edge0 Community Model License 1.0, full text (2026-11-12)
  6. GitHub — Qwen Community License 1.0 (reproduced unchanged in the Edge0 repository)
  7. Hugging Face — Edge0/Edge0-145B-q3k model card
  8. Hugging Face API — Edge0/Edge0-145B-q3k file list and sizes
  9. Hugging Face — Qwen/Qwen3.8-Flash-Next model card
  10. Enjoy — Edge0-145B memo (2026-11-13)
  11. DEV Community — Edge0-145B: a 145B model that runs on your laptop (2026-11-13)
  12. FreeAnswers — Edge0-145B (2026-11-15)
  13. AIbase — Edge0 open-sources Edge0-145B and Edge0-120B (2026-11-13)
  14. Emergent — Edge0-145B open source 145B device model 29GB (2026-11-13)
  15. Hacker News — Edge0-145B: Frontier AI Capabilities on Your Own Computer (posted 2026-11-12)

Verification

Published
Last modified
Cross-check
Checked against 15 independent sources.
Unverified
  • The 29GB peak memory, 1,100+ tokens per second prefill, 80+ tokens per second decode and roughly 120W power draw are Edge0's own blog figures. The machine, the build (Q3_K or NVFP4) and the memory options used are not disclosed. The blog names a MacBook Pro only as an example of a compatible laptop, and one paragraph of the same post says 28GB. No row in the repository's speed tables matches these numbers exactly.
  • In the breakdown of the 145B total (84.6B expert pool + 51.2B embedding table + about 9.2B remainder), the remainder is our subtraction of the two published components from the total. Edge0 has not published an itemized breakdown. That the 51.2B embedding table is counted inside the 145B is likewise inferred from this subtraction.
  • Qwen3.8-Flash-Next's model card lists 125B language-model parameters (6B activated) plus 51B of n-gram embedding and 4B of MTP parameters. We could not confirm that Edge0's 10.12B active figure and Qwen's 6B are counted on the same basis.
  • All six benchmark scores are Edge0's internal evaluations. The blog states that the Qwen, DeepSeek and Claude scores were also produced by Edge0. The evaluation setup and reproduction steps are promised with a technical report, which we could not find. We found no independent replication.
  • Edge0-120B's DeepSWE 1.1 and Terminal-Bench 2.1 scores differ between the blog (53.6, 81.3) and GitHub (51.3, 75.3). The company has not explained which is correct.
  • The timing of Mac support was confirmed from the GitHub commit history (2026-11-14, pull request 214) and the release notes. Release 0.2.0 carries a November 11 publication timestamp, but its text refers to the November 14 merge, so it appears to have been edited afterwards. That the Mac was not listed on November 13 rests on Enjoy's November 13 memo and on the wording of the README's November 13 news entry.
  • No speed or memory measurement on a MacBook Pro has been published anywhere. The only Mac measurement in the repository is a single Apple M2 Ultra row, and the memory capacity of that machine is not stated.
  • That the model cannot be loaded by Ollama, llama.cpp, LM Studio or vLLM is based on Enjoy's memo and a Hacker News comment. We did not test it. The generic run commands that the Hugging Face page displays are not in the model card's own text.
  • We could not confirm from the repository whether training data or training code has been released. What we confirmed as public is the inference engine code and the weights.
  • Edge0's location, founders and funding could not be confirmed from the company blog or the repository. The figures of more than 5 million production devices and more than 110,000 customer organizations are the blog's own.
  • The Hacker News score (355 points) and comment count (105) are as of our check on November 16, 2026.
  • The comparison showing decode 2.0 times faster than Qwen3.8-Flash-Next on the same memory budget (18.5 versus 36.8 tokens per second) is Edge0's own measurement from its model card.
Authoring
Reviewed by a person before publication. The full process is described in the Editorial.

Ten stories, once each morning

We send the three-line summaries only; the full pieces stay on the site. One-click unsubscribe, any time.

Related