¿Nemotron Bolt E4B o una API alojada? Elige por contexto y tarea

Si tu tarea cabe en 64.000 tokens y tu GPU tiene espacio para un modelo de ~4 GB, el Nemotron 3.5 Bolt E4B de NVIDIA puede ejecutarla en tu propia máquina. Si el trabajo necesita una ventana más grande, una respuesta larga o 20.000 elementos terminados hoy, un modelo alojado es el camino más corto. Abajo hay una tabla que clasifica tu tarea, y la aritmética detrás de cada fila.

El lado alojado de la comparación usa los tres modelos de la página de modelos de CheapTokens: DeepSeek-V4-Flash, GLM-5.3-Flash y MiniMax-M2.7.

Lo que NVIDIA publicó y lo que omitió#

La página de investigación de NVIDIA para Nemotron 3.5 Bolt E4B (publicado el 23 de octubre de 2026, consultado el 5 de noviembre) describe un modelo construido sobre Gemma 4 E4B y distribuido como checkpoint GGUF, cuantización Q4_K_M, para llama.cpp. NVIDIA dice que cabe en tan solo 4 GB; la VRAM que midió iba de 3,1 a 5,0 GB (en la carga de prueba de NVIDIA; con una ventana completa de 64K el uso de memoria será mayor, así que compruébalo en tu propia tarjeta). Los pesos están en Hugging Face como nvidia/NVIDIA-Nemotron-3.5-Bolt-E4B-4GB y también llegan a través de Ollama, LM Studio y Unsloth.

Tres hechos deciden la mayoría de las elecciones:

• Contexto: 64K tokens. NVIDIA es explícito en que la ventana contiene todo a la vez: historial de chat, instrucciones, definiciones de herramientas y texto recuperado.
• Idiomas: 35, de un modelo base preentrenado en más de 140.
• Velocidad: en las ejecuciones de llama.cpp CUDA de NVIDIA (Q4_K_M, tamaño de lote 1) una RTX 5070 con 12 GB usó 3,5 GB de VRAM y produjo 133,4 tokens por segundo. Una Jetson Orin Nano con 8 GB usó 4,2 GB y produjo 15,5 tokens por segundo. Ambas cifras provienen de la propia carga de prueba de NVIDIA, así que espera que las tuyas difieran.

La página también lista puntuaciones de uso de herramientas (BFCL-v3 68,5, Tau2-Bench 55,1) y RULER a 64K de 87,0. Son los benchmarks del propio desarrollador: dicen con qué se probó el modelo, no cómo se compara con un modelo alojado, así que este artículo no los pone frente a frente.

Dos cosas que la página no indica: cuánto puede medir una sola respuesta y la licencia. Lee ambas en la model card de Hugging Face antes de construir nada sobre él.

¿Cuánto es 64K cuando un agente empieza a trabajar?#

Piensa en la ventana como un escritorio. El modelo solo puede trabajar con lo que está sobre él en este momento, y el historial, tus instrucciones, las definiciones de herramientas y cualquier texto recuperado comparten el mismo escritorio. Entonces, ¿cuánto escritorio son 64K?

Eso es una novela corta, así que un chat, un correo o una traducción caben cómodamente. El aprieto viene de los agentes, porque cada paso deja la salida de su herramienta sobre el escritorio y nada se va.

Los agentes reales sortean esto recortando o resumiendo pasos antiguos. Funciona, pero es código extra que escribir y depurar. El lado del coste del mismo bucle está en Coste de sesión de agente: 50 pasos en GLM, DeepSeek o MiniMax.

Clasifica tu tarea: local o alojado#

La misma pregunta para un modelo abierto grande se responde en Ejecutar DeepSeek en local o usar una API. Para un modelo de 4 GB la respuesta depende de la tarea, así que clasifica la tarea primero e instala después.

Las columnas de alojado provienen de la lista de modelos de CheapTokens. DeepSeek-V4-Flash tiene un contexto de 380K, hasta 32.768 tokens de salida por respuesta y un precio a cualquier hora. GLM-5.3-Flash tiene un contexto de 390K y hasta 8.192 tokens de salida. MiniMax-M2.7 tiene un contexto de 180K, hasta 8.192 tokens de salida, y encaja en trabajo agéntico y de programación a través de una API.

Una fila que la tabla no puede capturar: si el texto no debe salir nunca de tu máquina, eso lo decide a favor de local.

Trabajos masivos: horas de GPU o una factura pequeña#

Supón que etiquetas 20.000 tickets de soporte. Cada uno es de unos 600 tokens de entrada y una etiqueta de 50 tokens de salida.

Totales: 20.000 × 600 = 12.000.000 tokens de entrada y 20.000 × 50 = 1.000.000 tokens de salida.

Generar esos 1.000.000 de tokens a las velocidades medidas por NVIDIA lleva 1.000.000 ÷ 133,4 = 7.496 s (unas 2,1 horas) en la RTX 5070 y 1.000.000 ÷ 15,5 = 64.516 s (unas 17,9 horas) en la Jetson Orin Nano. Eso cuenta solo la generación: leer los 12 millones de tokens de entrada va aparte, y también la electricidad que la tarjeta consume todo el tiempo.

El lado alojado del mismo trabajo, a los precios actuales:

La tabla pone precio al trabajo en cada modelo, con una columna de OpenRouter. En total, contando entrada y salida juntas, cada uno de ellos sale más barato que OpenRouter. En DeepSeek-V4-Flash, por ejemplo, los 1.000.000 de tokens de salida se facturan a $0.10 por 1M.

Tu trabajo probablemente no sean 20.000 tickets. Pon tus propios números:

Ahora tienes ambos lados en las mismas unidades: horas de una máquina que posees frente a dólares en una tabla en vivo.

Documentos largos y respuestas largas#

Toma un paquete de contratos de 120.000 tokens. Es más grande que 64.000, así que un Bolt E4B local necesitaría el paquete cortado en trozos, preguntado trozo a trozo, y las respuestas unidas. En una ventana de 380K entra como una sola petición: con una respuesta de 2.000 tokens eso es $0.002 a los precios actuales. Qué modelo encaja en un documento de 100K tokens repasa los límites de contexto y salida modelo por modelo.

Las respuestas largas son el otro límite. DeepSeek-V4-Flash puede escribir hasta 32.768 tokens en una respuesta, y con la misma regla aproximada de ¾ de palabra por token (una suposición) 32.768 × 0,75 = 24.576 palabras, que es un informe largo o un archivo de código completo. La página de NVIDIA no da un máximo para Bolt E4B, así que antes de planear una salida de 10.000 tokens en local, prueba lo que tu runtime devuelve realmente.

Enruta por tamaño: el mismo código, dos destinos#

No tienes que elegir uno para siempre. Mantén el modelo pequeño para los trabajos pequeños y envía los grandes a un modelo alojado. Si tu herramienta ya habla con un endpoint compatible con OpenAI, el cambio es una URL base, una clave y un 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)

El límite de 60.000 deja margen bajo la ventana de 64K para las instrucciones y la respuesta. Cuando la llamada funciona ves el texto de la respuesta, luego un objeto usage con prompt_tokens y completion_tokens: multiplícalos por los precios de la página de precios para obtener lo que costó la petición. Los pasos de la primera petición están en la documentación.

Empieza por la fila de la tabla que coincida con tu trabajo. Si dice local, descarga el GGUF y mide tus propios tokens por segundo antes de planear con las cifras de cualquier otro.