DGX Spark/Agentes de programación
Caso de uso · Agentes de programación

Un agente de programación privado en tu propio DGX Spark

Por Samuel Seidel · Actualizado el 10 de noviembre de 2026 · 8 min de lectura

Alquila un NVIDIA DGX Spark entero, arranca la imagen de Qwen3 Coder 30B y apunta tu agente de programación al endpoint compatible con OpenAI que sirve. Nadie más usa la máquina mientras la tienes, y una hora cuesta 0,79 $ envíe los tokens que envíe tu agente. En uno de mis Sparks, este modelo generó 80,9 tokens por segundo para una sola solicitud (vLLM, 2 de septiembre de 2026, log sin editar).

Primera recarga: paga 20 $ y recibe 30 $ de crédito. Facturado por minuto con crédito prepago. Termina la instancia cuando acabes y se deja de facturar. En la consola, elige DGX Spark 1× y después la imagen de Qwen3 Coder 30B.

Qué hay en la máquina

HardwareUn NVIDIA DGX Spark: GB10 Grace Blackwell, 128 GB de memoria unificada a 273 GB/s, 1 TB NVMe. La máquina entera es tuya mientras funciona.
ModeloQwen3-Coder-30B-A3B-Instruct en AWQ de 4 bits, un modelo mixture-of-experts que lee unos 3B de sus 30B parámetros por token. Los pesos ya están en la máquina.
ServidorvLLM, sirviendo el modelo como qwen3-coder-30b con un contexto de 32.768 tokens por solicitud
Endpointhttps://app-<instance-id>.gpuwerk.com/v1, compatible con OpenAI, protegido por una clave de API con el permiso de inferencia que creas en la consola
ShellUn terminal root en el navegador, sin clave SSH, o root por SSH con tu propia clave. Los archivos en /workspace sobreviven a los reinicios.
DóndeEsta imagen funciona en mis propios Sparks de Hradec Králové, República Checa. Los Sparks de socios ofrecen las imágenes DGX OS y Ubuntu, donde arrancas tú el modelo (consulta la segunda configuración más abajo).

Qué velocidad tiene, medida

Ejecuté vllm bench serve con este modelo en uno de mis Sparks, sin nada más en su GPU, el 2 de septiembre de 2026 (vLLM 0.27.1, AWQ de 4 bits). El método completo y la ejecución comparativa con 70B están en la página de benchmarks.

Solicitudes simultáneasGenerados por solicitudCómo se siente
180,9 tok/sUn desarrollador: las respuestas llegan más rápido de lo que las lees
835,2 tok/sUn equipo pequeño que comparte un endpoint
3218,4 tok/sMuchas ejecuciones de agentes en paralelo; cada una va más lenta

Leer el prompt también es rápido: un prompt de 8192 tokens entró a 5705 tok/s, unos 1,4 segundos antes del primer token. Son ejecuciones de referencia, no una promesa para tus prompts. Un preajuste que despliegues hoy puede usar una versión más nueva de vLLM, y los prompts largos de los agentes tardan más que los cortos de los benchmarks.

Qué agentes funcionan con el preajuste tal como está

Los agentes de programación se comunican con un modelo de una de dos maneras, y eso decide qué configuración necesitas. El preajuste arranca vLLM solo con un límite de contexto y un límite de memoria (--max-model-len 32768 --gpu-memory-utilization 0.5). No pasa --enable-auto-tool-choice, y vLLM rechaza las solicitudes que piden llamadas automáticas a herramientas salvo que el servidor se haya arrancado con ese flag y un parser de llamadas a herramientas.

Configuración 1: el preajuste con aider

  1. En la consola, añade crédito, elige DGX Spark 1× y la imagen de Qwen3 Coder 30B, y despliega. La facturación empieza en cuanto la instancia supera su comprobación de disponibilidad y muestra running.
  2. Crea en la consola una clave de API con el permiso de inferencia y copia el endpoint HTTPS de la página de la instancia.
  3. En tu portátil, comprueba que el endpoint responde. La respuesta incluye 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"

Después arranca aider en tu repositorio. El prefijo openai/ le indica a aider qué formato de API usar; no interviene ningún servicio de OpenAI.

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

Los ajustes de Continue y Cline para el mismo endpoint están en agentes de programación con tu propio endpoint.

Configuración 2: pi u OpenCode, con llamadas a herramientas

En su lugar, despliega la imagen DGX OS. Compila llama.cpp para el GB10 y arranca Qwen3 Coder con --jinja, que aplica la plantilla de chat propia del modelo y devuelve sus llamadas a herramientas en formato OpenAI. Estos son los pasos de compilación de mi guía de llama.cpp, ejecutados en el terminal del navegador:

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

El servidor solo escucha en 127.0.0.1, así que accede a él con un túnel SSH desde tu portátil. Para eso necesitas tu propia clave SSH en la instancia (dos minutos). Los mantenedores de llama.cpp publican 61,1 tok/s para este modelo en Q8_0 en un DGX Spark (resultados en DGX Spark, build 7941); no he medido esta vía yo mismo.

