mrkeyoor.comAsk

eagle-hq/EAGLE-4tested 16 Nov 2026commit b88bd4c

EAGLE-4 review

EAGLE-4's supplied 0.1.3 correctness check found seven unexplained divergences among 12,096 outputs; the bundle establishes no resolution for reviewed commit b88bd4c or latest release v0.1.5.

  • Install failed
  • Build 2 s
1,108/1,109passed, run exited non-zero
  • 65 packages
LLM Toolsevaluationupdated 16 Nov 2026
-71stars / 7d

EAGLE-4 is eagle-hq's speculative-decoding integration for language-model serving. A small drafter proposes tokens for a target model to check. The repository supplies eagle-harness and integrations with patched serving engines. Its code is source-available under the Eagle 4 license.

Verdict

EAGLE-4's supplied 0.1.3 correctness check found seven unexplained divergences among 12,096 outputs; the bundle establishes no resolution for reviewed commit b88bd4c or latest release v0.1.5. With correctness qualification as a condition of adoption, inference operators able to assess a documented model pair, patched engine and serving policy should consider evaluating it. Teams requiring OSI-approved licensing or a drop-in upgrade should skip it. Our repository harness installed in 58 seconds and built in 2 seconds, but the test command exited 1 with a missing transformers import. Published speedups provide configuration-specific comparison points, rather than a service-wide guarantee.

EAGLE-4 infographic: a drafter proposes tokens for a target model to check, plus our test result and who it suits
Tested 16 November 2026: uv install failed after 0.8 s. Before that: source install 58 s, build 2 s.

We ran it

Lab card: what happened when we ran EAGLE-4
Lab card from our sandbox run
Install✓ · 58s65 packages · 5456 MB
Build✓ · 2s
Tests✗ · 224s1108 passed · 0 failed · 426 skipped · 1 errors of 1109 (pytest)
Known vulns0(pip-audit)
Repo404 files~54,052 lines of source · 5.7 MB · 4 CI workflows · tests dir

Answers from our run

Does EAGLE-4 build from source?

Dependencies installed in 58 seconds (65 packages), and the build succeeded in 2 seconds. We cloned commit b88bd4c into a clean Debian container with 3 CPUs and no project-specific setup.

Do EAGLE-4's tests pass?

No. The project's own test command finished in 224 seconds and reported 1108 passed, 0 failed, 426 skipped, 1 collection error (pytest).

Does EAGLE-4 have known vulnerabilities in its dependencies?

pip-audit found none in the dependency tree at the time of our run.

Who should not use EAGLE-4?

Teams requiring OSI-approved open-source licensing.

What are the alternatives to EAGLE-4?

DSpark, DFlash 2, ConFu. EAGLE-4's supplied 0.

Setup2/5In our 2026-11-16 run the README’s “uv pip install eagle-harness[sglang] sglang==0.5.…” failed with “× No solution found when resolving dependencies:”, though our source checkout installed in 58 s and built in 2 s.Editor’s note: Installation and build completed, but tests encountered a collection error. The separate attempt omitted documented indexes and stopped before serving.
Docs4/5The README has an install section (“Quick start”) and usage in the same section; we did not run its quickstart ourselves.Editor’s note: The supplied guides specify engine pins and configuration requirements, but the recorded work did not complete a documented serving recipe.
Community4/5Last push on 2026-11-13, 1,290 stars and maintainers answered or closed 3 of the 3 most-discussed issues we sampled.Editor’s note: Three supplied issues contain responses, but this sample does not measure support capacity, adoption or response reliability.
Maturity1/5Latest release v0.1.5 on 2026-11-01 (pre-1.0), repository created 2026-10-20 and its test suite did not pass in our sandbox (1,108 of 1,109 passed).Editor’s note: The harness found four CI workflows and a tests directory, but exited 1. The supplied correctness record does not resolve the seven divergences for b88bd4c or v0.1.5.

How we score

Who it’s for

