Een eigen coding-agent op je eigen DGX Spark
Huur een hele NVIDIA DGX Spark, start de Qwen3 Coder 30B-image en richt je coding-agent op het OpenAI-compatibele endpoint dat die serveert. Niemand anders gebruikt de machine zolang jij hem hebt, en een uur kost $ 0,79, hoeveel tokens je agent ook verstuurt. Op een van mijn Sparks genereerde dit model 80,9 tokens per seconde voor één request (vLLM, 2 september 2026, ruwe log).
Eerste opwaardering: betaal $ 20, krijg $ 30 tegoed. Per minuut afgeschreven van prepaid tegoed. Beëindig de instance als je klaar bent; daarmee stopt de facturering. Kies in de console DGX Spark 1× en daarna de Qwen3 Coder 30B-image.
Wat er op de machine staat
| Hardware | Eén NVIDIA DGX Spark: GB10 Grace Blackwell, 128 GB unified memory op 273 GB/s, 1 TB NVMe. De hele machine is van jou zolang hij draait. |
|---|---|
| Model | Qwen3-Coder-30B-A3B-Instruct in AWQ 4-bit, een mixture-of-experts-model dat per token ongeveer 3B van zijn 30B parameters leest. De gewichten staan al op de machine. |
| Server | vLLM, dat het model serveert als qwen3-coder-30b met een context van 32.768 tokens per request |
| Endpoint | https://app-<instance-id>.gpuwerk.com/v1, OpenAI-compatibel, beveiligd met een API-sleutel met de scope inference die je in de console aanmaakt |
| Shell | Een root-terminal in de browser, zonder SSH-sleutel, of root via SSH met je eigen sleutel. Bestanden onder /workspace blijven bewaard bij herstarts. |
| Waar | Deze image draait op mijn eigen Sparks in Hradec Králové, Tsjechië. Partner-Sparks bieden de DGX OS- en Ubuntu-images, waarop je het model zelf start (zie de tweede setup hieronder). |
Hoe snel het is, gemeten
Ik heb op 2 september 2026 vllm bench serve tegen dit model gedraaid op een van mijn Sparks, zonder iets anders op de GPU (vLLM 0.27.1, AWQ 4-bit). De volledige methode en de vergelijkingsrun met 70B staan op de benchmarkpagina.
| Requests tegelijk | Gegenereerd per request | Hoe het aanvoelt |
|---|---|---|
| 1 | 80,9 tok/s | Eén developer: antwoorden streamen sneller dan je ze leest |
| 8 | 35,2 tok/s | Een klein team dat één endpoint deelt |
| 32 | 18,4 tok/s | Veel parallelle agentruns; elke run wordt trager |
Ook het lezen van de prompt is snel: een prompt van 8.192 tokens ging erin op 5.705 tok/s, ongeveer 1,4 seconden vóór het eerste token. Dit zijn referentieruns, geen belofte voor jouw prompts. Een preset die je vandaag deployt, kan een nieuwere vLLM-build draaien, en lange agentprompts duren langer dan korte benchmarkprompts.
Welke agents werken met de preset zoals hij is
Coding-agents praten op een van twee manieren met een model, en dat bepaalt welke opzet je nodig hebt. De preset start vLLM met alleen een contextlimiet en een geheugenlimiet (--max-model-len 32768 --gpu-memory-utilization 0.5). Hij geeft --enable-auto-tool-choice niet mee, en vLLM weigert requests die om automatische tool calls vragen, tenzij de server met die flag en een tool-call-parser is gestart.
- aider vraagt om bewerkingen als tekst en heeft geen tool calls nodig, dus het werkt ongewijzigd met de preset. Dat geldt ook voor de chat- en bewerkmodus van Continue.
- pi en OpenCode zijn gebouwd op tool calls, net als de agentmodus van Continue. Serveer het model voor die tools zelf met tool calling aan. Dat kost ongeveer 15 minuten, en het werkt op elke Spark, ook op partnermachines.
Setup 1: de preset met aider
- Voeg in de console tegoed toe, kies DGX Spark 1× en de Qwen3 Coder 30B-image, en deploy. De facturering begint zodra de instance zijn gereedheidscontrole doorstaat en running toont.
- Maak in de console een API-sleutel met de scope inference aan, en kopieer het HTTPS-endpoint van de pagina van de instance.
- Controleer op je laptop dat het endpoint antwoordt. Het antwoord vermeldt
qwen3-coder-30b.
export SPARK=https://app-<instance-id>.gpuwerk.com/v1 export GPUWERK_API_KEY=sy_key_... # inference scope curl -s $SPARK/models -H "Authorization: Bearer $GPUWERK_API_KEY"
Start daarna aider in je repository. Het voorvoegsel openai/ vertelt aider welk API-formaat het moet spreken; er komt geen dienst van OpenAI aan te pas.
export OPENAI_API_BASE=$SPARK export OPENAI_API_KEY=$GPUWERK_API_KEY aider --model openai/qwen3-coder-30b
Instellingen voor Continue en Cline voor hetzelfde endpoint staan in coding-agents met je eigen endpoint.
Setup 2: pi of OpenCode, met tool calls
Deploy in plaats daarvan de DGX OS-image. Bouw llama.cpp voor de GB10 en start Qwen3 Coder met --jinja, dat het eigen chattemplate van het model toepast en de tool calls in het OpenAI-formaat teruggeeft. Dit zijn de buildstappen uit mijn llama.cpp-handleiding, uitgevoerd in de browserterminal:
apt-get update && apt-get install -y build-essential cmake libcurl4-openssl-dev git clone https://github.com/ggml-org/llama.cpp /workspace/llama.cpp cd /workspace/llama.cpp cmake -B build -DGGML_CUDA=ON -DGGML_CURL=ON -DCMAKE_CUDA_ARCHITECTURES=121a-real cmake --build build --config Release --target llama-server -j # about 32 GB of weights on the first start ./build/bin/llama-server -hf unsloth/Qwen3-Coder-30B-A3B-Instruct-GGUF:Q8_0 \ --alias qwen3-coder --jinja -c 65536 \ --host 127.0.0.1 --port 30000
De server luistert alleen op 127.0.0.1, dus je bereikt hem via een SSH-tunnel vanaf je laptop. Daarvoor heb je je eigen SSH-sleutel op de instance nodig (twee minuten). De maintainers van llama.cpp melden 61,1 tok/s voor dit model bij Q8_0 op een DGX Spark (resultaten op de DGX Spark, build 7941); ik heb dit pad zelf niet gemeten.
# on your laptop, leave it running ssh -N -L 30000:127.0.0.1:30000 root@<instance-name>.gpuwerk.com
OpenCode (npm install -g opencode-ai) leest providers uit opencode.json in je project:
{
"$schema": "https://opencode.ai/config.json",
"provider": {
"spark": {
"npm": "@ai-sdk/openai-compatible",
"name": "DGX Spark",
"options": { "baseURL": "http://127.0.0.1:30000/v1" },
"models": { "qwen3-coder": { "name": "Qwen3 Coder 30B on a Spark" } }
}
}
}
pi (npm install -g --ignore-scripts @earendil-works/pi-coding-agent) leest ~/.pi/agent/models.json. Houd contextWindow op of onder de -c van de server, anders vult pi de context te vol en weigert de server het request.
{
"providers": {
"spark": {
"baseUrl": "http://127.0.0.1:30000/v1",
"api": "openai-completions",
"apiKey": "unused",
"compat": { "supportsDeveloperRole": false, "maxTokensField": "max_tokens" },
"models": [
{ "id": "qwen3-coder", "name": "Qwen3 Coder 30B (Spark)",
"reasoning": false, "contextWindow": 65536, "maxTokens": 8192,
"cost": { "input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0 } }
]
}
}
}
Daarna pi --model qwen3-coder in je repository. De server blijft draaien als de agent stopt; beëindig de instance in de console als de dag voorbij is.
Wat een uur oplevert, naast een API-rekening
Een Spark kost $ 0,79 per uur, per minuut gefactureerd: $ 6,32 voor een werkdag van acht uur, $ 132,72 voor 21 van zulke dagen. Wat je daarvoor krijgt, hangt af van hoe druk je hem bezet houdt. Volgens mijn berekening op basis van de gemeten snelheden hierboven:
- Eén developer, één request tegelijk: 80,9 tok/s is hoogstens ongeveer 291.000 gegenereerde tokens per uur, of $ 2,71 per miljoen als het model nooit pauzeert. Echte sessies pauzeren terwijl jij leest en tests draaien, dus per token kost het meer dan dat.
- Een team dat het endpoint deelt: bij 8 lopende requests is 8 × 35,2 tok/s ongeveer 1 miljoen gegenereerde tokens per uur, ongeveer $ 0,78 per miljoen.
- Prompttokens kosten niets extra. Een agent stuurt je bestanden en het hele gesprek bij elke beurt opnieuw, dus bij een API met betaling per token is het grootste deel van de rekening invoer. Hier is de prijs tijd: prefill op 5.705 tok/s.
Leg die naast je eigen API-factuur. Voor één developer van wie het programmeerabonnement nooit de limieten bereikt, is het abonnement waarschijnlijk goedkoper. Een Spark loont als meerdere mensen één endpoint delen, als rate limits lange agentruns stoppen, of als je code niet naar een modelaanbieder mag.
Grenzen die je eerst moet kennen
- Het is een middelgroot open model. Qwen3 Coder 30B is hier snel omdat het ongeveer 3B parameters per token leest. Het is geen frontier-model, en ik heb er geen programmeerbenchmark op gedraaid. Probeer het op je eigen taken voordat je er werk naartoe verplaatst.
- 32.768 tokens per request bij de preset. Een agent die veel bestanden leest, loopt daartegenaan. Bij setup 2 kies je zelf de contextlengte.
- De preset draait alleen op mijn eigen Sparks. Als die allemaal verhuurd zijn, toont de console dat. Partner-Sparks draaien setup 2.
- Het endpoint van de preset gaat via mijn gateway. Het is openbare HTTPS, beveiligd met je API-sleutel, en afhankelijk van de instance eindigt TLS bij Cloudflare en mijn gateway voordat het request de Spark bereikt (de API meldt welke, als
https_termination). Voor code die via geen van beide mag gaan, gebruik je de SSH-tunnel van setup 2. - De Spark is ARM64. Je agent draait op je laptop, dus dit doet er hier zelden toe, maar alles wat je op de Spark zelf installeert, heeft een aarch64-build nodig.
- Geen SLA en geen back-ups. Houd je code aan jouw kant in git; beëindigen verwijdert de workspace.
Waar de Sparks staan
Mijn eigen Sparks staan in een datacenter in Hradec Králové, Tsjechië. Partner-Sparks zijn eigendom van partners en worden door hen gehost op hun eigen locatie in de VS, Zweden, Nederland, Slowakije en Hongkong. De console toont vóór het deployen het land en of het in de EER ligt. Een partner heeft fysieke toegang tot zijn machine, en een machine buiten de EER betekent dat je data de EU/EER verlaat, dus kies de locatie die bij je code past.
Prijs
$ 0,79 per uur voor één Spark, per minuut afgeschreven van prepaid tegoed. Eerste opwaardering: betaal $ 20, krijg $ 30 tegoed. Een gestopte instance behoudt zijn workspace en wordt gefactureerd tegen 75% van het uurtarief. Beëindig hem als je klaar bent; daarmee stopt de facturering en wordt de workspace verwijderd. Prijzen zijn exclusief btw waar van toepassing. Details staan op de prijspagina.
Wie dit runt
GPUwerk is nieuw, dus hier is wie je zou betalen. Ik ben Samuel Seidel, de oprichter, en het bedrijf is PRINT IT! SE, geregistreerd in Praag. Sinds september 2026 hebben 94 developers 374 instances gestart (stand op 9 november 2026). De status van de dienst is openbaar op status.gpuwerk.com. Vragen voordat je begint? Schrijf via de contactpagina; ik antwoord zelf.
FAQ
Kan ik pi of OpenCode gebruiken met de Qwen3 Coder 30B-preset?
Niet zoals het nu is. Beide sturen OpenAI-tool calls, en de preset start vLLM zonder --enable-auto-tool-choice, dus vLLM weigert die requests. Deploy in plaats daarvan de DGX OS-image en serveer het model met llama.cpp en --jinja, zoals in setup 2 op deze pagina. aider en de chatmodus van Continue werken ongewijzigd met de preset.
Hoe snel is Qwen3 Coder 30B op een DGX Spark?
Op een van mijn Sparks genereerde het 80,9 tokens per seconde voor één request, en 35,2 per request met 8 requests tegelijk (vLLM 0.27.1, AWQ 4-bit, 2 september 2026). De ruwe log staat op deze pagina gelinkt. De maintainers van llama.cpp melden 61,1 tok/s bij Q8_0.
Wat kost een coding-agent op een Spark?
$ 0,79 per uur, per minuut afgeschreven van prepaid tegoed, wat de agent ook verstuurt: $ 6,32 voor een werkdag van acht uur. Eerste opwaardering: betaal $ 20, krijg $ 30 tegoed. Een gestopte instance wordt gefactureerd tegen 75% van het uurtarief; beëindigen stopt de facturering en verwijdert de workspace. Prijzen zijn exclusief btw waar van toepassing.
Gaat mijn code naar een modelaanbieder?
Er komt geen model-API van derden aan te pas: het model draait op de Spark die je huurt, die niemand anders gebruikt zolang jij hem hebt. Requests naar het HTTPS-endpoint van de preset gaan via de gateway van GPUwerk en, afhankelijk van de instance, via Cloudflare. Een SSH-tunnel naar een server die je zelf start, vermijdt beide. Op een partner-Spark heeft de partner fysieke toegang tot de machine.