Zum Hauptinhalt springen

Async-First-Agent-Harnesses: Was Unreal Agent verändert

Experte

Am 22. September 2026 veröffentlichte Unreal Labs Unreal Agent — ein MIT-lizenziertes, in Go geschriebenes Agent-Harness — und publizierte Benchmark-Läufe, die zeigen, dass es die Pass-Rate von Codex bei Terminal-Bench 4.0 für 1.428 $ gegenüber 2.350 $ erreicht. Gleiches Modell, gleiche Aufgaben, gleicher Wert, 39 % weniger Geld.

Der interessante Teil ist nicht die Zahl. Es ist, wohin das Geld geflossen ist. Der zentrale Anspruch von Unreal Agent lautet, dass ein großer Teil dessen, was du einem Coding-Agenten zahlst, überhaupt kein Schlussfolgern ist — es ist das Modell, das in der Schleife sitzt und sein eigenes Warten verwaltet. Diese Seite handelt von diesem Mechanismus, denn er lässt sich auf jedes Harness übertragen, das du baust oder kaufst, einschließlich solcher, die nichts mit Unreal Labs zu tun haben.

What you'll learn
  • Den Event-Flow asynchroner Tool-Calls verstehen: was wann an das Session-Log angehängt wird und was das Modell tatsächlich sieht
  • Lernen, warum die Anzahl der Turns — nicht die Ausgabelänge — die Einheit ist, die Agentenkosten treibt, und wie man sie in der eigenen Schleife messen kann
  • Die veröffentlichte Kostentabelle ehrlich lesen: was die Dollarbeträge abdecken und was nicht
  • Die drei Designs kennen, die Unreal Labs bewusst nicht gebaut hat (Sub-Agenten, Workflows, Security-Hooks auf Harness-Ebene) und das jeweilige Argument dafür
  • Die übertragbaren Regeln auf den eigenen Agenten anwenden, egal welches Harness du schon nutzt

Die Kurzfassung in einem Satz​

Unreal Agent ist ein MIT-lizenziertes Go-Harness, das jeden Tool-Call als in-progress-Event an ein Append-only-Session-Log anhängt und die Ausführung im Hintergrund weiterlaufen lässt, sodass das Modell nie blockiert und nie pollt — was Turns einspart, und Turns sind das, was du tatsächlich bezahlst.

Der Mechanismus, präzise​

So sieht ein normaler synchroner Agenten-Turn aus:

  1. Das Modell gibt einen Tool-Call aus.
  2. Das Harness führt das Tool aus. Die Schleife ist angehalten.
  3. Das Tool kehrt zurück. Das Harness hängt das Ergebnis an.
  4. Das Harness ruft das Modell erneut mit dem vollständigen Transkript auf.

Und jetzt derselbe Turn in Unreal Agent:

  1. Das Modell gibt einen Tool-Call aus.
  2. Das Harness hängt unmittelbar ein Event an das Session-Log, das besagt, dass der Call in progress ist, und startet die Ausführung im Hintergrund.
  3. Die Ausführung läuft weiter. Das Modell kann frei weitere Calls ausgeben.
  4. Wenn das Tool fertig ist, wird sein Ergebnis an das Log angehängt — und dieses Anhängen ist es, was den nächsten Modellaufruf auslöst.

Das Modell sieht den laufenden Zustand und dann das Endergebnis, in dieser Reihenfolge, in seinem eigenen Transkript. Es muss nie „warte darauf" kodieren, gibt nie einen Poll aus, trägt nie Heartbeat-Buchhaltung in seinem Reasoning mit. Die Formulierung von Unreal Labs: Das Harness erlaubt es dem Modell, „mehr schwere Tool-Calls pro Modell-Turn auszugeben, ohne Token mit Polling oder Warten darauf zu verschwenden."

Das ist die ganze Idee. Sie ist klein. Sie ist auch der Teil, den die meisten Harnesses falsch machen, denn eine synchrone Schleife ist das Naheliegende, was man schreibt.

Warum sich das als Geld zeigt​

