mrkeyoor.com_
Tue 01 Sept 17:46 UTC
Self-Hostedevaluationupdated 29 Aug 2026

Qwen3.8-Flash-Next-Dual-DGX-Sparks review

Qwen3.8-Flash-Next-Dual-DGX-Sparks is an English-language Shell recipe for serving one specific large Qwen model across two NVIDIA DGX Spark computers. Its English documentation packages the networking, memory settings, patched SGLang image, weight transfer, and server startup into one script for people assembling that exact pair.

+53 / 2dstars / 7d
Verdict

Our 2026-08-29 sandbox did not execute commit 344f9d0 because this Shell repository has no supported ecosystem or Dockerfile. Use the recipe if you own exactly two DGX Sparks, want this Qwen checkpoint, and can investigate the open memory, path, and token-loop reports yourself. Everyone else should begin with a broader DGX Spark guide or a serving engine whose hardware path they can test directly.

We ran it

Screenshot of Qwen3.8-Flash-Next-Dual-DGX-Sparks (x.com/MiaAI_lab)

Answers from our run

Did you run Qwen3.8-Flash-Next-Dual-DGX-Sparks yourself?

No. Its code is Shell, and it carries no manifest our lab installs from, and no Dockerfile, so there was nothing standard to install, build or test. This review is written from the repository's own documentation.

Who should not use Qwen3.8-Flash-Next-Dual-DGX-Sparks?

Anyone with one DGX Spark or a different GPU layout: the documented topology assumes two GB10 nodes joined by a direct ConnectX-7 link.

What are the alternatives to Qwen3.8-Flash-Next-Dual-DGX-Sparks?

NVIDIA DGX Spark Playbooks, spark-vllm-docker, SGLang. Use the recipe if you own exactly two DGX Sparks, want this Qwen checkpoint, and can investigate the open memory, path, and token-loop reports yourself.

Setup1/5Needs two DGX Sparks, RoCE, SSH, Docker, and manual tuning
Docs4/5Detailed topology and recovery notes; config defaults still conflict
Community3/5177 stars and active issue replies within three days of launch
Maturity2/5No release tag; serious memory and token-loop reports remain open

Who it’s for

DGX Spark owners serving Qwen3.8-Flash-Next-NVFP4 across exactly two GB10 nodes.
Engineers comfortable debugging Docker, SSH, RoCEv2, NCCL, CUDA kernels, and SGLang together.
Local AI operators who want an OpenAI-compatible endpoint and can keep the service on a trusted network or configure its API key.
Researchers willing to validate long-context and tool-call behavior on their own hardware before depending on it.

Who it’s NOT for

Anyone with one DGX Spark or a different GPU layout: the documented topology assumes two GB10 nodes joined by a direct ConnectX-7 link.
Teams wanting a routine package install: setup needs Docker, the Hugging Face CLI, passwordless SSH, about 135 GB of weights per node, and a locally patched image.
Operators who need the advertised 1M-token setting to be a safe service limit: open issue 11 reports a two-node pair becoming unusable far below that configured window.
Agent workloads that cannot tolerate token corruption or restart procedures: open issue 19 documents repeated token ID 0 output when thinking and tools are combined with the default NVFP4 KV cache.
Buyers who require tagged releases and a settled compatibility contract: GitHub has no release for this repository.

Setup reality

Our 2026-08-29 sandbox did not run commit 344f9d0. The repository is Shell and has no Dockerfile, so it falls outside our supported ecosystems; there are no install, build, or test results to report.

The documented path needs two DGX Sparks, Docker, the Hugging Face CLI, passwordless SSH, a direct ConnectX-7 link, and model access where required. You must copy .env.example, set both fabric addresses and the worker host, then decide whether the API should require a key.

The script creates a patched SGLang image on both nodes, moves roughly 135 GB of weights to the worker, and binds the API to all interfaces on port 8888. Current open reports cover an HF_HOME path rejection, a template that differs from the documented memory settings, and failures involving long prompts or thinking with tools.

The recipe targets exactly two DGX Sparks

Qwen3.8-Flash-Next-Dual-DGX-Sparks wraps one narrow deployment: a 176B-parameter NVFP4 Qwen mixture-of-experts model spread across two NVIDIA DGX Spark GB10 machines. The pair communicates over a direct 200 Gb RoCEv2 link, while SGLang exposes an OpenAI-compatible API on port 8888. The attraction is specificity. The author has put the fabric checks, model download, weight copy, image changes, launch, readiness probe, logs, smoke request, and stop command behind start.sh.

That specificity also defines the buyer. Our sandbox examined commit 344f9d0 on 2026-08-29, but ordinary Debian resources cannot represent the documented target. The recipe assumes two 128 GB DGX Spark systems, ConnectX-7 ports, passwordless SSH, Docker on both nodes, and enough storage for roughly 135 GB of weights on each machine. A developer with one Spark, x86 CUDA servers, or a switched multi-node fabric would be adapting the design rather than following it.

What happened when we ran it