# 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) lee los proveedores de opencode.json en tu proyecto:

{
  "$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) lee ~/.pi/agent/models.json. Mantén contextWindow igual o por debajo del -c del servidor, o pi llenará de más el contexto y el servidor rechazará la solicitud.

{
  "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 } }
      ]
    }
  }
}

Después ejecuta pi --model qwen3-coder en tu repositorio. El servidor sigue funcionando cuando el agente termina; termina la instancia en la consola cuando acabe el día.

Lo que compra una hora, frente a una factura de API

Un Spark cuesta 0,79 $ la hora, facturado por minuto: 6,32 $ por una jornada de ocho horas, 132,72 $ por 21 jornadas así. Lo que obtienes a cambio depende de cuánto lo mantengas ocupado. Según mis cálculos a partir de las velocidades medidas arriba:

Compáralo con tu propia factura de API. Para un desarrollador cuya suscripción de programación nunca llega a sus límites, probablemente la suscripción sea más barata. Un Spark compensa cuando varias personas comparten un endpoint, cuando los límites de uso cortan ejecuciones largas de agentes o cuando tu código no debe ir a un proveedor de modelos.

Límites que conviene conocer antes

Dónde están los Sparks

Mis propios Sparks están en un centro de datos en Hradec Králové, República Checa. Los Sparks de socios son propiedad de socios que los alojan en sus propias instalaciones en EE. UU., Suecia, los Países Bajos, Eslovaquia y Hong Kong. La consola muestra el país, y si está en el EEE, antes de desplegar. Un socio tiene acceso físico a su máquina, y una máquina fuera del EEE significa que tus datos salen de la UE/EEE, así que elige la ubicación que convenga a tu código.

Precio

0,79 $ la hora por un Spark, facturado por minuto con crédito prepago. Primera recarga: paga 20 $ y recibe 30 $ de crédito. Una instancia detenida conserva su espacio de trabajo y se factura al 75% de la tarifa por hora. Termínala cuando acabes y se deja de facturar; eso borra el espacio de trabajo. Los precios no incluyen el IVA cuando corresponda. Los detalles están en la página de precios.

Quién está detrás

GPUwerk es nuevo, así que esto es a quién pagarías. Soy Samuel Seidel, el fundador, y la empresa es PRINT IT! SE, registrada en Praga. Desde septiembre de 2026, 94 desarrolladores han iniciado 374 instancias (a 9 de noviembre de 2026). El estado del servicio es público en status.gpuwerk.com. ¿Preguntas antes de empezar? Escribe a través de la página de contacto; respondo yo mismo.

Preguntas frecuentes

¿Puedo usar pi u OpenCode con el preajuste de Qwen3 Coder 30B?

Tal como está, no. Ambos envían llamadas a herramientas de OpenAI, y el preajuste arranca vLLM sin --enable-auto-tool-choice, así que vLLM rechaza esas solicitudes. En su lugar, despliega la imagen DGX OS y sirve el modelo con llama.cpp y --jinja, como en la configuración 2 de esta página. aider y el modo de chat de Continue funcionan con el preajuste sin cambios.

¿Qué velocidad tiene Qwen3 Coder 30B en un DGX Spark?

En uno de mis Sparks generó 80,9 tokens por segundo para una sola solicitud, y 35,2 por solicitud con 8 solicitudes a la vez (vLLM 0.27.1, AWQ de 4 bits, 2 de septiembre de 2026). El log sin editar está enlazado en esta página. Los mantenedores de llama.cpp publican 61,1 tok/s en Q8_0.

¿Cuánto cuesta un agente de programación en un Spark?

0,79 $ la hora, facturado por minuto con crédito prepago, envíe lo que envíe el agente: 6,32 $ por una jornada de ocho horas. Primera recarga: paga 20 $ y recibe 30 $ de crédito. Una instancia detenida se factura al 75% de la tarifa por hora; terminarla pone fin a la facturación y borra el espacio de trabajo. Los precios no incluyen el IVA cuando corresponda.

¿Mi código va a un proveedor de modelos?

No interviene ninguna API de modelos de terceros: el modelo funciona en el Spark que alquilas, que nadie más usa mientras lo tienes. Las solicitudes al endpoint HTTPS del preajuste pasan por la pasarela de GPUwerk y, según la instancia, por Cloudflare. Un túnel SSH a un servidor que arranques tú evita ambas cosas. En un Spark de socio, el socio tiene acceso físico a la máquina.

Primera recarga: paga 20 $ y recibe 30 $ de crédito

Apunta tu agente a un Spark solo para ti.

Un DGX Spark dedicado con Qwen3 Coder 30B listo para servir, 0,79 $/h facturado por minuto. Termina la instancia cuando acabes y se deja de facturar.

Desplegar ya