Inference operators who can qualify a documented target-and-drafter pair, patched engine and serving configuration together.
Engineers comparing completed requests at their expected concurrency, with correctness checks included.
Teams able to assess the source-available license against their intended commercial use.

Who it’s NOT for

Teams requiring OSI-approved open-source licensing.
Developers expecting a drop-in upgrade of stock SGLang or vLLM.
Buyers choosing a serving stack from single-request throughput alone.

Setup reality

Our November 16, 2026 sandbox at commit b88bd4c installed in 58 seconds with 65 dependencies and 5,456 MB on disk, then built in 2 seconds. Tests exited 1 after 224 seconds: 1,108 passed, zero failed, 426 skipped and one collection/setup error. The traceback shows a missing transformers import. pip-audit reported zero known vulnerabilities.

A separate serving attempt stopped at dependency resolution after omitting the documented custom wheel indexes. Its clone took 1 second; installation failed in 0.8 seconds with exit 1. The recorded environment was Python 3.12.12. Teardown completed.

The repository harness recorded 3 CPUs, 8 GB RAM and image label ghcr.io/astral-sh/uv:python3.12-bookworm. The separate attempt used 2 CPUs and 4 GB RAM. NVIDIA pip installation requires a CUDA toolkit and C++ compiler; the AMD route specifies Python 3.10.

Who should use EAGLE-4

EAGLE-4 fits inference operators who can qualify a model pair and patched engine together; teams requiring OSI-approved licensing or a drop-in upgrade should skip it. Before adopting it, account for the supplied 0.1.3 correctness check: seven of 12,096 outputs had unexplained divergences, and the bundle establishes no resolution for reviewed commit b88bd4c or latest release v0.1.5. That finding makes correctness a condition of adoption, alongside throughput and installation. Versioned correctness findings

Our November 16, 2026 sandbox installed EAGLE-4 in 58 seconds and built it in 2 seconds, but the test command exited 1 with a missing transformers import. Those outcomes give an operator a concrete starting point: repository installation completed, while the test command encountered a collection error. The separate serving attempt stopped earlier, at dependency resolution, after using an installation command without the documented custom wheel indexes.

EAGLE-4 is eagle-hq's language-model speculative-decoding project. A small drafter guesses tokens, and the target model checks them together. The repository supplies eagle-harness and integrations with SGLang, vLLM and TokenSpeed. Its practical adoption unit is a target, trained drafter, engine build and runtime configuration, rather than a drafter checkpoint alone. The README describes measured-cost decisions that adapt speculation to the serving setup. EAGLE-4 README, AMD method explanation

What people use EAGLE-4 for

LightSeek reports a 3.04× speedup for a sampled, single-user coding replay at temperature 1. The supplied evaluations also describe local generation, CPU inference and AMD serving. These use cases come from named publishers and a community participant, with different hardware and request shapes. They give inference operators examples to compare with their own traffic, while keeping the source of each performance figure visible. LightSeek coding evaluation

Who ran it Use case Reported outcome
LightSeek / TokenSpeed SWE-smith multi-turn coding-session replay 3.04× speedup over decoding without speculation for one user at temperature 1. Coding replay
NVIDIA developer-forum participant Local Qwen3.8-27B BF16 generation with recompiled SGLang 4.5 tokens/s without speculation and 20.7 tokens/s with EAGLE-4 after warm-up. Local generation report
Eagle team Gemma-4-E2B-it CPU inference through llama.cpp Reported mean speedup of 2.71× across four benchmarks on AWS c5.xlarge. CPU evaluation
AMD contributors Qwen3.8-27B BF16 on one MI355X Reported 289 tokens/s with SGLang and 309 tokens/s with ATOM at concurrency 1. AMD evaluation

The coding replay starts with about 50K context tokens, adds about 800 tokens per subsequent turn and produces 500 output tokens per turn. Its prefix-cache hit rate is roughly 90%. LightSeek reports greedy speedups of 5.21× at concurrency 1 and 1.94× at concurrency 16. These request characteristics make the result particularly relevant to repeated coding-agent turns with substantial context reuse. Coding workload configuration

