Passa al contenuto principale

Harness agentici async-first: cosa cambia Unreal Agent

Avanzato

Il 22 settembre 2026 Unreal Labs ha rilasciato Unreal Agent — un harness agentico con licenza MIT scritto in Go — e ha pubblicato run di benchmark che lo mostrano eguagliare il pass rate di Codex su Terminal-Bench 4.0 spendendo $1,428 contro $2,350. Stesso modello, stessi task, stesso punteggio, 39% in meno di soldi.

La parte interessante non è il numero. È dove sono finiti i soldi. La tesi centrale di Unreal Agent è che una fetta consistente di quello che paghi a un agente di coding non è ragionamento affatto — è il modello seduto nel loop a gestire la propria attesa. Questa pagina parla di quel meccanismo, perché si trasferisce a qualunque harness tu costruisca o compri, comprese cose che non hanno nulla a che fare con Unreal Labs.

What you'll learn
  • Capire il flusso di eventi delle chiamate a strumenti asincrone: cosa viene aggiunto al log di sessione, quando, e cosa vede davvero il modello
  • Imparare perché il numero di turni — non la lunghezza dell'output — è l'unità che guida il costo di un agente, e come misurarla nel tuo loop
  • Leggere onestamente la tabella dei costi pubblicata: cosa coprono le cifre in dollari e cosa no
  • Conoscere i tre design che Unreal Labs ha deliberatamente rifiutato di costruire (sub-agent, workflow, hook di sicurezza a livello di harness) e l'argomento dietro a ciascuno
  • Applicare le regole trasferibili al tuo agente, qualunque harness tu stia già usando

La versione in una frase​

Unreal Agent è un harness in Go con licenza MIT che aggiunge ogni chiamata a uno strumento a un log di sessione append-only come evento in corso e lascia che l'esecuzione prosegua in background, così il modello non si blocca mai e non fa mai polling — il che taglia i turni, e i turni sono ciò che paghi davvero.

Il meccanismo, con precisione​

Ecco un normale turno agentico sincrono:

  1. Il modello emette una chiamata a uno strumento.
  2. L'harness esegue lo strumento. Il loop è sospeso.
  3. Lo strumento restituisce. L'harness aggiunge il risultato.
  4. L'harness richiama il modello con l'intera trascrizione.

Ora lo stesso turno in Unreal Agent:

  1. Il modello emette una chiamata a uno strumento.
  2. L'harness immediatamente aggiunge al log di sessione un evento che dice che la chiamata è in corso, e avvia l'esecuzione in background.
  3. L'esecuzione prosegue. Il modello è libero di emettere altre chiamate.
  4. Quando lo strumento termina, il suo risultato viene aggiunto al log — e quella aggiunta è ciò che innesca la chiamata successiva al modello.

Il modello vede lo stato in esecuzione e poi il risultato finale, in ordine, nella propria trascrizione. Non deve mai codificare "aspetta questo", non emette mai un polling, non si porta dietro contabilità di heartbeat nel ragionamento. Come lo mette Unreal Labs: l'harness permette al modello di "emettere più chiamate pesanti a strumenti per turno di modello senza sprecare token in polling o attese".

È tutta qui l'idea. È piccola. Ed è anche la parte che la maggior parte degli harness sbaglia, perché un loop sincrono è la cosa ovvia da scrivere.

Perché si vede sui soldi​

Ogni turno di modello rimanda l'intera trascrizione accumulata. Una run agentica da 30 turni non costa 30× una singola chiamata — costa all'incirca la somma di un contesto che cresce lungo 30 chiamate. Il numero di turni è quindi più vicino a un driver di costo quadratico che lineare, e domina qualunque risparmio ottenuto sfrondando il system prompt.

Guarda cosa riportano le run pubblicate accanto ai dollari:

BenchmarkPass rateUnreal AgentTurniCodexPiTurni Pi
Terminal-Bench 4.057.9%$1,42828$2,350$1,82744
SWE-Atlas Codebase QnA65.8%$93616$1,303$1,033—
DeepSWE 1.172.4%$1,36726$1,633$1,584—
ALE-CLI30.0% pass completo$217————

Su Terminal-Bench 4.0 il confronto è 28 turni contro i 44 di Pi — una riduzione del 36% nei turni per una riduzione del 22% nel costo rispetto a Pi, e del 39% rispetto a Codex. La colonna dei turni è quella causale; la colonna dei dollari è la conseguenza.

È la stessa lezione che AILmanac affronta dall'altra direzione in perché gli agenti bruciano token: la cosa costosa in un agente non è la risposta, è la rilettura.

