Nemotron Bolt E4B ou uma API hospedada? Escolha por contexto e tarefa

Se a sua tarefa cabe em 64.000 tokens e a sua GPU tem espaço para um modelo de ~4 GB, o Nemotron 3.5 Bolt E4B da NVIDIA pode executá-la na sua própria máquina. Se o trabalho precisa de uma janela maior, de uma resposta longa ou de 20.000 itens concluídos hoje, um modelo hospedado é o caminho mais curto. Abaixo há uma tabela que classifica a sua tarefa, e a aritmética por trás de cada linha.

O lado hospedado da comparação usa os três modelos da página de modelos do CheapTokens: DeepSeek-V4-Flash, GLM-5.3-Flash e MiniMax-M2.7.

O que a NVIDIA publicou, e o que deixou de fora#

A página de pesquisa da NVIDIA para o Nemotron 3.5 Bolt E4B (lançado em 23 de outubro de 2026, verificado em 5 de novembro) descreve um modelo construído sobre o Gemma 4 E4B e distribuído como checkpoint GGUF, quantização Q4_K_M, para llama.cpp. A NVIDIA diz que ele cabe em apenas 4 GB; a VRAM medida variou de 3,1 a 5,0 GB (na carga de teste da NVIDIA; com uma janela completa de 64K o uso de memória será maior, então verifique na sua própria placa). Os pesos estão no Hugging Face como nvidia/NVIDIA-Nemotron-3.5-Bolt-E4B-4GB e também chegam via Ollama, LM Studio e Unsloth.

Três fatos decidem a maioria das escolhas:

• Contexto: 64K tokens. A NVIDIA é explícita que a janela comporta tudo de uma vez: histórico de chat, instruções, definições de ferramentas e texto recuperado.
• Idiomas: 35, a partir de um modelo base pré-treinado em mais de 140.
• Velocidade: nas execuções CUDA do llama.cpp da NVIDIA (Q4_K_M, batch size 1) uma RTX 5070 com 12 GB usou 3,5 GB de VRAM e produziu 133,4 tokens por segundo. Um Jetson Orin Nano com 8 GB usou 4,2 GB e produziu 15,5 tokens por segundo. Ambos os números vêm da carga de teste da própria NVIDIA, então espere que os seus sejam diferentes.

A página também lista pontuações de uso de ferramentas (BFCL-v3 68,5, Tau2-Bench 55,1) e RULER em 64K de 87,0. Esses são os benchmarks do próprio desenvolvedor: eles dizem em que o modelo foi testado, não como ele se compara a um modelo hospedado, então este artigo não os coloca lado a lado.

Duas coisas que a página não informa: qual o tamanho máximo de uma única resposta e a licença. Leia ambas no model card do Hugging Face antes de construir qualquer coisa sobre ele.

Quão grande é 64K quando um agente começa a trabalhar?#

Pense na janela como uma mesa. O modelo só pode trabalhar com o que está sobre ela agora, e o histórico, as suas instruções, as definições de ferramentas e qualquer texto recuperado dividem a mesma mesa. Então, quanto de mesa são 64K?

Isso é um romance curto, então um chat, um e-mail ou uma tradução cabem com folga. O aperto vem dos agentes, porque cada passo despeja a saída da ferramenta na mesa e nada sai.

Agentes reais contornam isso cortando ou resumindo passos antigos. Funciona, mas é código extra para escrever e depurar. O lado do custo do mesmo loop está em Custo de sessão de agente: 50 passos no GLM, DeepSeek ou MiniMax.

Classifique a sua tarefa: local ou hospedado#

A mesma pergunta para um grande modelo aberto é respondida em Rodar DeepSeek localmente ou usar uma API. Para um modelo de 4 GB a resposta depende da tarefa, então classifique a tarefa primeiro e instale depois.

As colunas hospedadas vêm da lista de modelos do CheapTokens. O DeepSeek-V4-Flash tem contexto de 380K, até 32.768 tokens de saída por resposta e um preço a qualquer hora. O GLM-5.3-Flash tem contexto de 390K e até 8.192 tokens de saída. O MiniMax-M2.7 tem contexto de 180K, até 8.192 tokens de saída, e é adequado para trabalho agêntico e de programação via API.