Jeder Modell-Turn sendet das angesammelte Transkript erneut. Ein Agentenlauf mit 30 Turns kostet nicht das 30-Fache eines einzelnen Aufrufs — er kostet ungefähr die Summe eines wachsenden Kontexts über 30 Aufrufe hinweg. Die Anzahl der Turns ist damit näher an einem quadratischen als an einem linearen Kostentreiber, und sie dominiert alles, was du durch das Kürzen des System-Prompts einsparst.

Schau dir an, was die veröffentlichten Läufe neben den Dollarbeträgen berichten:

BenchmarkPass-RateUnreal AgentTurnsCodexPiPi-Turns
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% vollständiger Pass$217————

Bei Terminal-Bench 4.0 lautet der Vergleich 28 Turns gegenüber Pis 44 — eine Reduktion der Turns um 36 % bei einer Kostenreduktion von 22 % gegenüber Pi und 39 % gegenüber Codex. Die Turn-Spalte ist die kausale; die Dollar-Spalte ist die Folge.

Das ist dieselbe Lektion, die AILmanac aus der anderen Richtung in Warum Agenten Token verbrennen behandelt: Das Teure an einem Agenten ist nicht die Antwort, es ist das Wiederlesen.

Pro tip
  • Instrumentiere die Anzahl der Turns, bevor du irgendetwas anderes instrumentierst. Wenn du nur Token loggst, optimierst du Prompts und übersiehst die Schleife.
  • Eine nützliche Diagnose: Zähle, wie viele Turns deines Agenten keinen Tool-Call und keine für Nutzer sichtbare Ausgabe erzeugt haben. Das ist reiner Schleifen-Overhead — Warten, Prüfen, Neuplanen — und genau das entfernt ein asynchrones Harness.
  • Parallelfähige Tools verstärken den Effekt. Wenn deine drei langsamsten Tools gleichzeitig laufen können, zahlt eine synchrone Schleife für alle drei seriell — in der Wanduhrzeit UND in Turns.

Drei Dinge, die sie bewusst nicht gebaut haben​

Die Begründung zählt mehr als der Code, denn das sind Argumente, die du auf jedes Harness anwenden kannst, das du bereits betreibst.

1. Keine Sub-Agenten, keine Workflows​

Unreal Labs entschied sich für „ein geradliniges asynchrones Tool-Calling-Modell" statt für Sub-Agenten-Delegation und vordefinierte Workflows. Die Begründung lautet, dass, sobald Tool-Calls wirklich asynchron sind, das meiste, wofür Sub-Agenten gedacht waren — Dinge parallel laufen zu lassen, ohne den Parent anzuhalten — bereits von der Schleife erledigt wird. Sub-Agenten fügen dann Kontextaufspaltung, Ergebniszusammenführung und ihren eigenen Turn-Overhead für ein Problem hinzu, das du nicht mehr hast.

Das ist eine echte Position, nicht die einzige. Multi-Agenten-Designs gewinnen weiterhin dort, wo du wirklich isolierten Kontext willst und nicht bloß Parallelität. Aber „wir brauchen Sub-Agenten, um zwei Dinge gleichzeitig zu tun" ist eine Behauptung, die es wert ist, zuerst gegen eine asynchrone Schleife neu geprüft zu werden.

2. Keine Security-Hooks auf Harness-Ebene​

Das ist das schärfste Argument im Launch-Post, und es ist wert, seine Form zu zitieren: Sicherheit und Freigaben, die auf Harness-Hooks beruhen, „erfordern tendenziell mehr Pflege und sind weniger robust als deterministische Umgebungs- oder Sandbox-Beschränkungen außerhalb des Harness".

Was sie stattdessen empfehlen: erlaubte und verbotene Hosts, granulare Zugriffstoken und Proxys mit Freigabe-Gates. Anders gesagt: Platziere die Kontrolle dort, wo der Agent physisch nicht hinkommt.

Die Logik ist einleuchtend, sobald man sie ausspricht. Ein Harness-Hook ist Code, der im selben Prozess wie die Agentenschleife läuft und ein Tool gated, das der Agent bereits aufrufen kann. Eine Sandbox-Grenze wird vom Kernel oder vom Netzwerk erzwungen, unterhalb des Agenten insgesamt. Wenn dein Agent ein bash-Tool hat — und das von Unreal Agent hat eins — ist eine In-Process-Allowlist eine Bodenschwelle, keine Mauer. AILmanacs Lokale und hybride Agenten absichern behandelt, wie man die äußere Grenze baut.