Our 2026-08-29 sandbox did not run commit 344f9d0. The checkout is classified as Shell, our harness has no supported ecosystem for it, and the repository contains no Dockerfile. On the supplied 3-CPU, 8 GB unprivileged Debian container, there is therefore no install time, dependency count, build result, or test result to report. We also did not substitute the project's hardware claims for measurements from our own box.

The missing run matters more here than it would for a small utility. start.sh orchestrates two physical hosts and generates a patched container build context for SM121 kernels. A single local container cannot confirm the direct RoCE link, NCCL routing, unified-memory pressure, CUDA graph capture, weight synchronization, or a response from both tensor-parallel ranks. commit 344f9d0 is the exact revision our lab considered; the default branch moved again on August 29 with a token-loop abort change.

One command still leaves several operator decisions

The quick path is short on paper: copy .env.example, edit the two fabric addresses and worker name, run the doctor, obtain about 135 GB of model data, then serve. Under that command, the script checks GPUs and networking, prepares the patched SGLang image on both hosts, verifies model shards, copies them to the worker, starts tensor parallelism at 2, and waits for the API. Reruns reuse cached work, which is useful after a failed image or network step.

Security and exposure remain your job. The service binds to 0.0.0.0:8888, and API_KEY is empty in the example configuration. That is reasonable on a closed lab network, but it is unsafe as an accidental public endpoint. Open issue 18's path report also shows the launcher rejecting a valid snapshot under HF_HOME after 135.25 GB had already been verified. The report is open, so custom cache locations deserve a dry preflight before maintenance windows.

The 1M setting is a configured window, not a proven safe limit

The README defaults CONTEXT_LENGTH to 1,048,576 and says the author's NVFP4 retrieval checks are reliable through 128k on its pair. Those statements describe different boundaries. Issue 11's long-context report says another two-node GB10 setup exhausted usable memory between 294,912 and 327,680 tokens, retained memory after an aborted request, and needed a power cycle after a larger attempt. That report has no maintainer reply yet. Treat 1M as an option to investigate, not a capacity promise.

Configuration parity is another concern at the measured 344f9d0 revision. Issue 21 points out that .env.example leaves MAMBA_FULL_MEMORY_RATIO empty, which invokes SGLang's 0.9 default, while the README's measured profile uses 0.3. The current example still contains the empty value and sets the static memory fraction to 0.80, although parts of the README discuss 0.82. Copying the template does not reproduce the documented profile without deliberate edits.

Tool calling still has a token-loop failure report

The repository exists because upstream SGLang needed SM121-specific sparse-attention work for this model. Its patches steer decode away from a path associated with repeated token ID 0 output and add NVFP4 KV handling for Qwen Sparse Attention. The latest August 29 commit adds a guard that aborts after 16 consecutive zero-token samples, avoids caching that completion, and resets the prefix cache. That limits damage from a runaway response, but an abort is recovery behavior rather than correct generation.

Issue 19 reports the default NVFP4 KV cache entering the repeated ! loop when thinking and tools are used together. Seven comments and the new guard show active investigation. For an agent endpoint, reproduce your longest multi-turn tool sequence before routing real work to it. Our 3-CPU, 8 GB sandbox offers no evidence about that CUDA path, and the README's per-request workaround disables thinking for affected calls.

Five open items and no release make this an early recipe

GitHub showed 177 stars, 5 open issues and pull requests, an MIT license, and a last push on August 29, 2026. There is no latest release. Activity is unusually fast for a repository created on August 26: multiple fixes for shard verification, SSH behavior, fabric checks, log permissions, and half-assembled clusters merged within two days. That pace is encouraging for debugging, while the lack of a release means operators must pin a commit and review changes themselves.

This is worth studying if the hardware and model names in the title exactly match your rack. It records failures that most deployment recipes hide, including frozen machines, memory budgeting, and a server returning HTTP 200 while decoding bad tokens. The 2026-08-29 lab result remains a non-run, so adoption should begin with the project's doctor command and an isolated pair. If you need a general DGX Spark platform, NVIDIA's playbooks or a direct SGLang deployment gives you a less specialized base.

Alternatives

ProjectWhat it isPick it when
NVIDIA DGX Spark PlaybooksNVIDIA's collection of workload guides for DGX Spark hardware.pick this instead when you want vendor-maintained starting points across several workloads rather than one Qwen checkpoint.
spark-vllm-dockerA Docker configuration for running vLLM across two DGX Sparks.pick this instead when vLLM compatibility matters more than this recipe's Qwen-specific SGLang patches.
SGLang gh↗The upstream serving engine used and patched by this repository.pick this instead when you need to choose your own model, topology, and supported hardware path.

What people are saying

  1. [velocity-scout] MiaAI-Lab/Qwen3.8-Flash-Next-Dual-DGX-Sparks

Sources

  1. Project README
  2. Measured commit 344f9d0
  3. Issue 11: long-context memory ceiling and retained memory
  4. Issue 18: HF_HOME snapshot path rejection
  5. Issue 19: thinking and tool-call token loop
  6. Issue 21: example configuration differs from documented profile
  7. Issue 22: another cluster's throughput report
  8. NVIDIA DGX Spark Playbooks

More self-hosted reviews

v2 · OpenShell · wigolo · Mindwtr · club-3090 · reclip · the whole board →