The local-generation participant used an HP ZGX Nano with 128 GB GB10 hardware and recompiled SGLang because the available build was for x86-64. Their prompt asked for an explanation of hash tables with a short Python example. The report therefore supplies both a generation result and a concrete integration task, with attribution to the participant rather than to our sandbox. GB10 hardware and recompilation report

What happened when we ran it

Our November 16, 2026 sandbox installed EAGLE-4 in 58 seconds, built it in 2 seconds and exited the test command with status 1 after 224 seconds. The repository harness used commit b88bd4c. These are our measurements: the build completed, the test command encountered a collection error, and pip-audit reported zero known vulnerabilities. Installation, build, testing and dependency auditing produced separate recorded outcomes.

Question Answer Verdict Why
Did installation complete? Yes, in 58 seconds; 65 dependencies and 5,456 MB on disk Completed The recorded install step exited successfully.
Did the build complete? Yes, in 2 seconds Completed The recorded build command exited successfully.
Did the test command pass? No; exit 1 after 224 seconds, with 1,108 passed, zero failed, 426 skipped and one collection/setup error Unsuccessful Collection encountered a missing transformers import.
What did pip-audit report? Zero known vulnerabilities Recorded audit result The harness recorded 65 scanned packages.
Did the separate serving recipe install its pinned engine? No; installation failed in 0.8 seconds with exit 1 Stopped at dependency resolution The attempted command omitted the documented custom wheel indexes.
Did the separate container tear down? Yes Completed Its teardown record says teardown: ok.

The checkout contained 404 files, about 54,052 source lines and 5.7 MB. The harness recorded 3 CPUs, 8 GB RAM and image label ghcr.io/astral-sh/uv:python3.12-bookworm. Its scanner found four CI workflow files and a tests directory, and detected no Dockerfile. The documentation separately describes release-image build files and published CUDA images, so the scanner result and the documented distribution routes answer different questions.

The collection error occurred in tests/test_tokenspeed_nemotron.py at line 8, where the test imports LlamaConfig from transformers. Python raised ModuleNotFoundError: No module named 'transformers'. The inner pytest summary reports 1,108 passed, 426 skipped and one error in 219.50 seconds; the outer harness records 224 seconds for the test step. Both timings belong to the same recorded command, rather than to separate test runs.

Where people get stuck: complete commands and patched engines

The separate serving attempt omitted the custom wheel indexes in the documented SGLang installation command. It used commit b88bd4c93a75 on November 16, 2026 in a fresh unprivileged container with 2 CPUs, 4 GB RAM, no published ports and no secrets. The quickstart-lib clone took 1 second. Installation then failed in 0.8 seconds with exit 1 in a recorded Python 3.12.12 environment.

The attempted command was uv pip install eagle-harness[sglang] sglang==0.5.23.dev252+eagle.9 into a fresh environment. The resolver reported no matching version of the pinned SGLang package in the attempted resolution. The complete README command adds the EAGLE-4 CUDA wheel index, PyTorch CUDA index and NVIDIA package index. Restore those documented indexes before interpreting this resolver result as a package-availability problem. Teardown completed after the failed installation. complete installation route

Route Documented setup Practical next step
NVIDIA pip installation Python 3.12, patched engine packages, matching indexes, CUDA toolkit and C++ compiler Keep the full engine-specific installation command together.
vLLM Patched engine and an unquantized KV cache for tree verification Follow the vLLM recipe and its request settings.
TokenSpeed Matching engine and native packages, calibrated serve mode Calibrate the served setup before starting the documented server.
AMD SGLang ROCm dependency closure using Python 3.10 Use the locked AMD dependency set.