3. Kein Agent-SDK eines Anbieters​

Unreal Labs hat sich von Anbieter-SDKs abgewandt (Anthropics Agent SDK wird genannt), weil diese „lokale Sessions, Subprozesse und Ressourcenlimits annehmen, die sich nicht sauber in den Produktionseinsatz übertragen lassen".

Das ist ein Argument über die Deployment-Form, kein Qualitätsargument. Ein SDK, das einer lokalen CLI-Session nachempfunden ist, nimmt einen Prozess, eine Maschine, eine Lebensdauer an. Eine Produktionsflotte von Agenten will Sessions, die einen Prozess überleben und auf einer anderen Maschine fortgesetzt werden können — genau das, was der Append-only-, versionierte Session-Store von Unreal Agent bereitstellt, einschließlich des Forkens einer Session, um einen Lauf zu verzweigen.

Wenn du ein Produkt auf einer Agentenschleife aufbaust, ist das die Frage, die du jedem SDK stellen solltest: Kann eine Session den Prozess überleben, der sie erzeugt hat?

Die Architektur, kurz​

Das Harness ist bewusst klein und explizit komponierbar — acht austauschbare Komponenten hinter dokumentierten Interfaces:

  • Session-Inbox — dedupliziert Eingaben. Jede Eingabe trägt eine global eindeutige, stabile Caller-ID, sodass Retries nicht doppelt angewendet werden.
  • Coordinator — besitzt die LLM-Turns und verteilt Operationen.
  • Session-Store — Append-only persistierte Historie, unterstützt Forking, versioniert.
  • Context-Builder — setzt die Modelleingabe zusammen. Führt kein I/O aus.
  • LLM-Adapter — spricht mit dem Anbieter.
  • Tool-Registry und Translators — validieren Calls synchron und dürfen „kein I/O ausführen und die Schleife nicht anhalten".
  • Operation-Manager — führt die dauerhafte Hintergrundarbeit aus.

Zwei Einschränkungen in dieser Liste tragen die Hauptlast und sind leicht zu überlesen: Context-Builder und Tool-Translators ist I/O untersagt. Genau das hält den Hot Path des Coordinators deterministisch und nicht-blockierend — alle Latenz wird in Operationen geschoben, und die sind genau die Dinge, die für Asynchronität gebaut sind. Wenn du dein eigenes Harness baust, ist das die Regel, die man klauen sollte.

Speicherformate und Operationen sind versioniert, und eine nicht unterstützte Session-Version wirft beim Resume explizit einen Fehler, statt halb zu laden. Das ist der richtige Fehlermodus für dauerhaften Zustand, und er ist seltener, als er sein sollte.

Die eingebaute Tool-Oberfläche besteht aus drei Tools: Bash, ViewImage und Skill-use — letzteres greift auf das portable Skill-Format zu, das AILmanac in SKILL.md als offener Standard behandelt. Drei Tools sind der Punkt: Eine kleine, token-günstige Tool-Oberfläche ist Teil der Kostengeschichte.

Es betreiben​

Guided walkthrough1 of 5
  1. Go-1.27+-Toolchain, dann den Runner per go install aus dem cmd/-Pfad holen, oder klonen und das mitgelieferte Makefile nutzen (make build, make test).

