# Le impostazioni delle risorse di 66 compiti di Terminal-Bench

Terminal-Bench v4.1.0 dichiara impostazioni di risorse diverse per i suoi 66 compiti. Dal censimento dei file di configurazione risulta che 31 compiti specificano più di 4.096 MB di memoria e 22 più di due CPU. Una configurazione di confronto costruita con i valori espliciti più frequenti per CPU, memoria, archiviazione e GPU resta sotto almeno un valore dichiarato in 38 compiti. Queste differenze indicano quali impostazioni conservare o documentare quando si preparano ambienti isolati per una valutazione. Non permettono di prevedere i consumi o i fallimenti dei compiti.

Quando esegui lo stesso benchmark in un nuovo ambiente, quali condizioni si mantengono? Dipende dalla versione del compito, dalla versione del programma di esecuzione, dalle opzioni che sostituiscono i valori dichiarati e dalle regole del backend.

## La versione comprende compiti con esigenze dichiarate diverse

Abbiamo esaminato tutti i compiti del manifesto ufficiale di Terminal-Bench v4.1.0, pubblicato il 3 novembre 2026. Il censimento copre tutti i 66 compiti della versione, ciascuno con un file `task.toml` a una revisione precisa del codice sorgente. Il repository contiene anche compiti di versioni precedenti e file di supporto ai test che non rientrano nel censimento. [Versione e manifesto ufficiali](https://huggingface.co/datasets/harborframework/terminal-bench)

I valori dichiarati per l’ambiente principale vanno da 2 a 16 CPU e da 4.096 a 32.768 MB di memoria. Il valore più comune è di due CPU, presente in 44 compiti. Per la memoria, il più comune è 4.096 MB, presente in 35 compiti. Gli altri compiti dichiarano valori più alti.

![Frequenze dei valori espliciti di CPU e memoria nei 66 compiti. Per le CPU, 2 in 44 compiti, 4 in 14, 8 in 6 e 16 in 2. Per la memoria, 4.096 MB in 35 compiti, 8.192 MB in 22, 16.384 MB in 8 e 32.768 MB in uno.](https://sapien1.com/research/terminal-bench-resource-settings/figures/it/resource-distribution.svg)

I due pannelli riguardano gli stessi 66 ambienti dei compiti. I valori provengono dai file di configurazione della versione. Le [osservazioni complete](https://sapien1.com/research/terminal-bench-resource-settings/census.json) includono un URL fissato e l’hash del file sorgente per ciascun compito.

Le differenze contano quando un gruppo uniforma l’infrastruttura. Un ambiente uniforme può semplificare la pianificazione, ma cambia alcune condizioni dichiarate se il programma di esecuzione non applica le impostazioni dei singoli compiti. Avere più hardware a disposizione non garantisce il mantenimento di un limite dichiarato inferiore. Il confronto dipende dalle regole effettivamente applicate dal programma di esecuzione e dal backend.

## Una configurazione costruita con i valori più comuni cambia molte dichiarazioni

Per il confronto abbiamo combinato il valore esplicito più frequente di ciascuno dei quattro campi.

| Campo | Valore nella configurazione di confronto |
| --- | ---: |
| CPU | 2 |
| Memoria | 4.096 MB |
| Archiviazione | 10.240 MB |
| GPU | 0 |

Abbiamo costruito questa configurazione per l’analisi. Non è un’impostazione predefinita di Harbor, una raccomandazione di un fornitore o una configurazione osservata in un ambiente effettivo. Ogni valore è comune da solo. La combinazione completa può avere una frequenza diversa.

Per ogni compito abbiamo controllato se almeno una dichiarazione esplicita superasse il valore di confronto corrispondente. Succede in **38 compiti su 66**. I conteggi per campo sono 22 per le CPU, 31 per la memoria, 17 per l’archiviazione e tre per il numero di GPU. I gruppi si sovrappongono e sommarli conterebbe più volte alcuni compiti. I [risultati del confronto](https://sapien1.com/research/terminal-bench-resource-settings/census-results.json) contengono l’elenco esatto dei compiti nell’insieme complessivo e in ogni campo.

Negli altri 28 compiti, le dichiarazioni registrate non superano nessuno dei quattro valori di confronto. Ciò non dimostra che la configurazione sia compatibile con quei compiti. Otto compiti omettono il numero di GPU e il censimento mantiene il campo assente anziché riportare uno zero dichiarato. File, container ausiliari, immagini e servizi possono imporre altri requisiti.

Per le esecuzioni senza GPU, i responsabili rendono disponibile un [insieme separato di 63 compiti per sole CPU](https://hub.harborframework.com/datasets/terminal-bench/terminal-bench-cpu-only) in Terminal-Bench 4.1.0. Eseguilo con `harbor run -d terminal-bench/terminal-bench-cpu-only@4.1.0` e distingui i risultati da quelli della versione intera di 66 compiti. L’inclusione nell’insieme non dimostra che un compito rispetti un determinato limite di CPU, memoria o archiviazione.

Prima di un’esecuzione, usa l’elenco delle eccezioni per capire quali impostazioni cambierebbero in un ambiente standardizzato.

## Le dichiarazioni passano per il programma di esecuzione e il backend

Il file del compito è una parte della configurazione di valutazione. Per capire come vengono usate le dichiarazioni, abbiamo esaminato una revisione fissa di Harbor i cui [metadati del pacchetto indicano la versione 0.26.0](https://github.com/harbor-framework/harbor/blob/ec6aeab7fe0eb51df52b4e72c524daf5ea9cc5f4/pyproject.toml#L3).

Nel codice esaminato, le opzioni di un singolo tentativo possono sostituire i valori di risorse del compito. Le regole per CPU e memoria possono decidere se applicare o ignorare i valori. Il parser lascia non impostati CPU, memoria e archiviazione se i campi sono assenti. L’ambiente di base interpreta l’omissione del numero di GPU come uno zero effettivo. Il censimento conserva l’omissione originale per distinguere ciò che è scritto nel compito dall’interpretazione del programma di esecuzione. [Logica degli ambienti di Harbor nella revisione esaminata](https://github.com/harbor-framework/harbor/blob/ec6aeab7fe0eb51df52b4e72c524daf5ea9cc5f4/src/harbor/environments/base.py#L468)

Anche il backend incide sul risultato. L’adattatore Docker esaminato traduce in limiti le proprie regole automatiche per CPU e memoria. [Ignora esplicitamente la scelta del tipo di GPU](https://github.com/harbor-framework/harbor/blob/ec6aeab7fe0eb51df52b4e72c524daf5ea9cc5f4/src/harbor/environments/docker/docker.py#L272), e il codice che scrive le risorse di Compose non imposta un tetto per l’archiviazione. Tre compiti dichiarano una H100, ma quel campo da solo non dimostra che Docker la assegni. Allo stesso modo, `storage_mb` da solo non stabilisce un limite per il disco in Docker. La configurazione di Compose può imporre altri vincoli e altri backend possono comportarsi diversamente. [Adattatore Docker](https://github.com/harbor-framework/harbor/blob/ec6aeab7fe0eb51df52b4e72c524daf5ea9cc5f4/src/harbor/environments/docker/docker.py#L568) · [Scrittura delle risorse di Compose](https://github.com/harbor-framework/harbor/blob/ec6aeab7fe0eb51df52b4e72c524daf5ea9cc5f4/src/harbor/environments/docker/__init__.py#L36)

Per rendere ripetibile la valutazione, conserva la dichiarazione e registra come l’ha applicata il backend scelto. La configurazione richiesta e l’assegnazione effettiva forniscono informazioni diverse.

![Quattro elementi da registrare per una valutazione. La dichiarazione del compito a una revisione precisa, la versione e le opzioni del programma di esecuzione, le regole del backend e l’assegnazione osservata, se disponibile.](https://sapien1.com/research/terminal-bench-resource-settings/figures/it/evaluation-record.svg)

Registra in campi distinti le impostazioni richieste e le risorse assegnate.

## Registra separatamente i limiti di tempo dell’agente e le impostazioni del verificatore

Tutti i 66 file impostano esplicitamente un limite di 28.800 secondi per l’agente, pari a otto ore. È un massimo configurato. I limiti dichiarati per la verifica vanno da 60 a 18.000 secondi e quelli di build da 300 a 18.000 secondi. Tieni separate le fasi quando stimi la durata di un compito.

Il programma di esecuzione esaminato può sostituire i limiti di tempo e applicare massimi e moltiplicatori. Nella funzione ispezionata, il massimo viene applicato prima del moltiplicatore. L’analisi non somma i limiti delle varie fasi per prevedere il tempo totale trascorso. [Risoluzione dei limiti nella revisione esaminata](https://github.com/harbor-framework/harbor/blob/ec6aeab7fe0eb51df52b4e72c524daf5ea9cc5f4/src/harbor/trial/trial.py#L695) · [Calcolo del tempo per fase](https://github.com/harbor-framework/harbor/blob/ec6aeab7fe0eb51df52b4e72c524daf5ea9cc5f4/src/harbor/trial/trial.py#L1724)

Con le regole sui limiti di tempo della versione di Harbor che abbiamo esaminato, abbiamo calcolato i limiti per la verifica di tutti i 66 compiti di Terminal-Bench v4.1.0. Abbiamo provato separatamente un massimo di 600 secondi e la sostituzione del limite con 600 secondi, usando un moltiplicatore di 1 in entrambi i casi. Il limite più alto calcolato era di 600 secondi in entrambi i casi. Il massimo ha mantenuto i 28 limiti più brevi. La sostituzione li ha portati tutti e 28 a 600 secondi. Per mantenere i limiti più brevi in questa configurazione, usa il massimo e registra l’impostazione usata. [Come Harbor sceglie il limite di tempo iniziale](https://github.com/harbor-framework/harbor/blob/ec6aeab7fe0eb51df52b4e72c524daf5ea9cc5f4/src/harbor/trial/trial.py#L1737-L1745) · [Come Harbor applica il massimo e il moltiplicatore](https://github.com/harbor-framework/harbor/blob/ec6aeab7fe0eb51df52b4e72c524daf5ea9cc5f4/src/harbor/trial/trial.py#L695-L705)

Il limite di tempo del job che esegue l’agente può fermare un agente in esecuzione locale prima che scada il suo limite. Per esempio, se l’agente ha otto ore a disposizione per un compito, non può usarle tutte in un [job ospitato da GitHub](https://docs.github.com/en/actions/reference/limits) con un limite di sei ore. Anche la preparazione svolta nello stesso job riduce il tempo disponibile. Registra separatamente il limite di tempo del job e quello dell’agente.

Tutti i compiti selezionano esplicitamente una verifica separata. Sei forniscono un blocco di configurazione per l’ambiente del verificatore. Nella funzione Harbor esaminata, il blocco esplicito viene selezionato per intero senza fondere i campi con quelli dell’ambiente del compito. Se manca il blocco, la funzione copia l’ambiente del compito. Le opzioni del singolo tentativo possono comunque modificare la configurazione effettiva del verificatore. [Risoluzione della configurazione del verificatore](https://github.com/harbor-framework/harbor/blob/ec6aeab7fe0eb51df52b4e72c524daf5ea9cc5f4/src/harbor/models/task/verifier_mode.py#L15)

Tieni un registro separato per l’agente e il verificatore, anche quando le impostazioni coincidono. La verifica separata non indica da sola quali risorse vengano assegnate o se i due ambienti le consumino contemporaneamente.

Abbiamo confrontato le dichiarazioni di CPU, memoria, archiviazione, GPU, limiti di tempo e modalità di verifica tra Terminal-Bench 4.0 e 4.1 per i 66 compiti con nomi e percorsi coincidenti. Il [confronto](https://sapien1.com/research/terminal-bench-resource-settings/compare-versions.py) mostra due compiti con modifiche in questi campi. In `distributed-dedup` il limite di verifica passa da 1.800 a 3.900 secondi. In `payments-pipeline-fix` le dichiarazioni esplicite del verificatore passano da 6 CPU e 12.288 MB a 8 CPU e 16.384 MB. Sono valori dichiarati. Le [note della versione 4.1](https://github.com/harbor-framework/terminal-bench/releases/tag/v4.1.0) indicano che tutti i 66 compiti sono stati modificati. Questo confronto circoscritto lascia aperta l’equivalenza di istruzioni, immagini e verificatori.

Scarica [compare-versions.py](https://sapien1.com/research/terminal-bench-resource-settings/compare-versions.py) e [census.json](https://sapien1.com/research/terminal-bench-resource-settings/census.json) nella stessa cartella. Con Python 3.11 o una versione successiva e accesso a Internet, esegui `python3 compare-versions.py > comparison.json` da quella cartella. Lo script scarica la revisione fissata del registro 4.0 e i metadati senza eseguire i compiti. Il report conserva l’attribuzione alla fonte e la richiesta di tenere i dati del benchmark fuori dai corpora di addestramento.

## Che cosa conservare quando cambia la configurazione di una valutazione

Dal censimento si può ricavare un registro di configurazione sintetico.

1. **Fissa l’insieme di compiti.** Conserva insieme il manifesto, la revisione del sorgente e i percorsi dei compiti. Il conteggio dei file di tutto il repository può comprendere materiale esterno alla versione.
2. **Conserva le dichiarazioni originali.** Registra i valori espliciti e quelli omessi, incluse le impostazioni separate del verificatore e i limiti di tempo per fase.
3. **Documenta il programma di esecuzione e le opzioni.** Registra l’esatta versione o revisione e le opzioni che sostituiscono o moltiplicano le impostazioni dei compiti.
4. **Controlla le regole del backend.** Verifica quali campi diventano limiti, riserve, valori predefiniti o richieste prive di supporto.
5. **Registra l’assegnazione effettiva quando è osservabile.** Tienila separata dalla configurazione richiesta e dai consumi misurati durante l’esecuzione.

Se cambi intenzionalmente un limite o un’assegnazione, documenta la modifica accanto al risultato. Chi consulta la valutazione potrà così capirne le condizioni e tenere conto delle differenze fra ambienti.

Il [confronto delle configurazioni](https://sapien1.com/research/terminal-bench-resource-settings/census-results.json) e il [codice dell’analisi](https://sapien1.com/research/terminal-bench-resource-settings/census.py) permettono di esaminare le eccezioni. sapien1 applica questo tipo di verifica di compiti e ambienti quando definisce un progetto di [valutazione degli agenti](https://sapien1.com/it/agent-evaluation).

Per confrontare altri limiti, scarica il [filtro delle risorse](https://sapien1.com/research/terminal-bench-resource-settings/filter-census.py) e il [censimento](https://sapien1.com/research/terminal-bench-resource-settings/census.json) nella stessa cartella. Per esempio, `python3 filter-census.py --cpus 4 --memory-mb 8192 --status within` elenca i compiti i cui valori dichiarati rispettano i limiti sia nell’ambiente del compito sia in quello del verificatore. Il risultato mantiene i campi omessi e da solo non stabilisce se un compito si possa eseguire. Terminal-Bench chiede di tenere i dati del benchmark fuori dai corpora di addestramento.

### Confronta i compiti selezionati con ciascun limite

Ciascuno dei due esempi di limiti per le risorse seleziona 44 dei 66 compiti di Terminal-Bench v4.1.0. I due elenchi hanno 36 compiti in comune e 8 esclusivi ciascuno. Per ciascun limite il filtro controlla i valori dichiarati per CPU, memoria e spazio di archiviazione separatamente nell’ambiente del compito e in quello del verificatore.

| CPU | Memoria (MB) | Spazio di archiviazione (MB) | Compiti che rispettano tutti e tre i limiti |
| ---: | ---: | ---: | ---: |
| 4 | 8.192 | 10.240 | 44 |
| 2 | 16.384 | 20.480 | 44 |

Esegui entrambi i comandi dalla cartella che contiene il filtro e i dati del censimento. In ogni report, i campi `task` in `records` indicano gli ID dei compiti selezionati.

```bash
python3 filter-census.py --cpus 4 --memory-mb 8192 \
  --storage-mb 10240 --phases both --status within > ceiling-4cpu.json

python3 filter-census.py --cpus 2 --memory-mb 16384 \
  --storage-mb 20480 --phases both --status within > ceiling-2cpu.json
```

Quando riporti un punteggio, salva gli ID esatti dei compiti insieme alla versione del benchmark e alle impostazioni delle risorse. Se confronti due esecuzioni sui compiti in comune, calcola entrambi i punteggi sullo stesso elenco.

## Metodo e ambito

Il 17 novembre 2026 abbiamo completato il censimento delle dichiarazioni di configurazione di una sola versione. Il censimento riguarda tali dichiarazioni e non misura le prestazioni. La revisione di origine dei dati Terminal-Bench è `4070d6c`. La revisione Harbor esaminata è `ec6aeab`, identificata come 0.26.0 dai metadati del progetto. Il [metodo](https://sapien1.com/it/research/terminal-bench-resource-settings/methods.md) include gli hash completi, i collegamenti alle fonti, le regole di estrazione e i comandi per riprodurre il censimento.

Il programma di raccolta legge il manifesto ufficiale e 66 file TOML, per un totale di 85.966 byte alla fonte. Conserva separatamente i campi di versione e cerca alias di risorse precedenti, passaggi e blocchi di ambiente aggiuntivi. In questa versione non ne ha trovati per passaggi e vecchi alias. I file scaricabili pubblicamente contengono una selezione dei dati di configurazione e gli hash delle fonti. Restano escluse le istruzioni dei compiti, le soluzioni e gli ambienti completi.

Abbiamo verificato in modo indipendente la composizione del manifesto, i calcoli e alcuni esempi dalle fonti, tra cui un valore anomalo, un campo GPU omesso e un blocco di verifica esplicito. Non abbiamo eseguito modelli, container o compiti del benchmark.

