Una chiamata a uno strumento ha richiesto 5,4 secondi. L'elaborazione del contesto necessario ha richiesto 7 minuti e 29 secondi.
Questa è stata la ripartizione in un'esecuzione strumentata del mio flusso di lavoro con agente locale. In un'esecuzione di un flusso di lavoro per verificare lo stato dei log sul mio server operativo, la sonda remota ha impiegato 5,428 secondi ed è terminata correttamente. Prima che la sonda potesse essere eseguita, lo stesso turno ha impiegato circa 7 minuti e 29 secondi per elaborare 66.170 token di input di contesto necessari. La parte veloce è stata lo strumento. La parte lenta è stata tutto ciò di cui il flusso di lavoro aveva bisogno prima che si potesse chiamare lo strumento.
Un agente cloud utile comprende più della risposta del modello. Attorno al modello c'è un flusso di lavoro: le competenze che indicano come svolgere un'attività, le connessioni MCP che espongono strumenti e servizi, le autorizzazioni che determinano a cosa si può accedere e su cosa si può intervenire, e il browser o la shell che esegue effettivamente il lavoro. Riprodurlo localmente significa riprodurre l'intero sistema, non puntare una finestra di chat a un'API di modelli.
Il flusso di lavoro è il prodotto, non l'endpoint
Vale la pena definire in modo semplice due elementi di questo vocabolario, perché la maggior parte della difficoltà è qui, non nel modello.
MCP, il Model Context Protocol, è il modo in cui un host per agenti espone strumenti e servizi a un modello. Ogni server MCP pubblica un catalogo di strumenti che il modello può chiamare e dietro questi strumenti si trovano le capacità reali: file, repository, browser, database e servizi remoti. L'host media ogni chiamata e, allo stesso tempo, è il punto in cui vengono applicate le autorizzazioni.
Le competenze sono istruzioni per il flusso di lavoro. Una competenza spiega come svolgere un determinato tipo di attività: quali strumenti usare, cosa raccogliere, in quale ordine e cosa deve contenere il risultato. Fornisce al modello una procedura da seguire, anche se il modello può comunque saltare dei passaggi e deve essere sottoposto a verifica.
Il sistema che conta è quindi l'insieme di host, modello, runtime, autorizzazioni e connessioni agli strumenti. L'host è l'applicazione con cui interagisco, nel mio caso Kilo Desktop, Kilo in VS Code e AnythingLLM. Il runtime serve il modello. Il modello esegue il ragionamento. Le competenze e le connessioni MCP determinano quali attività siano possibili. Un endpoint di inferenza, da solo, non configura tali competenze, connessioni o autorizzazioni per l'host dell'agente.
Che cosa sto usando
La mia infrastruttura di serving è un server llama.cpp compatibile con OpenAI (CUDA, build b11852) che esegue Qwen 3 Coder Next (Q4_K_M). I metadati del modello indicano 79,67 miliardi di parametri totali su 48 livelli; i pesi quantizzati occupano circa 48 GB. La macchina è dotata di una RTX 4090 con 24 GB di VRAM, un Ryzen 9 3900X con 12 core fisici e 24 thread e 128 GB di RAM di sistema. La capacità di contesto configurata è di 131.072 token, con una risposta massima di 8.192 token.
Qwen 3 Coder Next è un modello a miscela di esperti. Ciò significa che memorizza molti insiemi separati di pesi degli esperti e ne attiva solo un sottoinsieme per ogni token. I pesi memorizzati sono quindi voluminosi, anche se il calcolo per token ne coinvolge solo una frazione. Per questa decisione sull'hardware conta la dimensione dei pesi memorizzati: circa 48 GB anche dopo la quantizzazione.
Perché il modello non entra nella GPU
Circa 48 GB di pesi quantizzati contro 24 GB di VRAM sono un problema aritmetico, non di ottimizzazione. La quantizzazione Q4_K_M riduce lo spazio necessario per i pesi, con un compromesso tra precisione e qualità, ma non fa entrare questo modello in 24 GB, soprattutto perché anche il contesto e i buffer del runtime richiedono VRAM.
La soluzione è suddividere il posizionamento. I pesi degli esperti dei primi 32 dei 48 livelli sono assegnati al lato CPU/RAM di sistema; gli altri tensori rimangono sulla GPU, con una cache GPU limitata per gli esperti. Per essere precisi, non si tratta di 32 livelli completi eseguiti soltanto sulla CPU: in un modello a miscela di esperti quei livelli contengono pesi degli esperti, e sono proprio i pesi degli esperti di quei primi 32 livelli a risiedere nella RAM di sistema.
A ciò si aggiungono una cache GPU per gli esperti da 1.024 MiB, una cache KV Q8 e Flash Attention. I pesi del modello costituiscono solo una parte dell'uso della memoria GPU. Il runtime necessita anche di buffer di lavoro e dello stato di attenzione, spesso chiamato cache KV. Q8 controlla la precisione di archiviazione dei tensori della cache supportati. La cache per gli esperti da 1 GiB e Flash Attention comportano ulteriori compromessi tra memoria e calcolo; in questa esecuzione non è stato possibile isolare il contributo di ciascuno di questi elementi.
Perché ciascun elemento è presente
Sono scelte pratiche per una macchina e un carico di lavoro, non ottimi dimostrati da benchmark.
| Scelta | Motivazione | Precisazione |
|---|---|---|
| Runtime llama.cpp | Offre controlli espliciti per la quantizzazione e il posizionamento dei livelli e serve un'API compatibile con OpenAI che l'host dell'agente può usare | È un runtime, non un modello; cambiarlo non rende più intelligente lo stesso modello |
| Modello MoE orientato alla programmazione | Un tentativo di supportare attività e strumenti di un carico di lavoro reale, anziché una dimostrazione di chat | Non è stato dimostrato che sia equivalente ai modelli cloud di frontiera; nelle precedenti esecuzioni locali servivano ancora correzioni umane |
| Quantizzazione Q4_K_M | Riduce lo spazio occupato dai pesi quanto basta per rendere praticabile il posizionamento ibrido | È un compromesso tra precisione e qualità, non un vantaggio gratuito |
| Divisione tra CPU e GPU | La VRAM è limitata e i pesi la superano | I pesi degli esperti dei primi 32 dei 48 livelli risiedono nella RAM di sistema; il resto viene eseguito sulla GPU |
| Limite di contesto 128K | Lascia spazio per istruzioni, definizioni di competenze e strumenti, input dell'attività, risultati degli strumenti e output | È una capacità configurata, non un requisito per ogni turno |
| Una richiesta simultanea, 12 thread CPU | Contiene la richiesta di memoria entro i limiti della RAM e dei core fisici disponibili | Non è stato dimostrato che sia ottimale per altri carichi di lavoro |
| Serving nativo Windows | Ha evitato il limite di 32 GB di RAM della VM WSL e gli inconvenienti del caricamento del modello attraverso file montati in Windows | I comandi operativi Linux di Kilo continuano a essere eseguiti all'interno di WSL |
Che cosa ha fatto davvero un'esecuzione