Installieren und ausführen (aus der dokumentierten Nutzung von 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.'

Auf einen anderen Anbieter richten und das Transkript behalten

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

Die Benchmark-Tabelle ehrlich lesen​

Vier Vorbehalte, denn die Zahlen sind gut genug, um genaue Prüfung zu verdienen:

  • Jeder Lauf ist der des Anbieters selbst. Zum Zeitpunkt des Schreibens hatte sie kein Dritter repliziert.
  • Ein Modell. Alle veröffentlichten Läufe nutzten GPT-6 Astra bei xhigh Reasoning. Der Async-Vorteil sollte generalisieren — es ist eine Eigenschaft der Schleife, keine des Modells —, aber „sollte" ist nicht „wurde gemessen".
  • Die Dollarbeträge sind Gesamtsummen ganzer Suiten, keine Kosten pro Aufgabe. Sie sind untereinander vergleichbar und nicht mit deinem Workload.
  • Die Pass-Raten sind gleichgezogen, nicht verbessert. Die Behauptung lautet ausdrücklich gleicher Wert, weniger Geld. Bei DeepSWE 1.1 berichtet Unreal Agent 72,4 % zu 1.367 $ gegen Codex' 1.633 $ — eine Einsparung von 19 %, deutlich kleiner als die 39 % bei Terminal-Bench. Der Vorteil skaliert damit, wie tool-lastig und wie langlaufend deine Aufgaben sind. Bei kurzen Aufgaben mit wenigen Tool-Calls erwarte nahezu nichts.

Dieser letzte Punkt ist der praktische. Wenn dein Agent drei Tool-Calls macht und fertig ist, bringt dir Async fast nichts. Wenn er sechzig über eine halbe Stunde macht, bringt er dir die Differenz zwischen den beiden Spalten.

Was sich auf deinen eigenen Agenten überträgt​

Du musst Unreal Agent nicht übernehmen, um irgendetwas davon zu nutzen:

  • Miss die Turns. Es ist die Kostenvariable, die die meisten Teams nicht loggen.
  • Mach langsame Tools nicht-blockierend, selbst wenn dein Harness ansonsten synchron ist. Sofort einen Handle zurückzugeben und das Ergebnis später als Event zu liefern, ist eine Änderung, die du in den meisten Schleifen vornehmen kannst.
  • Halte den Hot Path I/O-frei. Kontextzusammenbau und Tool-Call-Validierung sollten nie auf das Netzwerk warten.
  • Verlagere Freigaben aus dem Prozess heraus. Netzwerkrichtlinien, gescopte Credentials und ein Gating-Proxy schlagen eine In-Process-Allowlist, die neben einem bash-Tool wohnt.
  • Schrumpfe die Tool-Oberfläche. Drei gute Tools kosten pro Turn weniger Token als fünfzehn mittelmäßige — und das in jedem einzelnen Turn.

Check yourself

0/5
  1. Was passiert in Unreal Agent in dem Moment, in dem das Modell einen Tool-Call ausgibt?
  2. Warum spart das Senken der Turn-Anzahl in einer Agentenschleife mehr Geld als das Kürzen der Ausgabelänge?
  3. Warum argumentiert Unreal Labs gegen die Umsetzung von Freigaben als Harness-Hooks?
  4. Dem Context-Builder und den Tool-Translators ist I/O untersagt. Was bringt diese Einschränkung?
  5. Bei welcher Art von Workload solltest du den kleinsten Async-Vorteil erwarten?
Drücke Enter oder die Leertaste, um die Karte umzudrehen. Nutze die Pfeiltasten links und rechts, um zwischen den Karten zu wechseln.Begriff angezeigt.
1 / 8
Key takeaways
  • Die Anzahl der Turns, nicht die Anzahl der Token, ist die Kostenvariable in einer Agentenschleife. Instrumentiere sie zuerst.
  • Tool-Calls nicht-blockierend zu machen, entfernt Polling- und Warte-Turns — 28 Turns gegen 44 bei gleicher Pass-Rate auf Terminal-Bench 4.0 ist das ganze Argument.
  • Der Vorteil ist proportional zur Tool-Lastigkeit: 39 % bei Terminal-Bench, 19 % bei DeepSWE, ~0 bei einer Aufgabe mit drei Calls.
  • Sicherheit gehört außerhalb des Harness. Ein In-Process-Freigabe-Hook neben einem bash-Tool ist eine Bodenschwelle; eine Sandbox und ein Gating-Proxy sind eine Grenze.
  • Halte Kontextzusammenbau und Tool-Validierung I/O-frei. Schiebe jedes Warten in eine dauerhafte Operation.
  • Alle veröffentlichten Zahlen sind Anbieterläufe auf einem Modell. Behandle sie als gut begründete Hypothese über deinen Workload, nicht als Messung davon.

Quellen & weiterführende Literatur​

Weiter​