# How to Run a Private Remote AI Assistant on DGX Spark

Canonical source: [https://isaiuseful.com/remote-spark](https://isaiuseful.com/remote-spark)

<a id="main-content"></a>

Remote operator · Linux compute

Run OpenClaw, NemoClaw, Hermes or Open WebUI with Ollama on DGX Spark, then operate it from Windows 11, macOS, Linux, a browser or a messaging channel—without exposing the gateway, model or retrieval ports to the public network.

- [Choose a control surface](#operators)

- [Route a sensitive file](#hybrid-privacy)

- [Build the Spark side](#spark-setup)

Official NVIDIA starting points

## Pick a DGX Spark recipe.

These four official NVIDIA playbooks adapt our [workflow recipes](https://isaiuseful.com/guides.html.md#chooser) , [local-model stack](https://isaiuseful.com/local-models.html.md#runtimes) and [remote-operation runbook](#operators) to DGX Spark. Pick one here, then use our guides for model choice, private access and operating safeguards.

- [Run OpenClaw with a local LLM 30 min Install the local-first agent and connect it to a private OpenAI-compatible model endpoint.](https://build.nvidia.com/spark/openclaw)

- [Run NemoClaw with a local LLM 30 min Build an OpenClaw assistant in an OpenShell sandbox with local vLLM inference.](https://build.nvidia.com/spark/nemoclaw)

- [Run Hermes Agent with a local LLM 30 min Connect the terminal-first Nous Research agent to a model served locally with vLLM.](https://build.nvidia.com/spark/hermes-agent)

- [Open WebUI with Ollama 15 min Use the browser-based chat interface with Ollama and a model running on Spark.](https://build.nvidia.com/spark/open-webui)

- [Official DGX Spark collection **Explore every NVIDIA Spark playbook** Open build.nvidia.com/spark](https://build.nvidia.com/spark)

**Pocket-ready**

phone steers; state stays on Spark
OPENCLAW OR HERMES
**Insider**

for the newest Windows isolation
MXC SESSION PREVIEW
**Localhost**

services cross an SSH tunnel
NO OPEN ADMIN PORTS

Compatibility first

## How can you control DGX Spark remotely?

The operator device can be a phone, laptop or desktop without moving the gateway, memory, models or jobs off the always-on Linux host.

Native companion

### Windows 11

Use OpenClaw Windows Hub for Command Center, notifications and an optional Windows node. The current bleeding-edge containment route adds Windows Insider and MXC; ordinary remote chat does not move the gateway onto Windows.

Native companion

### macOS

Use the OpenClaw menu bar app in Remote mode. It can own the SSH tunnel, health checks and Web Chat while the gateway remains loopback-bound on Spark.

CLI or desktop

### Linux

Use the Linux companion, CLI, browser Control UI or an SSH tunnel. It is also the closest match to Spark when you need to reproduce commands locally.

**iPhone and Android:** use a paired companion, the browser UI or a configured messaging channel. OpenClaw documents iOS and Android as clients of the Gateway—not replacements for it—so Spark keeps the session and compute while the phone carries chat, status, approvals and only the device capabilities you explicitly enable.

- [iPhone companion →](https://docs.openclaw.ai/platforms/ios)

- [Android companion →](https://docs.openclaw.ai/platforms/android)

- [Compare every control surface →](#operators)

### Hardware + price warning · checked 24 July 2026 Do not buy DGX Spark on the assumption that Windows support will arrive later.

DGX Spark and the pre-release RTX Spark family publish strikingly similar headline numbers—up to one petaflop and up to 128 GB unified memory—but NVIDIA currently lists them as different product categories: DGX Spark is a Linux companion system, while RTX Spark is a Windows primary system. Public documentation does not establish that their drivers, firmware or boards are interchangeable, and NVIDIA has announced no Windows driver, Windows image or upgrade path for DGX Spark.

Buy DGX Spark only if DGX OS works for the machine's useful life. Future Windows support is possible in theory, but today it is speculation. There is also no public evidence for claims about NVIDIA's commercial motive; the support gap itself is the decision-relevant fact.

Indicative MSRP · NVIDIA Marketplace Germany
**€4,800**

NVIDIA's own DGX Spark listing displayed this price and was out of stock when checked. Use it as a reference for the NVIDIA-branded system—not a ceiling for partner products. OEMs choose their own configurations and selling prices.

- [Check the current NVIDIA Marketplace price →](https://marketplace.nvidia.com/de-de/enterprise/personal-ai-supercomputers/dgx-spark/)

- [NVIDIA platform comparison →](https://developer.nvidia.com/local-ai)

- [DGX Spark software requirements →](https://docs.nvidia.com/dgx/dgx-spark-porting-guide/porting/software-requirements.html)

- [Pre-release RTX Spark example →](https://www.microsoft.com/en-us/surface/devices/surface-rtx-spark-dev-box)

### NVIDIA AI Enterprise check · GB10 / DGX Spark Do not treat preinstallation, NIM access or a Spark badge as a production entitlement.

A 90-day NVIDIA AI Enterprise—DGX Spark evaluation exists only when it is purchased, requested or explicitly issued on the NVIDIA Entitlement Certificate (EC); not every OEM offer includes it. Record the EC/order line, GPU metric, start and end date, support route and renewal before deployment. It is an evaluation, not a public free-forever entitlement to the complete supported production suite.

Free components remain useful for development: Omniverse and NVIDIA AI Workbench are free, and the standard NVIDIA Developer Program NIM route is for development, research and test up to 16 GPUs with community support. Production self-hosting generally needs NVIDIA AI Enterprise.

- [DGX Spark 90-day evaluation and EC activation →](https://docs.nvidia.com/dgx/dgx-spark/nvaie-quickstart.html)

- [NVIDIA AI Enterprise licensing guide →](https://docs.nvidia.com/ai-enterprise/planning-resource/licensing-guide/latest/licensing.html)

- [NIM developer-program route and production boundary →](https://forums.developer.nvidia.com/t/nvidia-nim-faq/300317)

- [Omniverse license and support route →](https://docs.omniverse.nvidia.com/dev-guide/latest/common/NVIDIA_Omniverse_License_Agreement.html)

- [AI Workbench introduction →](https://docs.nvidia.com/ai-workbench/user-guide/latest/overview/introduction.html)

See the category boundary

### RTX Spark is being introduced as a Windows PC family—not as a DGX Spark software update.

These NVIDIA and Microsoft videos show the platform framing, one announced product and one example workload. Treat them as vendor demonstrations: they clarify positioning, but they do not prove interchangeability, delivery timing or performance for your workflow.

- [Video: NVIDIA RTX Spark Reinvents Windows PCs for the Age of Personal AI](https://www.youtube.com/watch?v=H4nJo-oqAro)

Platform overview · NVIDIA

### A Windows PC category for local AI

Use this overview to understand NVIDIA's intended product category. Keep the announced positioning separate from tested application support on a shipping system.

- [Video: Introducing Surface RTX Spark Dev Box](https://www.youtube.com/watch?v=VlAI1_JkXL4)

Product example · Microsoft

### Surface makes the Windows distinction concrete

The Surface RTX Spark Dev Box is a separate announced Windows product. Its existence is not evidence that a DGX Spark can be converted into one.

- [Video: Architectural Design With Agents on NVIDIA RTX Spark](https://www.youtube.com/watch?v=a6fUvL9gYAQ)

Workload demo · NVIDIA

### Judge the workflow, then test the stack

The architectural-design demo shows how NVIDIA imagines agents using the platform. It is a useful workflow reference, not a benchmark or compatibility matrix.

- [Video: Announcing NVIDIA RTX Spark | GTC Taipei 2026 Keynote by CEO Jensen Huang](https://www.youtube.com/watch?v=11Y3B33oCLE)

Launch context · NVIDIA

### Hear the promise—then compare DGX Station.

The keynote gives the broad RTX Spark context. If 128 GB is the constraint rather than the solution, the DGX Station guide maps the 748 GB tier, realistic model fits and the current benchmark gap.

- [Compare DGX Spark with Station →](https://isaiuseful.com/dgx-station.html.md)

<a id="spark-reviews"></a>

Independent reviews + benchmarks

## Spark is a capacity machine with a measured bandwidth ceiling.

Hands-on third-party tests agree on the shape even when engines, quants and prompts differ: 128 GB unlocks models that ordinary small systems cannot load, while 273 GB/s LPDDR5X limits dense single-stream decode.

Hands-on review

### LMSYS measured the trade.

Its early-access Spark ran GPT‑OSS 20B MXFP4 at 49.7 decode tok/s, but Llama 3.1 70B FP8 at 2.7 decode tok/s. Llama 3.1 8B scaled to 368 aggregate decode tok/s at batch 32. NVIDIA supplied early access, and the authors warn that software results can age.

- [Read the LMSYS methodology and tables →](https://www.lmsys.org/blog/2025-10-13-nvidia-dgx-spark/)

Independent comparison

### Dense 70B was capacity-first, not fast.

A separate published comparison reported 4.67 tok/s for Llama 3.3 70B, 38.03 tok/s for Qwen3 Coder and 60.33 tok/s for GPT‑OSS 20B on Spark. Treat these as workload-specific results, not universal product scores.

- [Inspect the comparison and conditions →](https://www.pcgamer.com/hardware/graphics-cards/nvidias-little-gold-box-of-pure-ai-power-the-dgx-spark-is-finally-out-and-the-comparison-with-amds-much-cheaper-strix-halo-chip-is-looking-a-little-fugly/)

Cluster evidence

### Two nodes need the right parallelism.

StorageReview tested Dell, GIGABYTE and HP pairs over the 200 Gb fabric and found OEM performance within a narrow band. For batched inference at practical concurrency, its pipeline-parallel layout mattered more than small chassis differences.

- [Read the two-node review →](https://www.storagereview.com/review/nvidia-dgx-spark-cluster-review-distributed-inference-on-dell-gigabyte-and-hp)

Independent video reviews

### Two longer practitioner views to put beside the numbers.

These videos add independent system context. Keep their software versions, workloads and methodology attached to any performance observation, and use the normalized table below for direct comparisons.

- [Video: Deep Dive into Nvidia's DGX Spark GB10](https://www.youtube.com/watch?v=Lqd2EuJwOuw)

Independent deep dive · Level1Techs

### Put the GB10 platform under a practitioner’s lens.

Level1Techs examines DGX Spark as a system rather than a specification sheet. Treat its observations as independent context and keep software versions and workload conditions attached to any result.

- [Video: NVIDIA DGX Spark: From “Inference Box” to Dev Rig (What It Actually Is) | Ep 2](https://www.youtube.com/watch?v=0CI19dXmOws)

Independent perspective · Domesticating AI

### Frame Spark as a development rig, not only an inference box.

This longer independent discussion focuses on what the machine is and how its development role differs from a simple inference appliance. Pair the framing with the measured limits below before buying.

Measured snapshot · do not mix rows

### Engine, precision, batch and model architecture explain the spread.

“Tokens per second” without those fields is not a benchmark. Prefill and decode are separate, and aggregate batch throughput is not the speed each interactive user sees.

| Source | Model and format | Workload | Measured Spark result | What it supports |
| --- | --- | --- | --- | --- |
| LMSYS · Oct 2025 | GPT‑OSS 20B · MXFP4 · Ollama | Single-stream decode | 49.7 tok/s | A small sparse model can be comfortably interactive. |
| LMSYS · Oct 2025 | Llama 3.1 70B · FP8 · SGLang | Batch 1 decode | 2.7 tok/s | Loading a large dense model is not the same as serving it quickly. |
| LMSYS · Oct 2025 | Llama 3.1 8B · FP8 · SGLang | Batch 32 aggregate decode | 368 tok/s | Batching can use compute that one bandwidth-bound stream leaves idle. |
| Third-party comparison · Oct 2025 | Llama 3.3 70B | Single prompt | 4.67 tok/s | A second setup reproduces the slow dense-70B shape, not the exact LMSYS number. |
| NVIDIA SANA · Aug 2026 | MiniMax H3 · pruned FP8 · Sol Engine | 5 s video · 480p · 124 frames · 50 steps | 181.3 s optimized · 3.92× | A specialized FP8 runtime makes H3 fit and materially faster; generation remains far from real time. |

**Buying implication:** Spark's best LLM fit is usually a 20–35B daily model or a larger sparse MoE with few active parameters—not the largest dense checkpoint that can be forced into memory. Re-run your exact engine after every major software update. [See where DGX Station changes the boundary →](https://isaiuseful.com/dgx-station.html.md#comparison)

### Spark owner tests · checked 15 August 2026 Muse Glimmer fits one Spark—and DFlash lifts decode into the 20s and 30s.

Meta’s Apache‑2.0 **Muse Glimmer 30B** is a dense local-agent model with tool use, coding and optional image input. Its official GGUF release provides 16.76 GB and 19.65 GB language-model builds, plus a separate 1.40 GB perception encoder and optional 1.63 GB DFlash drafter. That leaves ample room inside a 128 GB Spark-class system for runtime and a useful context budget, although the advertised 131,072+ model limit is not a promise that the maximum context will be fast or memory-efficient.

Early owner runs provide a useful speed range, not a controlled benchmark. On one DGX Spark, a llama.cpp run reported about 10.5 tok/s conventional decode and 36–38 tok/s with the official DFlash drafter at 15 speculative tokens; a separate vLLM run rose from 5–8 tok/s to about 23 tok/s at the same setting. Workload, draft acceptance, quant, context depth and engine build can move those numbers.

The llama.cpp test also reported about 700 tok/s prefill at short context, about 390 tok/s deep into an 832K-token prompt, and 3/3 needle retrieval at 97K, 188K, 415K and 832K after an 8× YaRN and metadata override. Treat that as an extended-context experiment rather than a new guaranteed model limit. Its two-Spark RPC layer split slowed decode to 25–28 tok/s, so a model this size is better run as one instance per Spark unless a measured workload proves otherwise. Pin the exact engine revision and rerun your own tool-call, recovery, context and latency harness.

- [Inspect Meta’s official GGUF files →](https://huggingface.co/meta-models/Muse-Glimmer-30B-GGUF/tree/main)

- [Read Meta’s launch and RTX 5090 speed conditions →](https://research.meta.ai/blog/introducing-muse-glimmer-open-agentic-model)

- [Inspect the DGX Spark llama.cpp and extended-context owner test →](https://www.reddit.com/r/LocalLLaMA/comments/1vl9adk/i_ran_muse_glimmer_1m_context_all_tests_passed/)

- [Inspect the DGX Spark vLLM DFlash owner test →](https://www.reddit.com/r/LocalLLM/comments/1vm4j0i/muse_glimmer_30b_on_dgx_spark_using_dflash_is/)

- [Compare memory fits and vendor benchmarks →](https://isaiuseful.com/local-models.html.md#muse-glimmer)

<a id="minimax-h3-spark"></a>

### Vendor video benchmark · checked 15 August 2026 MiniMax H3 proves the Spark fit—but 3.92× still means three minutes for five seconds.

NVIDIA’s SANA team ran the 33B dense **MiniMax H3** audio-video generator on one DGX Spark at 832×480, 24 fps, 124 frames and 50 denoising steps. Sol Engine reduced end-to-end wall time from 710.6 to 181.3 seconds, a reported 3.92× speedup. The full recipe combines kernel work with approximate Sol‑Attn sparse attention and cross-step caching, so the accompanying near-lossless quality assessment is part of the vendor experiment—not proof that every prompt is unchanged. NVIDIA’s separate GeForce RTX 5090 result uses 1344×768 and must not be treated as an RTX Spark benchmark or compared by raw time.

The ordinary BF16 FL2VA package is about 134.2 GiB before activations, so NVIDIA’s GB10 runtime uses a pruned FP8 DiT, FP8 Qwen3‑VL conditioner and the released VAEs, with one resident model process. MiniMax’s downloadable local system produces 768p H3‑Base output; the recommended Context‑IR preprocessing and Regenerate‑2K stage remain hosted. There is also a procurement-level license gate: the community license excludes the EU, UK, United States and South Korea, with a separate application route for those territories.

- [Inspect NVIDIA’s H3-on-device results →](https://nvlabs.github.io/Sana/Sol-Engine/H3-OnDevice/)

- [Inspect the GB10 runtime and reproducible config →](https://github.com/NVlabs/Sana/tree/sol-engine/models/minimax_h3/GB10)

- [Read the MiniMax H3 model card →](https://huggingface.co/MiniMaxAI/MiniMax-H3)

- [Read the MiniMax H3 license →](https://huggingface.co/MiniMaxAI/MiniMax-H3/blob/main/LICENSE)

- [Request an excluded-territory license →](https://platform.minimax.io/h3-license)

- [Compare the local-model route →](https://isaiuseful.com/local-models.html.md#minimax-h3)

### Native NVFP4 hardware · speculative capacity DGX Spark has Blackwell FP4 hardware. The serving kernel is still a gate.

NVFP4 is promising here because it can shrink weights and reduce memory traffic while preserving more quality than a crude four-bit conversion. For planning, reserving 20–25% of Spark's 128 GB and assuming a mixed checkpoint at roughly 5.0–5.2 bits per parameter gives an estimated **150–165B parameter** single-node fit. That is below NVIDIA's “up to 200B” capacity ceiling because this estimate leaves useful room for the runtime and cache.

Two linked Sparks provide a speculative **295–330B parameter** planning band with the same reserve. NVIDIA has demonstrated Qwen‑235B in NVFP4 on two systems and markets an up-to-405B model ceiling, but neither statement guarantees your model, context, kernel or interactive speed.

- [NVIDIA's dual-Spark NVFP4 example →](https://developer.nvidia.com/blog/?p=111120)

- [Understand NVFP4 and Blackwell support →](https://developer.nvidia.com/blog/introducing-nvfp4-for-efficient-and-accurate-low-precision-inference/)

- [Compare Spark, Station and datacenter capacity →](https://isaiuseful.com/cloud-models.html.md#nvfp4)

DGX Spark-class OEM systems

## Eight GB10 listings. One workload test.

The active products share the compact GB10, 128 GB coherent-memory class, but not necessarily NVIDIA's DGX Spark product name, factory image, storage, regional price or support terms. HP advised directly that ZGX Nano is discontinued, so it remains here as a clearly labelled historical reference.

![Acer logo](https://cdn.simpleicons.org/acer/white)

### Veriton GN100

GB10 AI mini workstation.

- [Open Acer system page →](https://www.acer.com/gb-en/desktops-and-all-in-ones/veriton-workstations/veriton-gn100-ai-mini-workstation?utm_source=nvidia)

![ASUS logo](https://cdn.simpleicons.org/asus/white)

### ASUS Ascent GX10

GB10 desktop AI supercomputer.

- [Open ASUS system page →](https://www.asus.com/networking-iot-servers/desktop-ai-supercomputer/ultra-small-ai-supercomputers/asus-ascent-gx10/?utm_source=nvidia)

![Dell logo](https://cdn.simpleicons.org/dell/white)

### Dell Pro Max with GB10

GB10 micro workstation.

- [Open Dell system page →](https://www.dell.com/en-ie/shop/desktop-computers/dell-pro-max-with-gb10/spd/dell-pro-max-fcm1253-micro/xcto_fcm1253_emea#features_section)

![GIGABYTE logo](https://upload.wikimedia.org/wikipedia/commons/d/d5/Gigabyte_Technology_Logo.svg)

### GIGABYTE AI TOP ATOM

GB10 AI TOP system.

- [Open GIGABYTE system page →](https://www.gigabyte.com/AI-TOP-PC/GIGABYTE-AI-TOP-ATOM)

![HP logo](https://cdn.simpleicons.org/hp/white)

### HP ZGX Nano AI Station

GB10 nano AI station.

- [Open the HP reference page →](https://www.hp.com/us-en/workstations/zgx-nano-ai-station.html?utm_source=nvidia)

![Lenovo logo](https://upload.wikimedia.org/wikipedia/commons/0/05/Lenovo-Logo.svg)

### Lenovo ThinkStation PGX

GB10 AI development workstation.

- [Open Lenovo system page →](https://www.lenovo.com/ie/en/p/workstations/thinkstationp/lenovo-thinkstation-pgx-sff/len102s0023)

![MSI logo](https://cdn.simpleicons.org/msi/white)

### MSI EdgeXpert MS-C931

GB10 AI supercomputer.

- [Open MSI system page →](https://ipc.msi.com/product_detail/Industrial-Computer-Box-PC/AI-Supercomputer/EdgeXpert-MS-C931?utm_source=nvidia)

![PNY logo](https://upload.wikimedia.org/wikipedia/commons/4/4f/PNY_Technologies_logo.svg)

Offer checked 10 August 2026

### PNY DGX Spark

Authorized DGX Spark channel route. The current NVIDIA/PNY offer advertises an optional free 90-day NVIDIA AI Enterprise—DGX Spark evaluation after registration and entitlement; it is time-limited, offers community-driven support only, and is not a production-support entitlement.

- [Open PNY system page →](https://www.pny.com/dgx-spark)

- [NVIDIA AI Enterprise—DGX Spark 90-day evaluation →](https://docs.nvidia.com/dgx/dgx-spark/nvaie-quickstart.html)

- [NVIDIA Marketplace DGX Spark offer →](https://marketplace.nvidia.com/en-us/enterprise/personal-ai-supercomputers/dgx-spark/)

- [NVIDIA trial support caveat →](https://www.nvidia.com/content/dam/en-zz/Solutions/dgx-spark/workstation-print-gtc26-nvaie-spark-solution-overview-5004550-r7.pdf)

**Shortlist + quote check:** first compare the exact model, engine, quant, context and concurrency. Then verify the configured SSD, DGX OS or factory image, ConnectX accessories and two-node kit, thermals, power supply, regional availability, support lifecycle, warranty and VAT-inclusive price. Start with the [independent Spark benchmark shape](#spark-reviews) , then repeat the same harness on the OEM unit you can actually buy.

Try before you buy

## Rent the remote workload before buying a Spark or larger system.

Before committing four, five or six figures to a Spark or larger deployment, rent the candidate workload and prove the whole operator path. A rental is a test drive, not a guarantee of GPU availability, equivalent hardware, benchmark transfer or price.

**Exercise the real route.** Run the exact model, engine, quantization, context, concurrency and acceptance harness, including the remote-control and tunnel pattern you need; retain the container, settings, logs, latency, throughput, memory and task-quality results.

 **Referral disclosure:** this isaiuseful.com link is a Runpod referral link. As checked 10 August 2026, eligible new first-time users must sign up through it with Google SSO and load their first $10: European users receive $5 credit, while non-European users receive a weighted $5–$500 credit (Runpod says most are $10 or less). Terms can change. If eligible, isaiuseful.com receives its referral bonus and earns Runpod credits on actual usage for the first six months: 3% of Pod spend and 5% of Serverless spend. Using the link supports the site.

- [Rent a Runpod test environment through this referral link →](https://runpod.io?ref=l40ix174)

- [Read Runpod’s current referral terms →](https://docs.runpod.io/accounts-billing/referrals)

DGX Spark product views

## Hear NVIDIA's platform promise. Keep it separate from measured results.

The keynote explains the platform story, the PNY film shows one product implementation, and the assistant and [GraphRAG](https://isaiuseful.com/rag.html.md#graph) sessions demonstrate intended workflows. All four are vendor presentations—use the independent review block above for measured model performance.

- [Video: NVIDIA GTC Spring 2025 Keynote: Introducing NVIDIA DGX Spark](https://www.youtube.com/watch?v=6p4U1kSiegg)

Launch context · NVIDIA

### Introducing DGX Spark at GTC

The keynote segment sets out NVIDIA's original product positioning and target users. Compare those claims with current documentation and the independent throughput results on this page.

- [Video: NVIDIA DGX Spark | A Grace Blackwell AI Supercomputer on your desk](https://www.youtube.com/watch?v=kZRMshaNrSA)

PNY product view · NVIDIA

### PNY DGX Spark in NVIDIA's product film

The short film shows the PNY implementation and intended compact appliance experience. It does not establish model quality, sustained tokens per second, thermals or equivalence with other OEM systems.

- [Video: Build Your Own AI Assistant with Hugging Face on NVIDIA DGX Spark](https://www.youtube.com/watch?v=dMpLCGvE2A0)

Build tutorial · NVIDIA

### Turn the appliance into an assistant workflow.

This concise NVIDIA walkthrough shows a Hugging Face assistant build on DGX Spark. Use it for workflow ideas and product setup context—not as independent performance evidence.

- [Video: DGX Spark Live: Process Text for GraphRAG With Up to 120B LLM](https://www.youtube.com/watch?v=uQtzjAvJMlE)

GraphRAG demo · NVIDIA Developer

### Use the memory pool for a larger retrieval pipeline.

The NVIDIA Developer session demonstrates text processing for [GraphRAG](https://isaiuseful.com/rag.html.md#architecture) with an LLM of up to 120B parameters. It shows an intended capacity-led workflow, not a standardized throughput benchmark.

<a id="operators"></a>

Choose the operator

## Use the device already in your hands.

A phone is enough for chat, status and approvals. Desktop- or mobile-node permissions are optional additions for workflows that genuinely need to touch the operator device.

Windows 11

### Windows Hub + MXC preview

Best native OpenClaw diagnostics and Windows-node experience. Use the Insider path below when you want the current session-isolation work; use SSH, Web Chat or messaging when the Windows machine is only an operator.

- [Follow the Insider setup →](#windows-setup)

- [Windows Hub →](https://github.com/openclaw/openclaw-windows-node)

macOS

### Menu bar app in Remote mode

Point the signed macOS companion at `user@SPARK_IP` . Its default remote mode manages a strict-host-key SSH tunnel, health checks and Web Chat without starting a second gateway on the Mac.

- [Official remote-mode guide →](https://docs.openclaw.ai/platforms/mac/remote)

Linux

### Companion, CLI or browser

Use the Linux desktop companion when you want a tray and Canvas, or forward port 18789 and open the Control UI on localhost. The CLI is the simplest path on a minimal workstation.

- [Official Linux guide →](https://docs.openclaw.ai/platforms/linux)

**Phone or desktop companion**

Best local notifications, status and optional device-node capabilities.

**Web or CLI**

Universal path through an SSH tunnel; no desktop-node permissions required.

**Messaging**

Telegram, Discord, WhatsApp or another configured channel for everyday remote conversations.

**Hermes surfaces**

Use its TUI, dashboard or messaging gateway from any client while Hermes stays on Spark.

Remote access · private by default

### Use the narrowest path that fits the job.

Keep Spark services loopback-bound and authenticate every client. NVIDIA Sync is the managed route for Windows, macOS and Ubuntu; direct SSH is the universal fallback; remote desktop is for work that truly needs the full Linux interface.

**01 · Sync** — Managed SSH, application launches and tunnels.
**02 · SSH** — Direct terminal access and explicit port forwards.
**03 · Desktop** — Full remote interface on a private network only.

- [NVIDIA Sync user guide →](https://docs.nvidia.com/sync/latest/index.html)

- [DGX Spark access options →](https://docs.nvidia.com/dgx/dgx-spark/system-overview.html)

- [Set up remote access in step 2 →](#spark-remote-access)

<a id="windows-setup"></a>

Windows 11 · bleeding edge

## Insider is mandatory for the newest containment path.

OpenClaw Windows Hub can run on ordinary Windows builds. This guide targets the newer MXC session-isolation and agent-policy work Microsoft is still shipping through Windows Insider.

01

### Give the preview a recoverable Windows installation.

Use a secondary device or separate system image when possible. Enable BitLocker or device encryption, Secure Boot, Windows Hello and Defender; create a tested recovery drive and backup before enrolling. Run the companion as a standard user, not from a shared or daily administrator account.

02

### Join Windows Insider Experimental on a retail-aligned core.

Experimental is where Microsoft says actively developed features appear first. Stay on the 25H2 or 26H1 line offered for your hardware rather than the separate Future Platforms option. After updating, confirm the actual build with `winver` ; MXC currently documents build 26300.8553 as the minimum for its `isolation_session` backend.

- [Current channel definitions →](https://blogs.windows.com/windows-insider/2026/04/10/improving-your-windows-insider-experience/)

- [MXC build matrix →](https://github.com/microsoft/mxc)

03

### Verify the containment feature—not merely the OS label.

Install the current feature and platform updates, then check the OpenClaw release notes for MXC support and confirm that the requested backend is available. An Insider badge alone proves nothing. Microsoft currently describes OpenClaw's Windows node and gateway as an MXC integration, but the MXC repository also warns that its early-preview profiles are still overly permissive in known cases.

**Preview rule**

If MXC or the expected session backend is unavailable, stop. Do not silently fall back to unrestricted execution and call the result hardened.

04

### Use the canonical signed installer and verify it.

Download the x64 or ARM64 asset and checksum file from the project's latest release. Compare the SHA-256 value before opening it, retain SmartScreen and Defender checks, and reject a binary whose publisher or digest does not match.

```
Get-FileHash .\OpenClawTray-Setup-x64.exe -Algorithm SHA256
```

- [Latest release →](https://github.com/openclaw/openclaw-windows-node/releases/latest)

- [Official setup guide →](https://github.com/openclaw/openclaw-windows-node/blob/main/docs/SETUP.md)

05

### Connect to the existing Spark gateway.

Choose the remote or existing-gateway route in Windows Hub. Keep the gateway on Spark bound to loopback and let the Hub manage an SSH tunnel, or use a private Tailnet with authentication. The local WSL gateway is a fallback for people without an always-on host—not the default topology here.

06

### Pair, then allow only harmless Windows commands.

Approve the Windows node from the Spark gateway. Begin with notifications and device information/status. Leave command execution, screen capture, camera, location, speech and browser control disabled until a named workflow needs them and both the gateway policy and MXC policy deny everything else.

```
openclaw devices list
openclaw devices approve <device-id>
```

**Starter allowlist**

`system.notify · device.info · device.status`

OpenClaw requires exact command names. If `system.run` is later enabled, keep the separate Windows node execution policy default-deny as well.

07

### Test the deny path before startup automation.

Run ten harmless actions, inspect the activity and MXC diagnostics, disconnect the gateway, reject an unexpected pairing request, attempt access to a deliberately denied file and domain, and confirm that every disabled node capability fails. Re-run this after Windows, Hub, MXC, OpenShell or gateway updates.

Insider policy

### Required for this bleeding-edge path; not proof of safety.

Stable Windows can run OpenClaw and MXC's lighter process backend, but the current session-isolation backend and several Windows AI connector/workspace policies are Insider-era features. That makes Insider non-optional for the setup described here. It also makes the setup a lab: Microsoft explicitly says current MXC profiles have known over-permissive cases and should not yet be treated as complete security boundaries. Keep Windows permissions, OpenClaw allowlists, network isolation, backups and human approval in place.

- [OpenClaw + MXC announcement →](https://blogs.windows.com/windowsdeveloper/2026/06/02/windows-platform-security-for-ai-agents/)

- [MXC preview warning →](https://github.com/microsoft/mxc)

- [Insider policy surface →](https://learn.microsoft.com/en-us/windows/client-management/mdm/policy-csp-windowsai)

Quality-of-life layer

## Add convenience without hiding authority.

OpenClaw extensions execute inside a trust boundary. Install fewer, inspect them and pin versions where the package route supports it.

Native companions

### Hub, menu bar or Linux tray

Use the platform companion for health, chat and notifications without moving the gateway. Enable a desktop node only when the agent must act on that device; operator access and node authority are separate choices.

- [Compare platforms →](https://docs.openclaw.ai/platforms)

Remote access

### Managed SSH tunnel or Tailscale

Prefer the Hub's SSH-tunnel support or Tailscale Serve over firewalling the gateway port open. Keep the gateway bound to loopback and authenticate every client.

- [OpenClaw remote access →](https://docs.openclaw.ai/gateway/remote)

High-trust browser tool

### OpenClaw Chrome extension

Use only when the workflow must operate an already signed-in browser tab. Share an explicit OpenClaw tab group, keep the relay on loopback and assume the agent can act with that tab's account permissions.

- [Extension security model →](https://docs.openclaw.ai/tools/chrome-extension)

Skills + plugins

### ClawHub, workspace-local first

Search by the exact capability you need, inspect source and scan state, then install into one workspace before promoting it. A popular package is still executable code—not a permission boundary.

- [ClawHub quickstart →](https://docs.openclaw.ai/clawhub/quickstart)

- [Manage plugins →](https://docs.openclaw.ai/plugins/manage-plugins)

Execution isolation

### OpenShell + platform controls

Put tool execution behind NVIDIA OpenShell where its backend fits, then layer the host controls: MXC preview on Windows, Bubblewrap or LXC on Linux, and Seatbelt-backed containment on macOS. Test denied files and destinations on the actual host.

- [OpenShell →](https://github.com/NVIDIA/OpenShell)

- [MXC status →](https://github.com/microsoft/mxc)

Operational habit

### One capability ledger

Record the package, version, owner, data it can read, actions it can take, token scopes and removal test. Re-run the ten-action test after every gateway, node or plugin update.

- [Use the ten-run method →](https://isaiuseful.com/guides.html.md#ten-run-evaluation)

<a id="topology"></a>

Preferred topology

## Your devices operate. Spark remembers and computes.

The agent does not disappear when a laptop sleeps. Gateway state, model serving and scheduled work remain together on the always-on host.

> Visual: Remote operator and DGX Spark architecture

**Visual reading order:**
1. **01 · Any operator** **Windows · macOS · Linux** Companion app, browser, CLI, mobile or messaging; desktop-node powers remain optional
2. SSH tunnel 18789 + 8000
3. **02 · DGX Spark** **OpenClaw or Hermes** Loopback-bound, authenticated, always-on sessions, memory, channels and tool orchestration
4. **03 · DGX Spark** **vLLM + optional Qdrant** OpenAI-compatible inference and private retrieval services; no direct LAN exposure
5. **04 · DGX Spark** **Training workspace** Stopped while serving needs the memory; versioned datasets, adapters, evaluations and manifests

### Default placement: gateway on Spark

OpenClaw's own model is one gateway with many clients: the gateway owns sessions, authentication profiles, channels and state. Hermes is similarly comfortable on a remote Linux host with its dashboard and messaging gateway exposed only through the private access layer. A local laptop gateway is the fallback for someone without an always-on server, not the target architecture here.

<a id="hybrid-privacy"></a>

Local first · cloud by exception

## Scrub here. Escalate only the derivative.

When the laptop model cannot finish the hard part, keep the original and the identity map local. Send a stronger model only the smallest reviewed artifact that policy permits.

Vendor case study

### Bayer taught Phi the exceptions.

Microsoft says Bayer fine-tuned a small Phi model on proprietary crop-protection labels, regulatory rules and expert-authored Q&A. Labels can exceed 100 pages; Bayer reports early complex questions falling from days or weeks to under 30 seconds.

- [Read the Microsoft customer story →](https://www.microsoft.com/en/customers/story/25255-bayer-azure-phi)

Vendor case study

### Discovery Bank split one job into five.

Discovery fine-tuned five variants across Azure OpenAI 4o-mini and 4.1-mini for company language, SQL shape and workflow templates. It reports average response time dropping from five or six seconds to 1.5–2 seconds.

- [Read the Microsoft customer story →](https://www.microsoft.com/en/customers/story/26157-discovery-bank-azure-openai-in-foundry-models)

Laptop implication

### Teach the boundary before the model.

A downloaded model can flag candidate names, secrets, clauses and contextual identifiers without giving the source file to a model provider. It can also finish simple extraction or comparison locally. Escalation begins only when a harder model adds enough value to justify a reviewed data crossing.

- [Run the one-document test →](#offline-scrub)

> Visual: Local scrub and cloud escalation workflow

**Visual reading order:**
1. **01 · Local** **Classify** Route the source red, amber or green before any model sees it.
2. **02 · Local** **Detect twice** Use deterministic checks plus a local model for direct and contextual identifiers.
3. **03 · Local** **Replace + minimize** Create stable typed tokens; prefer a task brief over a redacted full copy.
4. **04 · Human gate** **Review the exact artifact** Approve recipient, purpose, region, retention and unresolved spans.
5. **05 · Route** **Finish or escalate** Use local output when it passes; otherwise send only an approved derivative.
6. **06 · Local** **Rejoin carefully** Inspect the answer and restore approved values without exposing the token map.

**The boundary that matters**

Redaction is not deletion and pseudonymization is not anonymity. The original, findings manifest and re-identification map stay local. Credentials are removed rather than tokenized, and the cloud service never receives the map. If context still identifies the person, client, transaction or project, the file remains red.

<a id="offline-scrub"></a>

The offline setup

### One document. One local model. No fallback.

During a connected maintenance window, install LM Studio and download one instruction-tuned local model, its runtime and any local embedding model the attachment workflow requires. Test with a synthetic file, close the app, move the authorized copy outside synced folders, then switch off Wi-Fi and unplug Ethernet before reopening it.

1. 01 **Load locally.** Choose only the downloaded model; start with an 8,192-token context and temperature 0.
2. 02 **Remove side doors.** Turn off tools, MCP, web search, plugins, cloud models and automatic fallback.
3. 03 **Keep the server closed.** Leave it off; if an integration needs it, bind only to `127.0.0.1` with authentication.
4. 04 **Return locations, not prose.** Ask first for exact span, page, category, reason, confidence and a proposed token.

**Local candidate-finding prompt**

`Work only with the attached local document. Do not use tools, web search, external sources or a remote model. Find DIRECT_IDENTIFIER, CREDENTIAL_OR_SECRET, REGULATED_DATA, COMMERCIAL_CONFIDENTIAL, QUASI_IDENTIFIER and UNCERTAIN spans. Return exact text, page or section, reason, confidence and a stable token such as [PERSON-001]. Do not rewrite yet. Do not infer missing identities.`

**Do not certify from document chat**

[RAG](https://isaiuseful.com/rag.html.md#model) may retrieve only selected passages. Long documents require page-by-page or overlapping-chunk inspection, deterministic secret and identifier checks, a fresh rescan of the derivative and human approval. Any unreadable or skipped content stops cloud routing.

- [LM Studio offline-operation documentation →](https://lmstudio.ai/docs/app/offline)

- [LM Studio network binding warning →](https://lmstudio.ai/docs/developer/core/server/serve-on-network)

Red · never ordinary cloud

### Keep the job local.

Credentials, identity evidence, health or KYC records, privileged advice, protected investigations, safety-critical material, raw client or board files, and anything with unclear authority or processor terms. Use approved private infrastructure or no model.

Amber · reviewed derivative

### Minimize, rescan, approve.

Internal contracts, narratives or reports that can lose direct identifiers and distinctive combinations without losing the task. Name the exact service, purpose, region, retention, logging, training and deletion terms before sending.

Green · approved content

### Still send less.

Published material, genuinely synthetic tests, checked templates or content explicitly approved for this external purpose. Inspect comments, metadata, tracked changes, hidden sheets, notes and embedded objects too.

Grok Build · July 2026

### The model obeyed. The product still moved the repository.

An independent wire analysis of Grok Build 0.2.93 recovered a never-read tracked file and Git history from a separate uploaded bundle after the prompt said not to open files. The researcher later reported that xAI disabled the path server-side. The test established transmission and storage in that setup—not training, employee access or universal behavior. Its durable lesson is that a prompt controls the task, not necessarily packaging, traces, sync or upload: “no training,” “no retention,” “no human review,” “no upload” and “local-only” are five different claims.

- [Inspect the original wire analysis →](https://gist.github.com/cereblab/dc9a40bc26120f4540e4e09b75ffb547)

Microsoft's lock-in test

### Exclusive is private. It is not automatically portable.

Microsoft says Azure-hosted direct-model inputs, outputs, embeddings and training data are not made available to model providers or used to improve foundation models without permission, and that a customer's fine-tuned model is exclusive to that customer. Those are useful privacy commitments. They do not by themselves make the resulting weights exportable or the workflow provider-independent.

- [Read the current Foundry data terms →](https://learn.microsoft.com/en-us/azure/foundry/responsible-ai/openai/data-privacy)

### Keep the learning outside the endpoint.

Store rules, source provenance, prompts, schemas, corrections, permission policy and an untouched evaluation set in exportable formats. Treat a fine-tune as a replaceable build artifact, not the only copy of what the company learned.

**The 30-day question**

Could we replace the model in 30 days using only the artifacts we can export today, then prove the replacement against the same holdout?

The guide + skill

## Take the boundary with you.

The walkthrough includes the full LM Studio pilot, red/amber/green router, verification gates, laptop-to-enterprise thresholds and portability test. The companion Codex skill prepares the derivative and review package, then stops before transmission.

- [Download the full guide](https://isaiuseful.com/downloads/sensitive-document-hybrid-guide.md)

- [Download the router skill](https://isaiuseful.com/downloads/scrub-sensitive-documents.zip)

- [Build local document search](https://isaiuseful.com/guides.html.md#private-documents)

<a id="spark-setup"></a>

DGX Spark build

## Build a service you can recover.

Use NVIDIA's Spark-specific playbooks. Generic CUDA, x86 container or desktop instructions can fail on ARM64/Blackwell even when the project itself supports NVIDIA GPUs.

01

### Baseline DGX OS.

Record the installed DGX OS release, driver, CUDA stack and firmware. Apply NVIDIA-recommended updates through DGX Dashboard, then verify health before adding services. Do not replace the OS with generic Ubuntu or Windows.

- [Update guide →](https://docs.nvidia.com/dgx/dgx-spark/os-and-component-update.html)

- [Release notes →](https://docs.nvidia.com/dgx/dgx-spark/release-notes.html)

- [CUDA libraries reference →](https://docs.nvidia.com/cuda-libraries/index.html)

<a id="spark-remote-access"></a>

02

### Set up private remote access.

After updating DGX OS, create a named non-root account, install an SSH key and choose the least-powerful route that covers the operator's work. Keep it on a trusted LAN or Tailnet, retain host firewall rules and never publish SSH, RDP or VNC ports directly to the internet.

**NVIDIA Sync**

Managed SSH, application launches and forwarding; optional Tailscale off-LAN. No jump or bastion hosts.
**Direct SSH**

Terminal administration and explicit forwards. Confirm the host fingerprint and keep strict verification.
**Remote desktop**

Full DGX OS interface only. Keep the chosen tool behind the LAN or Tailnet and fully updated.
- [Set up NVIDIA Sync →](https://docs.nvidia.com/sync/latest/index.html)

- [Review supported access options →](https://docs.nvidia.com/dgx/dgx-spark/system-overview.html)

- [OpenClaw remote access →](https://docs.openclaw.ai/gateway/remote)

03

### Serve one supported model with vLLM.

Use NVIDIA's DGX Spark vLLM recipe and one model from its current compatibility list. Pin the container or environment, set a context and concurrency budget, and run a fixed latency/quality test before adding model routing.

- [Spark vLLM recipe →](https://build.nvidia.com/spark/vllm/instructions)

- [Community Spark vLLM Docker setup →](https://github.com/eugr/spark-vllm-docker)

- [vLLM docs →](https://docs.vllm.ai/en/stable/)

04

### Add retrieval only when the workflow needs it.

Start with Qdrant only if filters, hybrid search, persistence or multiple collections justify a service. Store the original document and page metadata with every chunk; back up source documents and collection configuration, then test a restore.

- [Use the private-document recipe →](https://isaiuseful.com/guides.html.md#private-documents)

05

### Place OpenClaw or Hermes on Spark.

Install one primary agent through its supported Linux path, point it at vLLM's loopback OpenAI-compatible endpoint and keep its sessions, memory and channels on persistent storage. OpenClaw uses its gateway service; Hermes can expose its dashboard and messaging gateway. Run both only when you have intentionally separated their state, ports and permissions.

- [OpenClaw on Linux →](https://docs.openclaw.ai/platforms/linux)

- [Hermes Agent →](https://github.com/NousResearch/hermes-agent)

06

### Lock down tools and data services.

Bind the gateway, vLLM and Qdrant to loopback unless a private container network requires otherwise. Run high-authority agent tools through an OpenShell sandbox where supported, then test its filesystem and outbound-network denies. Expose only the application endpoint the chosen operator route needs.

- [OpenShell →](https://github.com/NVIDIA/OpenShell)

- [Secure Qdrant →](https://qdrant.tech/documentation/operations/security/)

07

### Separate serving from training.

Do not let a training job silently evict or starve the always-on model. Use explicit service and training modes, drain requests, stop vLLM when the recipe needs the memory, checkpoint to persistent storage and restore serving from a known configuration.

08

### Prove recovery.

Back up only what cannot be recreated: gateway configuration and keys, source data, dataset manifests, adapters, evaluation sets and service definitions. Rebuild one clean service from the manifest before calling the system production-ready.

<a id="spark-training"></a>

Fine-tuning on Spark

## Use the smallest recipe that answers the question.

NVIDIA publishes PyTorch and NeMo fine-tuning playbooks for Spark. Their example model sizes describe tested recipes, not universal capacity or speed guarantees.

| Question | First method | NVIDIA Spark example | Artifact to keep | Gate |
| --- | --- | --- | --- | --- |
| Does the data pipeline work? | Small LoRA run | 8B LoRA path | Adapter + run manifest | Loss is sane and sample outputs improve without obvious memorization. |
| Can a larger model learn the behavior? | LoRA or QLoRA | 70B LoRA / 70B QLoRA paths | Adapter, tokenizer config and holdout results | Beats the unchanged base model on the untouched test set. |
| Is full-weight training justified? | Full SFT only after adapter evidence | 3B full SFT path | Checkpoint + reproducible environment | Material gain over LoRA, retention tests pass and operating cost is acceptable. |

**Official starting points:** [PyTorch fine-tuning](https://build.nvidia.com/spark/pytorch-fine-tune/instructions) · [NeMo fine-tuning](https://build.nvidia.com/spark/nemo-fine-tune/instructions) · [dataset and evaluation checklist](https://isaiuseful.com/guides.html.md#finetuning) .

No Spark yet

## Keep the topology; shrink the host.

Run the gateway on the most reliable machine you already own: WSL 2 on Windows, a launchd service on macOS, or a systemd user service on Linux. Keep it loopback-bound, use a small local model or hosted endpoint and operate it from the same companion, browser and messaging surfaces. This proves the workflow; it does not reproduce Spark's unified memory or sustained service role.

- [Choose an OS path](https://docs.openclaw.ai/platforms)

- [WSL networking](https://learn.microsoft.com/en-us/windows/wsl/networking)

- [Compare hardware](https://isaiuseful.com/guides.html.md#hardware)

Quick answers

## Frequently asked questions about DGX Spark

Power, unified memory, networking, remote access and troubleshooting answers checked against current NVIDIA documentation.

### What is the expected DGX Spark power draw?

Budget for the included **240W** power supply. NVIDIA specifies a **140W TDP** for the GB10 SoC and reserves **100W** for ConnectX‑7, Wi‑Fi, storage, USB‑C and other system components. Its EU technical disclosure reports **233.2W maximum** and **38W idle** under the stated test method. The power shown by `nvidia-smi` is not whole-system power at the wall.

- [NVIDIA power requirements →](https://docs.nvidia.com/dgx/dgx-spark/hardware.html#power-requirements)

- [NVIDIA measured-power disclosure →](https://docs.nvidia.com/dgx/dgx-spark/compliance.html)

### Why does `nvidia-smi` report “Memory-Usage: Not Supported”?

This is expected. DGX Spark’s integrated GPU shares unified system memory instead of having dedicated framebuffer memory, so `nvidia-smi` does not provide the usual aggregate VRAM-usage field. Use `top` , `htop` , `free -h` or DGX Dashboard for system-memory monitoring. Open the dashboard locally at `http://localhost:11000` ; remote access needs NVIDIA Sync or an SSH tunnel.

- [NVIDIA known issue →](https://docs.nvidia.com/dgx/dgx-spark/known-issues.html#nvidia-smi-reports-memory-usage-not-supported)

- [DGX Dashboard access →](https://docs.nvidia.com/dgx/dgx-spark/dgx-dashboard.html)

### Why does an application run out of memory below the 128 GB capacity?

Unified-memory applications can report less allocatable memory than the system can reclaim, and some software does not yet account correctly for swap or cache. Start with `free -h` , the process allocations and swap use. Linux normally reclaims clean cache automatically. For a controlled diagnostic only—not routine memory management—sync writes and drop reclaimable cache with:

```
sudo sh -c 'sync; echo 3 > /proc/sys/vm/drop_caches'
```

Dropping caches can create significant I/O and CPU work; stop the affected workload first and remeasure before treating cache as the cause.

- [NVIDIA unified-memory guidance →](https://docs.nvidia.com/dgx/dgx-spark/known-issues.html#guidance-for-reporting-memory-resources-with-unified-memory-architecture)

- [Linux drop-caches warning →](https://docs.kernel.org/admin-guide/sysctl/vm.html#drop-caches)

### Why does NVIDIA Sync say “Host already exists” after I deleted a device?

A stale SSH `Host` alias may remain. Back up the file, remove only the exact stale `Host` block, then add the device again. Current Sync documentation uses `~/.ssh/config` on macOS and Ubuntu and `C:\Users\<username>\.ssh\config` on Windows. Older Sync builds may also have a managed file at the paths below.

```
Windows: C:\Users\<username>\AppData\Local\NVIDIA Corporation\Sync\config\ssh_config
macOS:   /Users/<username>/Library/Application Support/NVIDIA/Sync/config/ssh_config
Linux:   /home/<username>/.config/NVIDIA/Sync/config/ssh_config
```

- [Review NVIDIA Sync SSH aliases →](https://docs.nvidia.com/sync/latest/direct-connections.html#importing-an-existing-ssh-configuration)

### Is GPUDirect RDMA supported on DGX Spark?

No. DGX Spark’s unified-memory architecture does not support GPUDirect RDMA, `nvidia-peermem` , `dma-buf` or GDRCopy for CUDA device allocations. A portable application should query `CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_SUPPORTED` and `CU_DEVICE_ATTRIBUTE_DMA_BUF_SUPPORT` , then use a supported fallback. For Linux `ibverbs` applications, NVIDIA suggests `cudaHostAlloc` memory registered with `ibv_reg_mr` .

- [NVIDIA DGX Spark porting guidance →](https://docs.nvidia.com/dgx/dgx-spark-porting-guide/porting/cuda.html#gpudirect-rdma)

### How do I set up DGX Spark after moving it to another location?

Connect Ethernet first. Try the Spark’s `spark-hostname.local` address; if mDNS is unavailable, find its wired IP in the router. Connect with NVIDIA Sync or SSH, identify the Wi‑Fi device, join the new network without putting the password in shell history, and note the Wi‑Fi address before unplugging Ethernet:

```
nmcli device status
sudo nmcli --ask device wifi connect "<wifi-name>"
ip -4 address show
```

- [NVIDIA Sync direct connections →](https://docs.nvidia.com/sync/latest/direct-connections.html)

- [NVIDIA network setup guidance →](https://docs.nvidia.com/dgx/dgx-spark/first-boot.html)

### Why are CPU-bound NVCC processes slow?

CUDA sources built through CMake can miss OpenMP compiler support. Pass `-Xcompiler=-fopenmp` for CUDA compilation, rebuild and remeasure the CPU-bound section.

```
# CMakeLists.txt
target_compile_options(mytarget PRIVATE
  $<$<COMPILE_LANGUAGE:CUDA>:-Xcompiler=-fopenmp>
)

# Command line
nvcc -Xcompiler=-fopenmp ...
```

- [NVIDIA DGX Spark compiling guide →](https://docs.nvidia.com/dgx/dgx-spark-porting-guide/porting/compilation.html)

### Can I reset a lost BIOS or UEFI Administrator password?

There is no documented user reset for a lost firmware Administrator password. Contact NVIDIA hardware support for a Founders Edition system or the device manufacturer for an OEM model. Do not assume that an OS recovery or “Restore Defaults” in UEFI clears the security credential.

- [Choose the correct support route →](https://docs.nvidia.com/dgx/dgx-spark/support.html)

- [DGX Spark UEFI security settings →](https://docs.nvidia.com/dgx/dgx-spark-uefi/security-tab.html)

### Why is the ConnectX‑7 module missing from `lspci` ?

The January 2026 DGX OS release added ConnectX‑7 hot-plug power management. With it enabled, the adapter can stay powered down until a QSFP cable is inserted, saving up to 18W. Connecting the cable activates the adapter and increases system power and temperature. To keep ConnectX‑7 active without hot-plug power saving, remove the marker; recreate it to re-enable the feature:

```
sudo rm -f /etc/nvidia/cx7-hotplug-enabled
sudo touch /etc/nvidia/cx7-hotplug-enabled
```

- [NVIDIA January 2026 release note →](https://docs.nvidia.com/dgx/dgx-spark/release-notes.html#january-2026-release)

### How many DGX Spark systems can I cluster?

Current NVIDIA Sync supports **two or three systems** with direct 200 Gb/s QSFP cabling, or **up to four systems through a switch** . Use an approved cable and the NVIDIA Sync Cluster Assistant or the matching two-node, three-node or switched NVIDIA playbook; four devices are not supported as a direct-cabled topology.

- [ConnectX‑7 cabling and playbooks →](https://docs.nvidia.com/dgx/dgx-spark/spark-clustering.html)

- [NVIDIA Sync Cluster Assistant →](https://docs.nvidia.com/sync/latest/cluster-assistant.html)

The operating rule
Keep the agent on the server. Grant every client capability separately.

- [Choose your operator](#operators)

- [Build the Spark host](#spark-setup)

- [Choose the rest of the stack](https://isaiuseful.com/tools.html.md)