The installation guide recommends one environment per engine because stock engine packages lack EAGLE-4's required hooks. Its eagle-harness-check command checks those hooks. An operator can keep installation, hook checking and a completed generation request as three distinct checkpoints, preserving the exact package set at each step. This makes a failure easier to locate than treating every successful package operation as the same deployment outcome. Installation and hook-check guide

One drafter still needs a serving policy

The supplied vLLM guide says verification width stays at 16 across batch sizes without the additional rounds file. Its measured recipe adds calibrated cost tables and a packaged schedule that narrows the tree at high load. The same trained weights can therefore serve different load regimes while runtime policy changes. Keep the cost tables and schedule with the engine configuration when reproducing that recipe. vLLM serving policy

The README says initial requests compile kernels and measure live costs, so they run more slowly. Warm-up belongs beside model pair, precision, engine, concurrency and cache behavior in a comparison record. LightSeek's coding replay shows why load matters: its greedy speedup changes from 5.21× for one concurrent request to 1.94× for 16. A useful evaluation reproduces the intended request pattern at the service's expected load. README benchmark instructions, coding concurrency results

TokenSpeed's reported long-context results distinguish output rate from startup delay. Single-request decode throughput stays between 759 and 822 tokens/s across contexts from 32K to 250K tokens, while time to first token rises from 0.55 to 5.7 seconds. Keep decode throughput, aggregate throughput and time to first token in separate columns: a stable output rate can coexist with a longer wait before generation begins. Long-context evaluation

EAGLE-4 vs alternatives

Issue #8 confirms that DSpark's adaptive verification was off in the cited comparison. LightSeek separately discloses its MTP chain tuning, including the five-token configuration used for its fastest tested baseline. These disclosures identify the configurations behind the method names. They give an operator something specific to reproduce when deciding whether a published comparison resembles the proposed deployment. DSpark configuration response, LightSeek MTP settings

Alternative Supplied comparison Decision use
DSpark Issue #8 says its SGLang 0.5.20 baseline used default static verification and checked all nine draft positions. Compare the intended working configuration on the chosen target.
Built-in MTP LightSeek reports EAGLE-4 at 1.28× MTP speed for one sampled request and 1.37× for greedy decoding. Include the model's existing MTP route in the same workload evaluation.
DFlash 2 Eagle's launch comparison favors EAGLE-4; Reddit participant joost00719 reports better DFlash 2 results on structured output such as code. Include coding and structured requests in a matched comparison.
ConFu Issue #5's responder calls the approaches potentially complementary. Treat the proposed combination as a research question.

LightSeek used MTP's fastest tested chain for its workload: five draft tokens with configuration 5/1/6. It reports that the paper's 7/1/8 chain was about 5% slower on TokenSpeed. In issue #8, Seyfal also describes failed attempts to enable adaptive DSpark verification for Qwen3.8-27B: vLLM refused its Gated DeltaNet layers, while SGLang failed during graph capture or a trimming verification step. MTP baseline configuration, DSpark engine failures

Source-available licensing affects adoption

Commercial Use of a Competing Offering requires a separate written commercial license regardless of revenue. The README describes EAGLE-4 as source-available rather than OSI-approved open-source software. For an inference provider, repository access and commercial permission are separate decisions. Read the applicable code license before treating the available source as permission to incorporate EAGLE-4 into a competing offering. README commercial-license summary

Other Commercial Use is subject to the license's conditions, including a US $20 million Aggregate Revenue threshold measured over any consecutive 12-month period. The README says exceeding that threshold requires a separate commercial agreement before beginning or continuing Commercial Use, and that this requirement continues after a later revenue decrease. Model weights carry their owners' licenses, so assess the code terms and the selected target and drafter weights separately. Revenue conditions and model licensing

What the other reviews get wrong

The preliminary Nemotron report describes September 29 measurements; the October 20 launch report includes a concurrency-512 result. The launch page reports 2.74× vanilla throughput for one request and 1.69× at 512 concurrent requests on four B300 GPUs, TP4, temperature 0. Reading the preliminary single-request scope as the current extent of published evaluation would miss that later result. Preliminary Nemotron evaluation, launch evaluation

