Um agente de programação privado no seu próprio DGX Spark
Alugue um NVIDIA DGX Spark inteiro, inicie a imagem Qwen3 Coder 30B e aponte o seu agente de programação para o endpoint compatível com OpenAI que ela serve. Mais ninguém usa a máquina enquanto a tiver, e uma hora custa $ 0,79 independentemente de quantos tokens o seu agente envie. Num dos meus Sparks, este modelo gerou 80,9 tokens por segundo para um único pedido (vLLM, 2 de setembro de 2026, registo bruto).
Primeiro carregamento: pague $ 20 e receba $ 30 em crédito. Faturado ao minuto a partir de crédito pré-pago. Termine a instância quando acabar e a faturação para. Na consola, escolha DGX Spark 1× e depois a imagem Qwen3 Coder 30B.
O que está na máquina
| Hardware | Um NVIDIA DGX Spark: GB10 Grace Blackwell, 128 GB de memória unificada a 273 GB/s, 1 TB NVMe. A máquina inteira é sua enquanto está em execução. |
|---|---|
| Modelo | Qwen3-Coder-30B-A3B-Instruct em AWQ 4 bits, um modelo mixture-of-experts que lê cerca de 3B dos seus 30B parâmetros por token. Os pesos já estão na máquina. |
| Servidor | vLLM, a servir o modelo como qwen3-coder-30b com um contexto de 32 768 tokens por pedido |
| Endpoint | https://app-<instance-id>.gpuwerk.com/v1, compatível com OpenAI, protegido por uma chave de API com o âmbito de inferência que cria na consola |
| Shell | Um terminal root no navegador, sem chave SSH, ou root por SSH com a sua própria chave. Os ficheiros em /workspace sobrevivem a reinícios. |
| Onde | Esta imagem corre nos meus próprios Sparks em Hradec Králové, República Checa. Os Partner Sparks oferecem as imagens DGX OS e Ubuntu, onde inicia o modelo por si próprio (veja a segunda configuração abaixo). |
Quão rápido é, medido
Executei vllm bench serve com este modelo num dos meus Sparks sem mais nada na GPU, a 2 de setembro de 2026 (vLLM 0.27.1, AWQ 4 bits). O método completo e a execução de comparação com o 70B estão na página de benchmarks.
| Pedidos em simultâneo | Gerado por pedido | Como se sente na prática |
|---|---|---|
| 1 | 80,9 tok/s | Um programador: as respostas aparecem mais depressa do que as lê |
| 8 | 35,2 tok/s | Uma pequena equipa a partilhar um endpoint |
| 32 | 18,4 tok/s | Muitas execuções de agentes em paralelo; cada uma fica mais lenta |
Ler o prompt também é rápido: um prompt de 8192 tokens entrou a 5705 tok/s, cerca de 1,4 segundos antes do primeiro token. São execuções de referência, não uma promessa para os seus prompts. Uma predefinição que implemente hoje pode usar uma build mais recente do vLLM, e os prompts longos de agentes demoram mais do que os prompts curtos de benchmarks.
Que agentes funcionam com a predefinição tal como está
Os agentes de programação comunicam com um modelo de uma de duas formas, e isso decide a configuração de que precisa. A predefinição inicia o vLLM apenas com um limite de contexto e um limite de memória (--max-model-len 32768 --gpu-memory-utilization 0.5). Não passa --enable-auto-tool-choice, e o vLLM recusa pedidos que pedem chamadas de ferramentas automáticas, a não ser que o servidor tenha sido iniciado com essa flag e um parser de chamadas de ferramentas.
- O aider pede edições como texto e não precisa de chamadas de ferramentas, por isso funciona com a predefinição sem alterações. O mesmo acontece com o modo de chat e edição do Continue.
- O pi e o OpenCode assentam em chamadas de ferramentas, tal como o modo agente do Continue. Para eles, sirva o modelo por si próprio, com as chamadas de ferramentas ativadas. Demora cerca de 15 minutos e funciona em qualquer Spark, incluindo máquinas de parceiros.
Configuração 1: a predefinição com o aider
- Na consola, adicione crédito, escolha DGX Spark 1× e a imagem Qwen3 Coder 30B, e implemente. A faturação começa quando a instância passa a verificação de prontidão e mostra running.
- Crie uma chave de API com o âmbito de inferência na consola e copie o endpoint HTTPS da página da instância.
- No seu portátil, verifique se o endpoint responde. A resposta lista
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"
Depois inicie o aider no seu repositório. O prefixo openai/ diz ao aider que formato de API usar; nenhum serviço da OpenAI está envolvido.
export OPENAI_API_BASE=$SPARK export OPENAI_API_KEY=$GPUWERK_API_KEY aider --model openai/qwen3-coder-30b
As definições do Continue e do Cline para o mesmo endpoint estão em agentes de programação com o seu próprio endpoint.
Configuração 2: pi ou OpenCode, com chamadas de ferramentas
Em vez disso, implemente a imagem DGX OS. Compile o llama.cpp para o GB10 e inicie o Qwen3 Coder com --jinja, que aplica o template de chat do próprio modelo e devolve as chamadas de ferramentas no formato OpenAI. Estes são os passos de compilação do meu guia do llama.cpp, executados no terminal do 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
O servidor só escuta em 127.0.0.1, por isso aceda-lhe através de um túnel SSH a partir do seu portátil. Para isso precisa da sua própria chave SSH na instância (dois minutos). Os responsáveis pelo llama.cpp reportam 61,1 tok/s para este modelo em Q8_0 num DGX Spark (resultados no DGX Spark, build 7941); não medi este caminho por mim.
# on your laptop, leave it running ssh -N -L 30000:127.0.0.1:30000 root@<instance-name>.gpuwerk.com
O OpenCode (npm install -g opencode-ai) lê os fornecedores a partir de opencode.json no seu projeto:
{
"$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" } }
}
}
}
O pi (npm install -g --ignore-scripts @earendil-works/pi-coding-agent) lê ~/.pi/agent/models.json. Mantenha contextWindow igual ou inferior ao -c do servidor, ou o pi enche demasiado o contexto e o servidor rejeita o pedido.
{
"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 } }
]
}
}
}
Depois pi --model qwen3-coder no seu repositório. O servidor continua a correr quando o agente termina; termine a instância na consola quando o dia acabar.
O que uma hora compra, ao lado de uma fatura de API
Um Spark custa $ 0,79 por hora, faturado ao minuto: $ 6,32 por um dia de oito horas, $ 132,72 por 21 desses dias. O que obtém por isso depende de quanto o mantém ocupado. Pelas minhas contas, a partir das velocidades medidas acima:
- Um programador, um pedido de cada vez: 80,9 tok/s são no máximo cerca de 291 000 tokens gerados por hora, ou $ 2,71 por milhão se o modelo nunca parar. As sessões reais têm pausas enquanto lê e os testes correm, por isso, por token, custa mais do que isso.
- Uma equipa a partilhar o endpoint: com 8 pedidos em curso, 8 × 35,2 tok/s dá cerca de 1 milhão de tokens gerados por hora, cerca de $ 0,78 por milhão.
- Os tokens de prompt não custam nada a mais. Um agente volta a enviar os seus ficheiros e toda a conversa em cada interação, por isso, numa API paga ao token, a maior parte da fatura é entrada. Aqui o custo é tempo: prefill a 5705 tok/s.
Compare isso com a sua própria fatura de API. Para um programador cuja subscrição de programação nunca atinge os limites, a subscrição é provavelmente mais barata. Um Spark compensa quando várias pessoas partilham um endpoint, quando os limites de pedidos travam execuções longas de agentes, ou quando o seu código não deve ir para um fornecedor de modelos.
Limitações a conhecer primeiro
- É um modelo aberto de tamanho médio. O Qwen3 Coder 30B é rápido aqui porque lê cerca de 3B parâmetros por token. Não é um modelo de fronteira, e não executei nenhum benchmark de programação com ele. Experimente-o nas suas próprias tarefas antes de lhe passar trabalho.
- 32 768 tokens por pedido na predefinição. Um agente que lê muitos ficheiros atinge esse limite. A configuração 2 permite escolher o comprimento do contexto.
- A predefinição só corre nos meus próprios Sparks. Quando estão todos alugados, a consola mostra-o. Os Partner Sparks usam a configuração 2.
- O endpoint da predefinição passa pelo meu gateway. É HTTPS público, protegido pela sua chave de API, e consoante a instância o TLS termina na Cloudflare e no meu gateway antes de o pedido chegar ao Spark (a API indica qual, como
https_termination). Para código que não deve passar por nenhum dos dois, use o túnel SSH da configuração 2. - O Spark é ARM64. O seu agente corre no seu portátil, por isso isto raramente importa aqui, mas tudo o que instalar no próprio Spark precisa de uma build aarch64.
- Sem SLA e sem cópias de segurança. Mantenha o seu código em git do seu lado; terminar apaga o espaço de trabalho.
Onde estão os Sparks
Os meus próprios Sparks estão num datacenter em Hradec Králové, República Checa. Os Partner Sparks pertencem a parceiros e estão alojados nas suas próprias instalações nos EUA, Suécia, Países Baixos, Eslováquia e Hong Kong. A consola mostra o país, e se está no EEE, antes de implementar. Um parceiro tem acesso físico à sua máquina, e uma máquina fora do EEE significa que os seus dados saem da UE/EEE, por isso escolha a localização adequada ao seu código.
Preço
$ 0,79 por hora por um Spark, faturado ao minuto a partir de crédito pré-pago. Primeiro carregamento: pague $ 20 e receba $ 30 em crédito. Uma instância parada mantém o espaço de trabalho e é faturada a 75% da tarifa horária. Termine-a quando acabar e a faturação para; isso apaga o espaço de trabalho. Preços sem IVA, quando aplicável. Os detalhes estão na página de preços.
Quem gere isto
A GPUwerk é nova, por isso eis a quem estaria a pagar. Sou o Samuel Seidel, o fundador, e a empresa é a PRINT IT! SE, registada em Praga. Desde setembro de 2026, 94 programadores iniciaram 374 instâncias (dados de 9 de novembro de 2026). O estado do serviço é público em status.gpuwerk.com. Tem dúvidas antes de começar? Escreva através da página de contacto; sou eu quem responde.
FAQ
Posso usar o pi ou o OpenCode com a predefinição Qwen3 Coder 30B?
Não tal como está. Ambos enviam chamadas de ferramentas OpenAI, e a predefinição inicia o vLLM sem --enable-auto-tool-choice, por isso o vLLM recusa esses pedidos. Em vez disso, implemente a imagem DGX OS e sirva o modelo com o llama.cpp e --jinja, como na configuração 2 desta página. O aider e o modo de chat do Continue funcionam com a predefinição sem alterações.
Quão rápido é o Qwen3 Coder 30B num DGX Spark?
Num dos meus Sparks gerou 80,9 tokens por segundo para um único pedido, e 35,2 por pedido com 8 pedidos em simultâneo (vLLM 0.27.1, AWQ 4 bits, 2 de setembro de 2026). O registo bruto está ligado nesta página. Os responsáveis pelo llama.cpp reportam 61,1 tok/s em Q8_0.
Quanto custa um agente de programação num Spark?
$ 0,79 por hora, faturado ao minuto a partir de crédito pré-pago, seja o que for que o agente envie: $ 6,32 por um dia de oito horas. Primeiro carregamento: pague $ 20 e receba $ 30 em crédito. Uma instância parada é faturada a 75% da tarifa horária; terminá-la acaba com a faturação e apaga o espaço de trabalho. Preços sem IVA, quando aplicável.
O meu código vai para um fornecedor de modelos?
Não há nenhuma API de modelos de terceiros envolvida: o modelo corre no Spark que aluga, que mais ninguém usa enquanto o tiver. Os pedidos ao endpoint HTTPS da predefinição passam pelo gateway da GPUwerk e, consoante a instância, pela Cloudflare. Um túnel SSH para um servidor que inicie por si próprio evita ambos. Num Spark de parceiro, o parceiro tem acesso físico à máquina.