Pro tip
  • Strumenta il numero di turni prima di qualunque altra cosa. Se registri solo i token, ottimizzerai i prompt e ti perderai il loop.
  • Una diagnostica utile: conta quanti turni del tuo agente non hanno prodotto nessuna chiamata a strumenti e nessun output visibile all'utente. Quelli sono puro overhead di loop — attesa, controllo, ri-pianificazione — ed è esattamente ciò che un harness asincrono rimuove.
  • Gli strumenti che possono girare in parallelo amplificano l'effetto. Se i tuoi tre strumenti più lenti possono girare in concorrenza, un loop sincrono li paga tutti e tre in serie, sia in tempo reale SIA in turni.

Tre cose che deliberatamente non hanno costruito​

Le motivazioni contano più del codice, perché sono argomenti che puoi applicare a qualunque harness tu stia già usando.

1. Niente sub-agent, niente workflow​

Unreal Labs ha scelto "un modello di chiamata a strumenti asincrona lineare" invece della delega a sub-agent e dei workflow predefiniti. Il ragionamento è che, una volta che le chiamate a strumenti sono davvero asincrone, gran parte di ciò a cui servivano i sub-agent — far girare cose in parallelo senza bloccare il genitore — è già gestito dal loop. I sub-agent aggiungono allora frammentazione del contesto, fusione dei risultati e overhead di turni propri, per un problema che non hai più.

È una posizione reale, non l'unica. I design multi-agente vincono ancora dove vuoi davvero un contesto isolato, non solo parallelismo. Ma "ci servono i sub-agent per fare due cose alla volta" è un'affermazione che vale la pena ritestare prima contro un loop asincrono.

2. Niente hook di sicurezza a livello di harness​

Questo è l'argomento più tagliente del post di lancio, e vale la pena citarne la forma: sicurezza e approvazioni che si appoggiano a hook dell'harness "tendono a richiedere più manutenzione e a essere meno robuste di vincoli deterministici di ambiente o sandbox, fuori dall'harness".

Cosa raccomandano al suo posto: host consentiti e vietati, token di accesso granulari e proxy con gate di approvazione. In altre parole, mettere il controllo dove l'agente fisicamente non può arrivare.

La logica è lineare una volta enunciata. Un hook dell'harness è codice che gira nello stesso processo del loop dell'agente, a filtrare uno strumento che l'agente può già invocare. Un confine di sandbox è imposto dal kernel o dalla rete, sotto l'agente del tutto. Se il tuo agente ha uno strumento bash — e quello di Unreal Agent ce l'ha — una allowlist in-process è un dosso, non un muro. La pagina di AILmanac su mettere in sicurezza agenti locali e ibridi spiega come costruire il confine esterno.

3. Nessun SDK agentico di fornitore​