Uma linha que a tabela não captura: se o texto nunca pode sair da sua máquina, isso decide a favor do local.

Trabalhos em lote: horas de GPU ou uma conta pequena#

Digamos que você etiquete 20.000 tickets de suporte. Cada um tem cerca de 600 tokens de entrada e um rótulo de 50 tokens de saída.

Totais: 20.000 × 600 = 12.000.000 tokens de entrada e 20.000 × 50 = 1.000.000 tokens de saída.

Gerar esses 1.000.000 de tokens nas velocidades medidas pela NVIDIA leva 1.000.000 ÷ 133,4 = 7.496 s (cerca de 2,1 horas) na RTX 5070 e 1.000.000 ÷ 15,5 = 64.516 s (cerca de 17,9 horas) no Jetson Orin Nano. Isso conta apenas a geração: ler os 12 milhões de tokens de entrada vem por cima, e também a eletricidade que a placa consome o tempo todo.

O lado hospedado do mesmo trabalho, aos preços atuais:

A tabela precifica o trabalho em cada modelo, com uma coluna OpenRouter. No total, com entrada e saída contadas juntas, cada um deles sai mais barato que o OpenRouter. No DeepSeek-V4-Flash, por exemplo, os 1.000.000 de tokens de saída são cobrados a $0.10 por 1M.

O seu trabalho provavelmente não são 20.000 tickets. Coloque os seus próprios números:

Agora você tem os dois lados nas mesmas unidades: horas de uma máquina que você possui contra dólares numa tabela ao vivo.

Documentos longos e respostas longas#

Pegue um pacote de contratos de 120.000 tokens. É maior que 64.000, então um Bolt E4B local precisaria do pacote cortado em pedaços, perguntado pedaço por pedaço, e as respostas costuradas. Numa janela de 380K ele entra como uma única requisição: com uma resposta de 2.000 tokens isso é $0.002 aos preços atuais. Qual modelo cabe num documento de 100K tokens percorre os limites de contexto e de saída modelo por modelo.

Respostas longas são o outro limite. O DeepSeek-V4-Flash pode escrever até 32.768 tokens numa resposta, e na mesma regra aproximada de ¾ de palavra por token (uma suposição) 32.768 × 0,75 = 24.576 palavras, o que é um relatório longo ou um arquivo de código inteiro. A página da NVIDIA não dá um máximo para o Bolt E4B, então antes de planejar uma saída de 10.000 tokens localmente, teste o que o seu runtime realmente retorna.

Roteie por tamanho: o mesmo código, dois destinos#

Você não precisa escolher um para sempre. Mantenha o modelo pequeno para os trabalhos pequenos e envie os grandes para um modelo hospedado. Se a sua ferramenta já fala com um endpoint compatível com OpenAI, a troca é uma base URL, uma chave e um id de modelo completo.

import os
from openai import OpenAI

hosted = OpenAI(
    base_url='https://api.cheaptokens.dev/v1',
    api_key=os.environ['CHEAPTOKENS_API_KEY'],
)

def too_big_for_local(text: str, limit: int = 60_000) -> bool:
    return len(text) // 4 > limit  # rough: about 4 characters per token in English

document = open('contract.txt', encoding='utf-8').read()
if too_big_for_local(document):
    resp = hosted.chat.completions.create(
        model='deepseek-ai/DeepSeek-V4-Flash-0731',
        messages=[{'role': 'user', 'content': 'List the termination clauses:\n\n' + document}],
        max_tokens=2000,
    )
    print(resp.choices[0].message.content)
    print(resp.usage)

O limite de 60.000 deixa espaço sob a janela de 64K para instruções e a resposta. Quando a chamada funciona você vê o texto da resposta, depois um objeto usage com prompt_tokens e completion_tokens: multiplique esses pelos preços na página de preços para obter quanto custou a requisição. Os passos da primeira requisição estão na documentação.

Comece pela linha da tabela que corresponde ao seu trabalho. Se ela disser local, baixe o GGUF e meça os seus próprios tokens por segundo antes de planejar com base nos números de qualquer outra pessoa.