RITS describes one drafter spanning load regimes without retraining or hand-tuning; the released vLLM guide supplies the operating details of calibrated costs and a packaged schedule. A launch-day Reddit statement also names only Qwen3.8-27B, whereas the supplied checkpoint page contains a Nemotron-3.5-Super-VL-120B-A12B drafter. The README's exact-output promise needs the versioned correctness record discussed below. These sources concern weights, serving configuration and correctness, respectively. RITS account, vLLM recipe, launch discussion, Nemotron checkpoint

FAQ

DSpark's adaptive verification was off in the cited EAGLE-4 comparison, according to the response in issue #8. Other supplied questions ask about coding and JSON workloads, ConFu, larger target models and engine availability. The answers below retain the named configuration or respondent so a baseline disclosure, community report or training update stays attached to the statement it supports. DSpark question and response

How does EAGLE-4 speculative decoding work?

A small drafter proposes tokens, and the target model checks multiple proposals in one pass. AMD describes EAGLE-Harness measuring drafting and checking costs on the hardware, then choosing a tree that balances accepted tokens against cost. This puts the drafter and runtime policy beside the target model in the serving stack. The drafter supplies candidate tokens; the target performs the checking. AMD architecture explanation

Is EAGLE-4 faster than DSpark, MTP and DFlash?

Eagle and LightSeek report EAGLE-4 wins in their compared settings. DSpark used static verification, while LightSeek tuned MTP to its fastest tested five-token chain. Reddit participant joost00719 reports strong DFlash 2 results on structured output such as code. Read those as a published comparison, a disclosed baseline configuration and a participant's experience, respectively. The comparison table preserves their different roles in a deployment decision. Launch comparison, MTP configuration, structured-output discussion

How do EAGLE-4 speedups vary across coding, JSON and other workload types?

LightSeek reports 3.04× speedup for sampled single-user coding replay, with greedy speedups of 5.21× at concurrency 1 and 1.94× at concurrency 16. FullstackSensei's Reddit question asks for acceleration broken down by workload. The preliminary Nemotron source distinguishes category acceptance measurements from category-level speedup ratios, so acceptance figures answer a different question from the requested coding and JSON acceleration breakdown. Coding evaluation, reader question, acceptance interpretation

Was adaptive verification enabled for DSpark in the EAGLE-4 comparison?

No. Seyfal says the DSpark row used SGLang 0.5.20 with default static verification, without the confidence head, checking all nine draft positions. The response describes attempts to enable adaptive verification that encountered engine incompatibilities for Qwen3.8-27B. Keep that configuration attached to the comparison when deciding which DSpark setup to include in an evaluation of the chosen target and serving engine. Issue #8 response

How does EAGLE-4 compare with ConFu, and could the two be combined?

The responder in issue #5 calls the approaches potentially complementary and proposes examining whether changes to drafter conditioning help EAGLE-4. The issue author's reported ConFu improvement of roughly 10-20% concerns EAGLE-3. Those are different comparison targets: the author's earlier result motivates the EAGLE-4 question, while the response identifies a possible experiment involving the newer drafter. ConFu comparison and proposed integration

Will EAGLE-4 drafters support larger target models such as GLM-5.3-Flash?

Hongyanz says model training is underway in issue #10, which the supplied record marks closed. The question specifically asks about larger targets including GLM-5.3-Flash. An operator can distinguish that training update from the named checkpoint and serving recipe needed for deployment: the response describes work underway, while the question identifies the larger-model use case the reader wants addressed. Larger-model request and response

When will EAGLE-4 be available in llama.cpp and vLLM?

Eagle's launch page reports Gemma CPU evaluations using llama.cpp, and the repository provides a patched-vLLM serving guide. These identify an evaluated CPU implementation and a documented vLLM installation route. The installation guide specifies patched engine packages because stock packages lack EAGLE-4's required hooks. Use the engine-specific guide alongside the selected model pair when turning that availability into a deployment configuration. CPU evaluation, vLLM guide, engine requirements