| Fase | Durata | Dettaglio |
|---|---|---|
| Elaborazione dell'input e del contesto | 448,92 s (7 min 29 s) | 66.170 token di input iniziali, circa 147 token di input/sec effettivi |
| Sonda remota per verificare lo stato dei log | 5,428 s | Codice di uscita 0, sul mio server operativo |
| Risposta successiva del modello | 20,1 s | 66.251 token di input riutilizzati, 763 nuovi, 388 token di output, circa il 98,9% riutilizzato |
Sono tre fasi diverse di un'unica esecuzione, non confronti omogenei. I 448,92 secondi corrispondono all'elaborazione a freddo di un contesto ampio, osservata una sola volta in un flusso di lavoro. I 5,428 secondi sono il tempo impiegato dalla sonda remota per svolgere il proprio lavoro. I 20,1 secondi sono una seconda fase del modello dopo il ritorno dello strumento. Sarebbe sbagliato interpretare il confronto tra 449 e 20,1 secondi come un'accelerazione della stessa attività, perché il lavoro era diverso e la seconda fase ha ereditato un prefisso già elaborato.
Da dove proveniva il riutilizzo
Questa fase successiva ha riutilizzato 66.251 token di input e ne ha elaborati 763 nuovi, pari a circa il 98,9% di riutilizzo. È facile confondere due meccanismi diversi, quindi è utile distinguerli. Il caching KV memorizza lo stato di attenzione, in modo che a ogni fase di generazione non sia necessario ricalcolare i token precedenti nello stesso modo; Q8 è una scelta relativa alla precisione di archiviazione. Il riutilizzo del prefisso è invece un comportamento: il motore ha rilevato che l'inizio della richiesta corrispondeva a contenuto già elaborato e ha evitato di rielaborare quella parte. Nessuno dei due meccanismi riduce i pesi del modello e nessuno dei due equivale a uno sconto sulla fatturazione cloud. La contabilizzazione della cache di input presso un provider cloud è un meccanismo separato, con regole e tariffe proprie.
La disponibilità è un problema separato
Il 31 ottobre 2026 la mia sessione di Kilo Desktop era bloccata su un indicatore di caricamento, così ho chiesto di indagare sul blocco. La causa non era la qualità del modello, la dimensione del contesto né un errore dello strumento. Il server locale del modello era spento. Kilo continuava a riprovare e a ricevere ECONNREFUSED, ma l'indicatore di caricamento non rendeva mai chiara la causa.
Avviare il server ha ripristinato la sessione esistente. Non è stato necessario scartare il contesto né rifare il lavoro. La soluzione duratura è stata un avviatore su richiesta: avviare il server, attendere che fosse pronto e poi aprire Kilo. Non ho aggiunto nulla all'accesso a Windows, una scelta che preferivo su una macchina che uso anche in modo interattivo. La configurazione di llama.cpp e Qwen era già presente; l'incidente ha cambiato il modo in cui viene avviato il server, non il modo in cui viene servito il modello.
Vale la pena sottolinearlo perché è la lezione opposta rispetto ai tempi descritti sopra. Un modello veloce su un server non disponibile non produce nulla.
Il costo del prompt, senza giri di parole
In questa esecuzione il prompt era grande perché il flusso di lavoro lo richiedeva. Istruzioni, definizioni delle competenze, definizioni degli strumenti, attività e spazio per i risultati degli strumenti si sommano; non ho alcun interesse a eliminare competenze o connessioni MCP solo per far sembrare migliore un numero. Un benchmark basato su un flusso di lavoro svuotato non descrive un agente funzionante.
È quindi meglio confrontare onestamente le categorie di costo, senza accorparle.
I piani cloud possono addebitare costi diversi per i token di input, i token di output e l'input memorizzato nella cache. Il costo dell'input non memorizzato nella cache è all'incirca pari ai token di input divisi per un milione, moltiplicati per il prezzo del provider per un milione di token di input. Il costo dell'output e gli eventuali sconti sulla cache dipendono dal provider e dal piano. La fatturazione effettiva dipende quindi dal provider e dalla fascia di prezzo; non inventerò una cifra in dollari.
L'inferenza locale elimina il costo API per token per quel modello locale. Non elimina i costi degli strumenti a pagamento o dei servizi remoti e non è gratuita. I costi comprendono l'hardware, la capacità di memoria e di VRAM, il consumo elettrico, la manutenzione della configurazione, il tempo passato ad aspettare e la revisione umana dell'output. Sono costi reali, che non diminuiscono solo perché l'inferenza è locale.
Un punto che spesso si perde di vista: l'inferenza locale non rende locali né offline le chiamate MCP remote. I miei strumenti continuano a raggiungere servizi remoti attraverso la rete. Ciò che lascia la mia macchina è il traffico degli strumenti; il modello che decide quali chiamate effettuare è solo una parte dell'esposizione.
Tenete inoltre distinta la capacità di contesto di 128K dai 66.170 token elaborati. La prima è un'impostazione, i secondi rappresentano ciò che questo turno ha effettivamente inviato. Nessuno dei due valori equivale ai token fatturabili o al costo di completamento dell'attività.
Che cosa mostra questa esecuzione e che cosa no
Il risultato osservato è stato modesto e reale: la sonda della competenza in tempo reale è stata completata sul mio server operativo, Kilo ha prodotto un rapporto e il rapporto conteneva elementi di prova da sottoporre alla revisione di una persona. La sonda e la risposta sono state completate. Questo, da solo, non dimostra che siano state seguite tutte le istruzioni della competenza o che ogni conclusione fosse corretta.
È questo il criterio che mi interessa davvero: completamento e correttezza, non velocità. Aspettare sette minuti e mezzo è accettabile quando l'agente segue la propria competenza, chiama gli strumenti giusti e restituisce qualcosa che si possa esaminare. Una risposta incompleta non ha alcun valore per questo flusso di lavoro.
Non ne consegue che questa configurazione sia generalmente affidabile, che sia all'altezza di un modello cloud di frontiera o che i tempi riportati qui permettano di prevedere i tuoi. Un'esecuzione è solo un'esecuzione. E un grafico del tempo di elaborazione del prompt misura il costo di fornire l'input al modello, non la qualità di ciò che ha prodotto. Completamento, qualità dell'output e costo della revisione determinano se vale la pena eseguire il flusso di lavoro.
Se esegui attività con agenti localmente, qual è il tuo budget per l'elaborazione del prompt e come decidi se vale la pena aspettare un turno lento?
Nota sulle prove: Queste cifre provengono da una singola esecuzione locale strumentata da un utente il 31 ottobre 2026, con tempi approssimativi rilevati in un flusso di lavoro reale. Non sono un benchmark standardizzato, un confronto controllato tra Ollama e llama.cpp né un confronto delle prestazioni o dei costi tra cloud e locale.