QRAE: comprimere il contesto degli agenti DeepSearch per risparmiare token e latenza

Quando un agente DeepSearch risponde a una domanda, non fa un solo salto: cerca, apre una pagina, legge un frammento, ragiona, e torna a cercare. Ogni risultato che trova — i chunk di testo recuperati — resta in memoria e viene riletto a ogni passo successivo. Dopo dieci ricerche, il contesto è spesso più lungo della risposta, e gran parte di quei frammenti non verrà mai più usata. È lì che si perdono il budget di token e la latenza.
QRAE (Query-Relevant Attention Entropy) è una tecnica di compressione del contesto che affronta proprio questo punto: decidere, prima che un frammento entri nel contesto di ragionamento, se vale la pena tenerlo. Il paper — QRAE: Query-Relevant Attention Entropy for Context Compression in DeepSearch Agents — la misura su più benchmark e modelli, e i numeri sono il punto.
Il problema: il contesto che cresce a ogni passo
Un agente DeepSearch (il tipo di agente che fa ricerche approfondite, come Tongyi DeepResearch o OpenResearcher) lavora a ciclo: genera un ragionamento, lancia un'azione (cerca, apri, leggi), e incorpora il risultato nel contesto. I frammenti recuperati — i chunk — sono la parte più grossa del contesto e si accumulano di passo in passo.
Il costo è doppio. Prima, ogni token che resta nel contesto viene rielaborato a ogni chiamata successiva: il prefill si ripaga a ogni passo. Secondo, più contesto significa più latenza: il modello impiega di tempo solo per rileggere materiale che non userà mai.
Le soluzioni classiche — riassumere la storia con un altro modello (ACON), rimuovere token con una policy di compressione appresa (LLMLingua-2), o piegare le sottotraiettorie completate in riassunti compatti (Context-Folding) — funzionano, ma aggiungono un passaggio generativo extra. In pratica: paghi un'altra chiamata al modello per comprimere il modello.
Come funziona QRAE
L'idea di QRAE è non aggiungere nessuna chiamata generativa: usare il modello stesso, solo in fase di prefill, per decidere cosa tenere.
Il framework mantiene due aree separate:
- Una whitelist persistente — i chunk ammessi, che restano nel contesto di ragionamento tra un passo e l'altro.
- Una cache di candidati — i chunk incerti, tenuti fuori dal contesto ma recuperabili: se in seguito arriva nuova evidenza, possono essere riesaminati e ammessi.
Per ogni nuovo lotto di chunk, QRAE esegue due prefills abbinati: uno con la query e uno di controllo senza query. La differenza tra le due risposte di attenzione isola la reazione indotta specificamente dalla query. Poi misura l'entropia normalizzata di quella reazione all'interno di ogni chunk: un frammento davvero rilevante fa rispondere in modo ampio molti token a supporto (entropia alta), mentre una coincidenza casuale produce un picco isolato (entropia bassa).
Il segnale viene da una piccola famiglia di teste di attenzione query-rilevanti, localizzate una volta, offline, su 100 traiettorie HotpotQA. Una volta localizzate restano fisse: sono una proprietà del modello, non della dataset di localizzazione. Il paper le chiama "teste di valutazione dell'evidenza" e mostra che ricorrono attraverso modelli e architetture diverse.
Nessun operatore di attenzione modificato, nessun passaggio di compressione generativo. Solo due prefills extra, a costo delimitato e indipendente dalla dimensione della cache di candidati.
I numeri
Sul modello principale DeepDiver-7B, confrontato con l'agente DeepSearch senza compressione:
| Benchmark | Successo (base → QRAE) | Token (base → QRAE) | Latenza (base → QRAE) |
|---|---|---|---|
| BrowseComp-Plus | 13,8% → 17,2% | 177k → 54k | 29,5 s → 20,5 s |
| XBench-DeepSearch | 38,0% → 44,0% | 319k → 117k | 276 s → 150 s |
| FRAMES | 40,9% → 42,8% | 140k → 94k | 158,7 s → 90,7 s |
| SimpleQA | 79,6% → 82,2% | 74k → 45k | 145,6 s → 98,6 s |
In media QRAE migliora il successo del task di 2,35 punti percentuali mentre taglia la latenza del 30% e il consumo di token del 45%. Su XBench-DeepSearch i token scendono del 63% (da 319k a 117k) con il successo che sale di 6 punti. E in tutti e quattro i benchmark il successo non peggiora: sale.
Il risultato si generalizza oltre il modello di riferimento. Su architetture ibride a tempo lineare (OpenResearcher-30B, Mamba–Transformer) e con attenzione sparsa (OpenPangu-2.0-Flash-92B, quasi 100B di parametri), QRAE resta efficace: su BrowseComp-Plus con i 92B, i token passano da 1077k a 660k (−39%) e il successo da 54,9% a 55,3%.
Cosa cambia per chi gira in locale
Se fai girare agenti di ricerca sul tuo hardware, il contesto è il tuo collo di bottiglia. I token che restano nel contesto sono i token che la tua GPU deve rielaborare, e su un setup locale non c'è un cluster che li diluisce: ogni secondo di latenza lo senti tu, e ogni watt lo paghi tu.
QRAE non ti dà un modello più veloce, ma ti mostra come far lavorare meglio lo stesso modello: smettere di trascinare nei prompt i frammenti che non servono. La riduzione del 45% sui token significa, a parità di modello, prompt più corti a ogni passo e un costo operativo inferiore. La riduzione del 30% sulla latenza è pura velocità percepita — su un agente che fa decine di passi, è la differenza tra una risposta che arriva e una che fa aspettare.
E i limiti?
- È un metodo, non un pacchetto. QRAE è un framework di ricerca: richiede di localizzare le teste rilevanti (una volta, offline) e di integrare il gestore del contesto nel tuo agente. Non lo scarichi e funziona da solo.
- Testato su DeepSearch. I benefici sono misurati su agenti che cercano e accumulano chunk. Su un chatbot a turno singolo il problema non c'è, e con esso il guadagno.
- I token risparmiati non garantiscono la precisione. Il paper lo dice esplicitamente: il conteggio dei token non è un conteggio dei FLOP, e il risparmio non implica automaticamente le stesse risposte. Qui i due vanno insieme, ma va verificato caso per caso.
- Dipende da un segnale interno. Funziona perché quei modelli contengono teste di query-rilevanza. Su modelli dove quel segnale è debole o assente, il metodo perde efficacia.
Come portarne l'idea nel tuo setup
Anche senza implementare QRAE, il principio è quello da adottare: non mandare mai nel contesto di ragionamento tutto ciò che recuperi. Tre abitudini concrete:
- Tieni un contesto di evidenze delimitato — lascia dentro solo i frammenti che il ragionamento attuale sta usando, non la cronologia completa.
- Mantieni una coda di candidati — se un frammento è incerto, mettilo da parte invece di buttarlo: puoi riesaminarlo quando arriva nuovo contesto.
- Misura i token per passo — se il contesto cresce in modo lineare con il numero di ricerche, stai pagando il prefill più volte per lo stesso materiale.
Il paper completo, con le formule e i dettagli sperimentali, è disponibile nella versione HTML.
Fonti
- QRAE: Query-Relevant Attention Entropy for Context Compression in DeepSearch Agents — arXiv, 5 novembre 2026 (fonte primaria per tutti i numeri citati)
- QRAE — versione HTML completa — tabelle sperimentali, localizzazione delle teste e analisi dei costi
In sintesi
QRAE è una tecnica di compressione del contesto per agenti DeepSearch che decide, con due prefills e l'entropia dell'attenzione del modello stesso, quali frammenti recuperati meritano di restare nel contesto di ragionamento. Niente passaggio generativo extra, niente modifica dell'operatore di attenzione. I risultati, su quattro benchmark e modelli fino a quasi 100B di parametri: successo in media +2,35 punti, token −45%, latenza −30%. L'idea di fondo — non trascinare nel contesto ciò che non userai, e tenere una coda di candidati per ciò che è incerto — è il principio da adottare oggi, indipendentemente dal fatto che implementerai il metodo.
Articolo generato con IA
In questi percorsi
Ti è piaciuto questo articolo?
Iscriviti alla newsletter per ricevere nuovi tutorial e guide.
Articoli Correlati

Qwen3.8-2.4T-A95B: i conti per girare 2,4 trilioni di parametri open-weight, con 95B attivi
Il primo modello Qwen-Max in open-weight pesa ~1,3 TB in Q4: nessun nodo consumer singolo ci entra. I conti su ammortamento, luce e velocità per il multi-nodo.

Ripple-65B: un dense da 64,8B in Apache-2.0, i conti per girarlo in locale
64,8B di parametri, Apache 2.0, 1M di contesto e un checkpoint NVFP4 pensato per 128 GB di memoria unificata: i conti e i criteri per girare un dense da frontier in locale.

