Edge0-145B Benchmarks: Terminal-Bench, GPQA, HLE, and IFBench Explained
Edge0-145B's NVFP4 build hits 86.5 on Terminal-Bench 2.1. Here's how it stacks up on GPQA-Diamond, HLE, and IFBench, and the NVFP4 vs Q3_K tradeoff.
What is Edge0-145B?
Edge0-145B is a 145-billion-parameter sparse mixture-of-experts (MoE) model built to run agentic workloads on a single consumer GPU. It’s trained natively at 4-bit precision using NVFP4, a low-precision numeric format designed for efficient inference on modern Nvidia hardware. The headline pitch is that a model this large can still fit and run locally, instead of requiring a multi-GPU server rack, while holding up on hard benchmarks like Terminal-Bench, GPQA-Diamond, HLE, and IFBench.
TL;DR
- Edge0-145B scores 86.5 on Terminal-Bench 2.1, a benchmark that tests whether a model can actually operate a terminal to complete multi-step technical tasks, not just answer questions about code.
- The model is a 145B-parameter sparse MoE architecture, meaning only a fraction of its total parameters activate per token, which is what makes single-GPU inference realistic at this scale.
- It’s trained natively in NVFP4, a 4-bit format, rather than being trained at higher precision and quantized down afterward, which the model card frames as a quality advantage over post-hoc quantization.
- Edge0 reports results across four distinct benchmark families (Terminal-Bench, HLE, GPQA-Diamond, IFBench), each testing a different skill: tool use, broad expert-level knowledge, graduate-level science reasoning, and instruction following.
- There’s a speed versus quality tradeoff between the NVFP4 build and a Q3_K quantized build, with NVFP4 aimed at users with newer Nvidia hardware that supports the format natively, and Q3_K offering broader compatibility at a different performance profile.
- The release is open-weight, distributed on Hugging Face and GitHub, and has already drawn over 14,000 downloads and 226 likes on its model card, signaling meaningful developer interest.
What do Edge0-145B’s benchmark scores actually mean?
Benchmark names get thrown around a lot, so it’s worth unpacking what each one actually measures before comparing numbers.
Terminal-Bench 2.1 tests whether a model can use a real terminal environment to accomplish tasks: writing and running scripts, navigating a filesystem, debugging failures, chaining commands together. It’s a proxy for “can this model act as an agent that does real engineering work” rather than just produce plausible-looking code in a chat window. Edge0-145B’s reported score of 86.5 on this benchmark is the headline number in its release materials, and it’s the clearest signal that the model is being positioned as an agentic, tool-using system rather than a general chatbot.
HLE (Humanity’s Last Exam) is designed to be a very hard, broad knowledge and reasoning test, covering expert-level questions across many academic disciplines. It exists specifically because easier benchmarks have become saturated by frontier models, so HLE scores tend to be low across the board for every model, which makes relative standing more informative than the raw number.
GPQA-Diamond is a graduate-level question set in biology, physics, and chemistry, built so that questions are hard even for people with access to search engines. It’s commonly used as a stand-in for “genuine scientific reasoning” rather than memorized trivia.
IFBench evaluates instruction-following: can the model actually do what it’s told, including obeying formatting constraints, multi-part instructions, and negative constraints (“don’t do X”). This matters a lot for agentic use cases where a model’s output feeds directly into another system, since a model that reasons well but ignores instructions is unreliable in production pipelines.
Taken together, these four benchmarks test different failure modes: tool use, breadth of knowledge, depth of scientific reasoning, and instruction compliance. A model that does well across all four is a reasonable general-purpose agent candidate, rather than being tuned narrowly for one kind of leaderboard win.
How does a 145B model run on a single consumer GPU?
The trick is sparsity. Edge0-145B is a mixture-of-experts model, which means the full parameter count (145 billion) is not all active at once. Instead, the model routes each token through a small subset of “expert” sub-networks, so the actual compute and memory touched per forward pass is much smaller than the total parameter count would suggest. This is the same general architectural idea behind other large MoE releases: you get the capacity benefits of a big model without paying the full inference cost on every token.
The second piece is quantization. NVFP4 is a 4-bit floating-point format aimed at cutting memory footprint and increasing throughput on compatible Nvidia GPUs. What makes Edge0-145B notable here is that it’s described as trained natively in NVFP4, not trained in a higher-precision format (like BF16) and then quantized afterward. Native low-precision training is harder to pull off without quality loss, but when it works, it tends to produce better results at a given bit-width than post-training quantization of a model that never saw 4-bit arithmetic during training.
Remy.
Combine sparse activation with native 4-bit weights, and you get a model whose active memory and compute footprint during inference is small enough to target a single consumer-grade GPU, despite the headline parameter count sounding like server-cluster territory.
NVFP4 vs Q3_K: which build should you run?
Edge0 ships in more than one quantization format, and the two most relevant for comparison are NVFP4 and Q3_K.
NVFP4 is the native training format and is optimized for Nvidia GPUs that support 4-bit floating-point execution in hardware. On supported cards, this format is built to deliver the best combination of speed and quality the model can offer, since the weights were never compressed from a different precision.
Q3_K is a different quantization scheme (part of the GGUF-style K-quant family commonly used in the llama.cpp ecosystem) that compresses the model to roughly 3-bit precision. It trades some quality for broader hardware compatibility, including GPUs and setups that don’t support NVFP4 natively, and it’s a format widely supported across local-inference tools outside the Nvidia-specific stack.
The practical tradeoff: if you have modern Nvidia hardware that supports NVFP4, that build is the one to run for the best balance of throughput and benchmark-level quality. If your hardware doesn’t support NVFP4, or you need maximum compatibility with existing local-inference tooling, Q3_K is the fallback, at some cost to quality and possibly speed depending on your specific GPU and memory setup. Neither is strictly better in all situations. It depends on what hardware you’re actually running.
Is Edge0-145B worth running locally?
For developers who want an agentic model that can drive a terminal, follow instructions reliably, and handle broad knowledge and science questions, Edge0-145B’s benchmark spread across Terminal-Bench, HLE, GPQA-Diamond, and IFBench suggests it’s built for exactly that kind of generalist, tool-using role rather than as a narrow chat model. The fact that it’s open-weight and already has over 14,000 downloads suggests real developer uptake, not just a marketing release.
Whether it’s “worth it” for a given team depends mostly on hardware. The entire value proposition rests on being able to run a 145B-parameter model on one consumer GPU, so if your hardware doesn’t support NVFP4 and you’re forced into a heavier quantization format, you lose some of the quality edge the benchmarks demonstrate. Teams already invested in Nvidia hardware with NVFP4 support get the cleanest path to the numbers reported on the model card.
Frequently Asked Questions
What does the 86.5 Terminal-Bench 2.1 score mean?
It means Edge0-145B completed a large share of multi-step, real-terminal agentic tasks correctly in the Terminal-Bench 2.1 evaluation suite. This benchmark specifically tests tool use and command-line task completion, not just conversational code generation, so a high score indicates stronger agentic reliability.
Is Edge0-145B open source?
Edge0-145B is distributed as an open-weight model, available through Hugging Face and GitHub. Weights are downloadable and the model card documents setup directly, which is why it has accumulated thousands of downloads since release.
What’s the difference between NVFP4 and Q3_K quantization?
NVFP4 is a native 4-bit floating-point format that Edge0-145B was trained in directly, optimized for compatible Nvidia GPUs. Q3_K is a roughly 3-bit post-training quantization format from the K-quant family, offering wider hardware compatibility at some cost to quality compared to native NVFP4 execution on supported hardware.
Why does Edge0-145B report scores on HLE and GPQA-Diamond specifically?
Both are designed to resist saturation and memorization. HLE covers expert-level questions across many fields specifically because easier exams are no longer discriminating between strong models. GPQA-Diamond uses graduate-level science questions that remain hard even with search access, making both benchmarks useful for testing genuine reasoning rather than retrieval.
Can Edge0-145B really run on one consumer GPU despite having 145 billion parameters?
Yes, because it uses a sparse mixture-of-experts architecture where only a subset of parameters activate per token, combined with native 4-bit NVFP4 weights. That combination substantially reduces the active memory and compute footprint compared to a dense model of the same total size.