Unreal Labs si è allontanata dagli SDK dei fornitori (l'Agent SDK di Anthropic è nominato) perché quelli presuppongono "sessioni locali, sottoprocessi e limiti di risorse che non si traducono in modo pulito nell'uso in produzione".

È un argomento sulla forma del deployment, non sulla qualità. Un SDK modellato su una sessione CLI locale presuppone un processo, una macchina, una durata. Una flotta di agenti in produzione vuole sessioni che sopravvivano a un processo e possano essere riprese su un'altra macchina — che è esattamente ciò che fornisce il session store append-only e versionato di Unreal Agent, incluso il fork di una sessione per biforcare una run.

Se stai costruendo un prodotto sopra un loop agentico, questa è la domanda da fare a qualunque SDK: una sessione può sopravvivere al processo che l'ha creata?

L'architettura, in breve​

L'harness è deliberatamente piccolo ed esplicitamente componibile — otto componenti sostituibili dietro interfacce documentate:

  • Session inbox — deduplica gli input. Ogni input porta un ID chiamante globalmente unico e stabile, così i retry non applicano due volte.
  • Coordinator — possiede i turni dell'LLM e smista le operazioni.
  • Session store — storia persistita append-only, supporta il fork, versionata.
  • Context builder — assembla l'input del modello. Non esegue nessun I/O.
  • LLM adapter — parla con il fornitore.
  • Tool registry e translator — validano le chiamate in modo sincrono e devono "non eseguire alcun I/O né sospendere il loop".
  • Operation manager — esegue il lavoro in background durevole.

Due vincoli in quell'elenco fanno il lavoro pesante ed è facile perderli: il context builder e i tool translator hanno il divieto di fare I/O. È questo che mantiene deterministico e non bloccante il percorso caldo del coordinator — tutta la latenza viene spinta nelle operazioni, che sono le cose progettate per essere asincrone. Se costruisci il tuo harness, questa è la regola da rubare.

I formati di storage e le operazioni sono versionati, e una versione di sessione non supportata dà errore esplicito alla ripresa invece di caricarsi a metà. È la modalità di fallimento corretta per lo stato durevole, ed è più rara di quanto dovrebbe essere.

La superficie di strumenti integrata è di tre strumenti: Bash, ViewImage e Skill-use — l'ultimo dei quali si aggancia al formato portabile di skill che AILmanac copre in SKILL.md come standard aperto. Tre strumenti sono il punto: una superficie di strumenti piccola e a basso costo in token è parte della storia del costo.

Farlo girare​

Guided walkthrough1 of 5
  1. Toolchain Go 1.27+, poi go install del runner dal percorso cmd/, oppure clona e usa il Makefile incluso (make build, make test).

Installa ed esegui (dall'uso documentato da Unreal Labs)

go install github.com/unreallabsai/unreal-agent/cmd/unreal-agent-runner@latest

export OPENAI_API_KEY="..."
unreal-agent-runner -p 'Inspect this project and explain how to run its tests.'

Puntalo su un fornitore diverso e conserva la trascrizione

export UNREAL_HARNESS_LLM_PROVIDER=openrouter
export UNREAL_HARNESS_LLM_MODEL=<model-id>

unreal-agent-runner \
-workspace ./my-project \
-p 'Summarize this project.' > run.jsonl

Leggere onestamente la tabella dei benchmark​

Quattro avvertenze, perché i numeri sono abbastanza buoni da meritare scrutinio:

  • Ogni run è del fornitore stesso. Nessuna terza parte le aveva replicate al momento della scrittura.
  • Un solo modello. Tutte le run pubblicate hanno usato GPT-6 Astra a reasoning xhigh. Il vantaggio asincrono dovrebbe generalizzare — è una proprietà del loop, non del modello — ma "dovrebbe" non è "è stato misurato".
  • I dollari sono totali di suite intera, non costi per task. Sono confrontabili tra loro e non con il tuo carico di lavoro.
  • I pass rate sono eguagliati, non migliorati. La tesi è esplicitamente stesso punteggio, meno soldi. Su DeepSWE 1.1 Unreal Agent riporta 72.4% a $1,367 contro i $1,633 di Codex — un risparmio del 19%, notevolmente più piccolo del 39% su Terminal-Bench. Il vantaggio scala con quanto i tuoi task sono pesanti di strumenti e a lunga durata. Su task brevi con poche chiamate a strumenti, aspettati quasi nulla.

Quest'ultimo punto è quello pratico. Se il tuo agente fa tre chiamate a strumenti e finisce, l'asincrono ti compra quasi niente. Se ne fa sessanta in mezz'ora, ti compra la differenza tra le due colonne.

Cosa si trasferisce al tuo agente​

Non devi adottare Unreal Agent per usare niente di tutto questo:

  • Misura i turni. È la variabile di costo che la maggior parte dei team non registra.
  • Rendi non bloccanti gli strumenti lenti, anche se il tuo harness è per il resto sincrono. Restituire subito un handle e consegnare il risultato come evento successivo è un cambiamento che puoi fare dentro la maggior parte dei loop.
  • Tieni il percorso caldo libero da I/O. L'assemblaggio del contesto e la validazione delle chiamate a strumenti non dovrebbero mai aspettare la rete.
  • Sposta le approvazioni fuori dal processo. Policy di rete, credenziali con ambito e un proxy che fa da gate battono una allowlist in-process che vive accanto a uno strumento bash.
  • Riduci la superficie di strumenti. Tre buoni strumenti costano meno token per turno di quindici mediocri, a ogni singolo turno.

Check yourself

0/5
  1. In Unreal Agent, cosa succede nell'istante in cui il modello emette una chiamata a uno strumento?
  2. Perché tagliare il numero di turni fa risparmiare più soldi che tagliare la lunghezza dell'output in un loop agentico?
  3. Perché Unreal Labs sostiene che le approvazioni non vadano implementate come hook dell'harness?
  4. Al context builder e ai tool translator è vietato eseguire I/O. Cosa compra questo vincolo?
  5. Su che tipo di carico di lavoro dovresti aspettarti che il vantaggio asincrono sia minimo?
Premi Invio o Spazio per girare la carta. Usa le frecce sinistra e destra per spostarti tra le carte.Termine mostrato.
1 / 8
Key takeaways
  • Il numero di turni, non quello di token, è la variabile di costo in un loop agentico. Strumentalo per primo.
  • Rendere non bloccanti le chiamate a strumenti rimuove i turni di polling e attesa — 28 turni contro 44 a parità di pass rate su Terminal-Bench 4.0 è tutto l'argomento.
  • Il vantaggio è proporzionale alla pesantezza di strumenti: 39% su Terminal-Bench, 19% su DeepSWE, ~0 su un task da tre chiamate.
  • La sicurezza sta fuori dall'harness. Un hook di approvazione in-process accanto a uno strumento bash è un dosso; una sandbox e un proxy che fa da gate sono un confine.
  • Tieni assemblaggio del contesto e validazione degli strumenti liberi da I/O. Spingi ogni attesa dentro un'operazione durevole.
  • Tutti i numeri pubblicati sono run del fornitore su un solo modello. Trattali come un'ipotesi ben argomentata sul tuo carico di lavoro, non come una sua misurazione.

Fonti e approfondimenti​

Avanti​