Un agente de programación privado en tu propio DGX Spark
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
| Hardware | Un 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. |
|---|---|
| Modelo | Qwen3-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. |
| Servidor | vLLM, sirviendo el modelo como qwen3-coder-30b con un contexto de 32.768 tokens por solicitud |
| Endpoint | https://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 |
| Shell | Un 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ónde | Esta 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áneas | Generados por solicitud | Cómo se siente |
|---|---|---|
| 1 | 80,9 tok/s | Un desarrollador: las respuestas llegan más rápido de lo que las lees |
| 8 | 35,2 tok/s | Un equipo pequeño que comparte un endpoint |
| 32 | 18,4 tok/s | Muchas 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.
- aider pide las ediciones como texto y no necesita llamadas a herramientas, así que funciona con el preajuste sin cambios. Lo mismo ocurre con el modo de chat y edición de Continue.
- pi y OpenCode se basan en llamadas a herramientas, igual que el modo agente de Continue. Para ellos, sirve tú mismo el modelo con las llamadas a herramientas activadas. Lleva unos 15 minutos y funciona en cualquier Spark, incluidas las máquinas de socios.
Configuración 1: el preajuste con aider
- 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.
- 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.
- 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:
- Un desarrollador, una solicitud cada vez: 80,9 tok/s son como máximo unos 291.000 tokens generados por hora, o 2,71 $ por millón si el modelo nunca para. Las sesiones reales tienen pausas mientras lees y se ejecutan los tests, así que por token cuesta más.
- Un equipo que comparte el endpoint: con 8 solicitudes en curso, 8 × 35,2 tok/s son aproximadamente 1 millón de tokens generados por hora, unos 0,78 $ por millón.
- Los tokens del prompt no cuestan nada extra. Un agente envía tus archivos y toda la conversación de nuevo en cada turno, así que en una API de pago por token la mayor parte de la factura es la entrada. Aquí el coste es tiempo: prefill a 5705 tok/s.
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
- Es un modelo abierto de tamaño medio. Qwen3 Coder 30B va rápido aquí porque lee unos 3B parámetros por token. No es un modelo de vanguardia, y no he ejecutado ningún benchmark de programación con él. Pruébalo en tus propias tareas antes de pasarle trabajo.
- 32.768 tokens por solicitud en el preajuste. Un agente que lee muchos archivos llega a ese límite. La configuración 2 te permite elegir la longitud de contexto.
- El preajuste solo funciona en mis propios Sparks. Cuando están todos alquilados, la consola lo indica. Los Sparks de socios usan la configuración 2.
- El endpoint del preajuste pasa por mi pasarela. Es HTTPS público, protegido por tu clave de API, y según la instancia el TLS termina en Cloudflare y en mi pasarela antes de que la solicitud llegue al Spark (la API indica cuál, como
https_termination). Para código que no deba pasar por ninguno de los dos, usa el túnel SSH de la configuración 2. - El Spark es ARM64. Tu agente se ejecuta en tu portátil, así que aquí rara vez importa, pero todo lo que instales en el propio Spark necesita una compilación aarch64.
- Sin SLA ni copias de seguridad. Guarda tu código en git por tu lado; terminar borra el espacio de trabajo.
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.