Nemotron Bolt E4B o un'API hosted? Scegli in base al contesto e al task

Se il tuo task rientra in 64.000 token e la tua GPU ha spazio per un modello da ~4 GB, Nemotron 3.5 Bolt E4B di NVIDIA può eseguirlo sulla tua macchina. Se il lavoro richiede una finestra più grande, una risposta lunga o 20.000 elementi completati oggi, un modello hosted è la strada più breve. Qui sotto c'è una tabella che classifica il tuo task, e l'aritmetica dietro ogni riga.

Il lato hosted del confronto usa i tre modelli nella pagina dei modelli CheapTokens: DeepSeek-V4-Flash, GLM-5.3-Flash e MiniMax-M2.7.

Cosa ha pubblicato NVIDIA, e cosa ha omesso#

La pagina di ricerca di NVIDIA per Nemotron 3.5 Bolt E4B (rilasciato il 23 ottobre 2026, verificato il 5 novembre) descrive un modello basato su Gemma 4 E4B e distribuito come checkpoint GGUF, quantizzazione Q4_K_M, per llama.cpp. NVIDIA afferma che occupa appena 4 GB; la VRAM misurata andava da 3,1 a 5,0 GB (sul workload di test di NVIDIA; con una finestra completa da 64K l'uso di memoria sarà maggiore, quindi verifica sulla tua scheda). I pesi sono su Hugging Face come nvidia/NVIDIA-Nemotron-3.5-Bolt-E4B-4GB e arrivano anche tramite Ollama, LM Studio e Unsloth.

Tre fatti decidono la maggior parte delle scelte:

• Contesto: 64K token. NVIDIA è esplicita sul fatto che la finestra contiene tutto in una volta: cronologia chat, istruzioni, definizioni degli strumenti e testo recuperato.
• Lingue: 35, da un modello base pre-addestrato su più di 140.
• Velocità: nelle esecuzioni llama.cpp CUDA di NVIDIA (Q4_K_M, batch size 1) una RTX 5070 con 12 GB ha usato 3,5 GB di VRAM e prodotto 133,4 token al secondo. Una Jetson Orin Nano con 8 GB ha usato 4,2 GB e prodotto 15,5 token al secondo. Entrambi i numeri provengono dal workload di test di NVIDIA, quindi aspettati valori diversi.

La pagina elenca anche i punteggi di tool-use (BFCL-v3 68,5, Tau2-Bench 55,1) e RULER a 64K di 87,0. Sono i benchmark dello sviluppatore stesso: dicono su cosa è stato testato il modello, non come si confronta con un modello hosted, quindi questo articolo non li mette a confronto.

Due cose che la pagina non dichiara: quanto può essere lunga una singola risposta e la licenza. Leggi entrambe sulla model card di Hugging Face prima di costruirci qualcosa sopra.

Quanto è grande 64K quando un agente inizia a lavorare?#

Pensa alla finestra come a una scrivania. Il modello può lavorare solo con ciò che è appoggiato lì in questo momento, e la cronologia, le tue istruzioni, le definizioni degli strumenti e qualsiasi testo recuperato condividono la stessa scrivania. Quindi quanta scrivania sono 64K?

È un romanzo breve, quindi una chat, un'email o una traduzione ci stanno comodamente. La stretta arriva dagli agenti, perché ogni passo deposita l'output degli strumenti sulla scrivania e nulla se ne va.

Gli agenti reali aggirano il problema tagliando o riassumendo i passi vecchi. Funziona, ma è codice extra da scrivere e da debuggare. Il lato costo dello stesso ciclo è in Costo di una sessione agente: 50 passi su GLM, DeepSeek o MiniMax.

Classifica il tuo task: locale o hosted#

La stessa domanda per un grande modello aperto è affrontata in Eseguire DeepSeek in locale o usare un'API. Per un modello da 4 GB la risposta dipende dal task, quindi classifica prima il task e installa dopo.

Le colonne hosted provengono dalla lista dei modelli CheapTokens. DeepSeek-V4-Flash ha un contesto di 380K, fino a 32.768 token di output per risposta e un prezzo unico a qualsiasi ora. GLM-5.3-Flash ha un contesto di 390K e fino a 8.192 token di output. MiniMax-M2.7 ha un contesto di 180K, fino a 8.192 token di output, e si adatta a lavoro agentico e di coding tramite API.

Una riga che la tabella non può catturare: se il testo non deve mai lasciare la tua macchina, questo decide a favore del locale.

Lavori in blocco: ore di GPU o una piccola fattura#

Diciamo che tu etichetti 20.000 ticket di supporto. Ognuno è circa 600 token in input e 50 token di etichetta in output.

Totali: 20.000 × 600 = 12.000.000 token di input e 20.000 × 50 = 1.000.000 token di output.

Generare quei 1.000.000 di token alle velocità misurate da NVIDIA richiede 1.000.000 ÷ 133,4 = 7.496 s (circa 2,1 ore) sulla RTX 5070 e 1.000.000 ÷ 15,5 = 64.516 s (circa 17,9 ore) sulla Jetson Orin Nano. Questo conta solo la generazione: leggere i 12 milioni di token di input si aggiunge, e così l'elettricità che la scheda consuma per tutto il tempo.

Il lato hosted dello stesso lavoro, ai prezzi attuali:

La tabella prezza il lavoro su ciascun modello, con una colonna OpenRouter. In totale, contando input e output insieme, ognuno di essi risulta più economico di OpenRouter. Su DeepSeek-V4-Flash, per esempio, i 1.000.000 di token di output sono fatturati a $0.10 per 1M.

Il tuo lavoro probabilmente non è di 20.000 ticket. Inserisci i tuoi numeri:

Ora hai entrambi i lati nelle stesse unità: ore di una macchina che possiedi contro dollari su una tabella live.

Documenti lunghi e risposte lunghe#

Prendi un fascicolo contrattuale di 120.000 token. È più grande di 64.000, quindi un Bolt E4B locale dovrebbe tagliare il fascicolo in pezzi, interrogarlo pezzo per pezzo e ricucire le risposte. Su una finestra da 380K entra come una singola richiesta: con una risposta da 2.000 token sono $0.002 ai prezzi attuali. Quale modello si adatta a un documento da 100K token esamina i limiti di contesto e di output modello per modello.

Le risposte lunghe sono l'altro limite. DeepSeek-V4-Flash può scrivere fino a 32.768 token in una risposta, e con la stessa regola approssimativa di ¾ di parola per token (un'assunzione) 32.768 × 0,75 = 24.576 parole, che è un report lungo o un intero file di codice. La pagina di NVIDIA non dà un massimo per Bolt E4B, quindi prima di pianificare un output di 10.000 token in locale, testa cosa restituisce davvero il tuo runtime.

Instrada per dimensione: lo stesso codice, due destinazioni#

Non devi scegliere una volta per sempre. Tieni il modello piccolo per i lavori piccoli e manda quelli grandi a un modello hosted. Se il tuo strumento parla già con un endpoint compatibile OpenAI, il cambio è un base URL, una chiave e un model id 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)

Il limite di 60.000 lascia spazio sotto la finestra da 64K per istruzioni e risposta. Quando la chiamata funziona vedi il testo della risposta, poi un oggetto usage con prompt_tokens e completion_tokens: moltiplicali per i prezzi sulla pagina dei prezzi per ottenere quanto è costata la richiesta. I passi per la prima richiesta sono nella documentazione.

Inizia dalla riga della tabella che corrisponde al tuo lavoro. Se dice locale, scarica il GGUF e misura i tuoi token al secondo prima di pianificare sui numeri di qualcun altro.