A private coding agent on your own DGX Spark

Rent a whole NVIDIA DGX Spark, start the Qwen3 Coder 30B image, and point your coding agent at the OpenAI-compatible endpoint it serves. Nobody else uses the machine while you have it, and an hour costs $0.79 however many tokens your agent sends. On one of my Sparks this model generated 80.9 tokens per second for a single request (vLLM, 2 September 2026, raw log).

First top-up: pay $20, get $30 in credit. Billed per minute from prepaid credit. Terminate when you're done and billing ends. In the console, choose DGX Spark 1× and then the Qwen3 Coder 30B image.

What is on the machine

How fast it is, measured

I ran vllm bench serve against this model on one of my Sparks with nothing else on its GPU, on 2 September 2026 (vLLM 0.27.1, AWQ 4-bit). The full method and the 70B comparison run are on the benchmarks page.

Reading the prompt is fast too: an 8,192-token prompt went in at 5,705 tok/s, about 1.4 seconds before the first token. These are reference runs, not a promise for your prompts. A preset you deploy today may run a newer vLLM build, and long agent prompts take longer than short benchmark ones.

Which agents work with the preset as it is

Coding agents talk to a model in one of two ways, and it decides which setup you need. The preset starts vLLM with a context limit and a memory limit only (--max-model-len 32768 --gpu-memory-utilization 0.5). It does not pass --enable-auto-tool-choice, and vLLM refuses requests that ask for automatic tool calls unless the server was started with that flag and a tool-call parser.

• aider asks for edits as text and does not need tool calls, so it works with the preset unchanged. So does Continue's chat and edit mode.
• pi and OpenCode are built on tool calls, as is Continue's agent mode. For them, serve the model yourself with tool calling switched on. It takes about 15 minutes, and it works on any Spark, partner machines included.

Setup 1: the preset with aider

1. In the console, add credit, choose DGX Spark 1× and the Qwen3 Coder 30B image, and deploy. Billing starts once the instance passes its readiness check and shows running.
2. Create an API key with the inference scope in the console, and copy the HTTPS endpoint from the instance page.
3. On your laptop, check that the endpoint answers. The reply lists 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"

Then start aider in your repository. The openai/ prefix tells aider which API format to speak; no OpenAI service is involved.

export OPENAI_API_BASE=$SPARK
export OPENAI_API_KEY=$GPUWERK_API_KEY
aider --model openai/qwen3-coder-30b

Continue and Cline settings for the same endpoint are in coding agents against your own endpoint.

Setup 2: pi or OpenCode, with tool calls

Deploy the DGX OS image instead. Build llama.cpp for the GB10 and start Qwen3 Coder with --jinja, which applies the model's own chat template and returns its tool calls in the OpenAI format. These are the build steps from my llama.cpp guide, run in the browser terminal:

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

The server listens on 127.0.0.1 only, so reach it through an SSH tunnel from your laptop. That needs your own SSH key on the instance (two minutes). The llama.cpp maintainers report 61.1 tok/s for this model at Q8_0 on a DGX Spark (DGX Spark results, build 7941); I have not measured this path myself.

# 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) reads providers from opencode.json in your 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) reads ~/.pi/agent/models.json. Keep contextWindow at or below the server's -c, or pi overfills the context and the server rejects the 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 } }
      ]
    }
  }
}

Then pi --model qwen3-coder in your repository. The server keeps running when the agent exits; terminate the instance in the console when the day is over.

What an hour buys, next to an API bill

A Spark costs $0.79 an hour, billed per minute: $6.32 for an eight-hour day, $132.72 for 21 such days. What you get for that depends on how busy you keep it. By my arithmetic from the measured speeds above:

• One developer, one request at a time: 80.9 tok/s is at most about 291,000 generated tokens an hour, or $2.71 per million if the model never pauses. Real sessions pause while you read and tests run, so per token it costs more than that.
• A team sharing the endpoint: at 8 requests in flight, 8 × 35.2 tok/s is about 1 million generated tokens an hour, about $0.78 per million.
• Prompt tokens cost nothing extra. An agent sends your files and the whole conversation again on every turn, so on a per-token API most of the bill is input. Here the cost is time: prefill at 5,705 tok/s.

Put those next to your own API invoice. For one developer whose coding subscription never hits its limits, the subscription is probably cheaper. A Spark pays off when several people share one endpoint, when rate limits stop long agent runs, or when your code should not go to a model provider. My guide Can local AI replace Claude Code?, not yet published, goes through that comparison with prices and with newer open models.

Limits to know first

• It is a mid-size open model. Qwen3 Coder 30B is fast here because it reads about 3B parameters per token. It is not a frontier model, and I have not run a coding benchmark on it. Try it on your own tasks before you move work to it.
• 32,768 tokens per request on the preset. An agent that reads many files hits that. Setup 2 lets you choose the context length.
• The preset runs only on my own Sparks. When they are all rented, the console shows it. Partner Sparks run setup 2.
• The preset's endpoint passes through my gateway. It is public HTTPS, protected by your API key, and depending on the instance TLS ends at Cloudflare and my gateway before the request reaches the Spark (the API reports which, as https_termination). For code that should not pass through either, use the SSH tunnel of setup 2.
• The Spark is ARM64. Your agent runs on your laptop, so this rarely matters here, but anything you install on the Spark itself needs an aarch64 build.
• No SLA and no backups. Keep your code in git on your side; terminating deletes the workspace.

Where the Sparks are

My own Sparks are in a datacenter in Hradec Králové, Czech Republic. Partner Sparks are owned and hosted by partners at their own premises in the USA, Sweden, the Netherlands, Slovakia and Hong Kong. The console shows the country, and whether it is in the EEA, before you deploy. A partner has physical access to their machine, and a machine outside the EEA means your data leaves the EU/EEA, so pick the location that suits your code.

Price

$0.79 an hour for one Spark, billed per minute from prepaid credit. First top-up: pay $20, get $30 in credit. A stopped instance keeps its workspace and is billed at 75% of the hourly rate. Terminate it when you're done and billing ends; that deletes the workspace. Prices exclude VAT where applicable. Details are on the pricing page.

Who runs this

GPUwerk is new, so here is who you would be paying. I'm Samuel Seidel, the founder, and the company is PRINT IT! SE, registered in Prague. Since September 2026, 94 developers have started 374 instances (as of 9 November 2026). Service status is public at status.gpuwerk.com. Questions before you start? Write through the contact page; I answer myself.

FAQ