What we have not tested yet

The seven unexplained divergences identified above affected three 0.1.3 configurations: the one-GPU README command at concurrency 128, one prompt in each of four starts; the four-GPU measured recipe at concurrency 64, one prompt in each of two starts; and the four-GPU high-load recipe at concurrency 512, one prompt in one start. The source says 0.1.4 compares against plain decoding at the same batch size; that statement supplies no demonstrated fix for either reviewed version. Correctness configurations

Other numerical-difference findings are separate. The known-limits page attributes some differences to engine batch-dependent numerics and reports token-for-token matching under a particular deterministic SGLang configuration. AMD qualifies token matching around BF16 near-ties, and the new-model guide requires examining first greedy mismatches. These results do not resolve the seven unexplained outputs. They explain why an adoption check needs the precise engine, batch shape and correctness rule alongside the model pair. Engine numerics, AMD correctness wording, new-model checks

Our execution evidence ends before a served inference result. We have not measured inference throughput, time to first token, GPU memory, request correctness or operating cost. The incomplete installation attempt does not demonstrate that the published package is unavailable. The supplied GB10 report covers one prompt; other performance figures retain vendor or integration-partner attribution. The harness image label records configuration rather than confirmed runtime or operating-system versions.

The missing-import cause beyond the traceback, the coverage represented by 426 skipped tests and the outcome of a repaired test environment remain unresolved. The dependency audit reports known advisories in the recorded environment; it does not assess isolation, authentication or endpoint behavior. Rendered layout, resolved evidence links, automatic related links and recommendation modules also fall outside the supplied execution evidence. No corrected installation command or code example was executed for this revision.

TokenSpeed's documented static path stops at startup with the released sliding-window draft; calibrated serve mode is its documented route. Its 0.1.3 build checks and 0.1.2 measurements concern different configurations. The AMD route requires the Python 3.10 ROCm closure, with no published ROCm image in the supplied documentation. The packaged vLLM rounds profile concerns the Qwen pair on B300 TP4. These boundaries prevent extending a measured recipe to every available engine and device. Installation boundaries, engine and version limits

At high load, SGLang can decode without speculation; vLLM and TokenSpeed can be slower with speculation above concurrency 64. A grammar-constrained vLLM tree batch advances every request by one token per verification round. Structured output and tool calls require the model's engine parser, and raw tool syntax is not a structured response. A request evaluation therefore needs finish reasons and completed-output validation alongside rate measurements. High-load and request limits

Matched JSON performance, continuous phone thermals, multimodal quality, multi-node deployment and arbitrary-target training remain outside our measured results. Phone measurements began with a cool device; preliminary Nemotron decode timing excludes prefill, networking and application overhead. The inspected training bundle lacks a reproducible repository revision. Issue #10 supplies no release date or demonstrated GLM-5.3-Flash checkpoint, and issue #5 supplies no EAGLE-4 versus ConFu head-to-head result. Phone evaluation, preliminary timing scope, training provenance, model request, ConFu response

Alternatives

ProjectWhat it isPick it when
DSparkIssue #8 says the cited baseline used default static verification.Include it in a matched evaluation when its intended configuration works with the chosen target and engine.
DFlash 2A Reddit participant reports strong results on structured output such as code.Include it when coding or JSON dominates the intended traffic, comparing completed outputs on the same workload.
ConFuThe issue #5 responder describes potential complementarity with EAGLE-4.Consider it for a research comparison of drafter conditioning using matched targets and serving conditions.

What people are saying

  1. [velocity-scout] eagle-hq/EAGLE-4

Sources

  1. EAGLE-4 README
  2. EAGLE-4 installation guide
  3. Introducing EAGLE-4
  4. LightSeek training and serving evaluation
  5. Comparison to DSpark
  6. Comparison with ConFu
  7. Extend to larger models
  8. Current known limits

More llm tools reviews