Neuer Ansatz für Code in Agentensystemen: Die Rolle von Code als Agenten-Harness

Die künstliche Intelligenz (KI) entwickelt sich rasant weiter, und mit ihr verändern sich auch die Paradigmen, wie wir über Softwareentwicklung und Agentensysteme denken. Ein zentrales Konzept, das in jüngster Zeit an Bedeutung gewonnen hat, ist das des „Code as Agent Harness“. Dieses Konzept beschreibt einen tiefgreifenden Wandel in der Rolle von Code innerhalb von Agentensystemen. Code ist nicht mehr nur das finale Produkt, das von einem Modell generiert wird, sondern dient als grundlegendes Betriebssystem, das die Argumentation, das Handeln, die Umgebungsmodellierung und die ausführungsbasierte Verifizierung von KI-Agenten ermöglicht. Diese Neuinterpretation des Codes als „Harness“ – im Sinne eines Steuerungsrahmens oder Geschirrs – ist entscheidend für den Aufbau ausführbarer, überprüfbarer und zustandsbehafteter KI-Agentensysteme.

Die Harness-Schnittstelle: Code für Argumentation, Aktion und Umgebungsmodellierung

Die Kernidee des „Code as Agent Harness“ manifestiert sich in drei fundamentalen Rollen, die Code in Agentensystemen übernimmt:

Code für die Argumentation

Die Transformation der Modellargumentation von einer flüchtigen Textgenerierung in eine ausführbare und überprüfbare Berechnung ist eine zentrale Aufgabe des Agenten-Harness. Während frühe Prompting-Techniken wie Chain-of-Thought (CoT) die Argumentation vollständig in natürlicher Sprache durchführten, was Modelle anfällig für Fehler in symbolischen oder arithmetischen Berechnungen machte, ermöglicht Code-basierte Argumentation eine externe Überprüfung. Modelle generieren ausführbare Programme, die von externen Laufzeiten, Interpretern oder symbolischen Lösern bewertet werden können. Dies trennt die hochstufige Argumentation von der niederstufigen Berechnung, wodurch Zwischenzustände inspizierbar und der Fortschritt über Schritte hinweg persistent wird.

• Programm-delegierte Argumentation: Hier dient Code als primäre Schnittstelle zwischen Problemzerlegung und Berechnung. Statt sich nur auf natürliche Sprachargumentation zu verlassen, generiert das Modell Code, der von externen Interpretern ausgeführt wird, um formal fundierte Ergebnisse zu liefern. Dies erhöht die Zuverlässigkeit erheblich, indem Zwischenschritte in strukturierte, überprüfbare Ausführungsspuren überführt werden.
• Formale Verifikation und symbolische Argumentationsschnittstellen: Hybride neuronal-symbolische Methoden kombinieren flexible sprachbasierte Inferenz mit strukturierter symbolischer Berechnung, wobei Code als persistente Zwischenrepräsentation dient. Iterative Verifikationsschleifen und die Verwendung maschinenüberprüfbarer formaler Sprachen (wie in Beweisassistenten) ermöglichen es, jeden Ableitungsschritt rigoros zu überprüfen und Agentenverhalten zu zertifizieren.
• Iterative Code-gestützte Argumentation: Dieser Ansatz konzentriert sich auf die geschlossene Schleife zwischen Generierung, Ausführung und Feedback. Argumentation ist hier kein einmaliger Prozess, sondern eine iterative Berechnungstrajektorie, die in ausführbaren Zustandsübergängen verankert ist. Reinforcement Learning und die Integration von Ausführungssignalen während der Generierung ermöglichen eine kontinuierliche Anpassung und Korrektur.

Code für die Aktion

Über die Argumentation hinaus muss der Agent auch mit externen Umgebungen verbunden werden, in denen Entscheidungen zu realen, ausführbaren Effekten führen. Code dient hier als Aktionsschnittstelle, die Modellausgaben in konkrete Operationen wie Tool-Aufrufe, Robotersteuerungsrichtlinien oder GUI-Aktionen umwandelt. Die zentrale Herausforderung liegt in der Verankerung: Abstrakte Sprachausgaben müssen in ausführbare Verhaltensweisen übersetzt werden, die den Beschränkungen der Zielumgebung entsprechen.

• Grundierte Skill-Auswahl: Der Agent ordnet hochstufige Sprachabsichten ausführbaren Verhaltensweisen durch wiederverwendbare Skill-Schnittstellen zu. Statt direkt niederstufige Aktionen zu generieren, behandelt der Harness die Umgebung als eine Sammlung ausführbarer Fähigkeiten, die der Agent unter Umgebungsbeschränkungen aufrufen, zusammensetzen und verfeinern kann.
• Programmatische Richtliniengenerierung: Hier wird Code selbst als Kontrollschnittstelle zwischen Modell und Umgebung behandelt. Anstatt aus vordefinierten Skills zu wählen, materialisiert der Harness ausführbare Richtlinien direkt als Programme, die Steuerungslogik, wahrnehmungsbedingte Verzweigungen und API-Interaktionen spezifizieren.
• Lebenslange Code-basierte Agenten: Diese untersuchen, wie ausführbare Interaktionsschnittstellen über lange Zeiträume hinweg bestehen, sich entwickeln und Fähigkeiten ansammeln können. Code ist hier nicht nur ein Ausführungsmechanismus, sondern auch ein persistentes Gedächtnissubstrat, über das der Harness wiederverwendbare Verhaltensweisen, Interaktionsspuren und Umgebungswissen speichert.

Code für die Umgebung

Ein Agent muss auch eine explizite Repräsentation der Umgebung pflegen, mit der er interagiert. Ohne eine solche Repräsentation bleibt der Umgebungszustand implizit, transient und schwer überprüfbar. Code-for-Environment löst diese Einschränkung, indem es ausführbare Programme als Schnittstelle zur Umgebung selbst einführt. Statt die Umgebung als einen undurchsichtigen externen Prozess zu behandeln, materialisieren diese Systeme die Umgebungsstruktur und -dynamik durch rechnerische Artefakte wie Simulatoren, Repositories, Tests und Ausführungsspuren.

• Strukturierte Weltrepräsentationen: Umgebungen werden durch explizite programmatische Strukturen modelliert, die der Agent ausführen, inspizieren und manipulieren kann. Weltzustand, Objektbeziehungen und Interaktionsdynamiken werden als strukturierte rechnerische Artefakte kodiert.
• Ausführungs-Spur-Weltmodellierung: Hier lernt der Agent Umgebungsdynamiken direkt aus ausführbaren Interaktionsspuren. Laufzeitübergänge selbst werden als primäre Repräsentation des Umgebungsverhaltens modelliert.
• Code-gestützte Bewertungsumgebungen: Ausführbare Systeme dienen als Schnittstelle zur Messung von Agentenverhalten und Interaktionsqualität. Diese Umgebungen legen explizite Laufzeit-Zustandsübergänge, Ausführungsfeedback und überprüfbare Interaktionsergebnisse offen, die der Agent direkt beobachten und bewerten kann.
• Verifizierbare Umgebungs-Konstruktion: Hier werden ausführbare Umgebungen nicht nur als Benchmarks zur Bewertung von Agenten behandelt, sondern als Harness-Artefakte, die programmatisch synthetisiert, skaliert und validiert werden können.

Harness-Mechanismen: Planung, Gedächtnis, Werkzeugnutzung, Kontrolle und Optimierung

Harness-Mechanismen bilden die zentrale Systemschicht, die Code-Agenten über einen einzelnen Generierungsschritt hinaus zuverlässig macht. Sie sind keine isolierten Zusatzmodule, sondern koordinierte Kontrollflächen, die Modellentscheidungen in begrenzte, beobachtbare und revidierbare Änderungen in einer ausführbaren Umgebung umwandeln.

Planung für Agenten-Harness

Planung ist entscheidend, da reale Software-Engineering-Aufgaben selten eine direkte, einmalige Abbildung von natürlicher Sprachabsicht zu korrekter Implementierung zulassen. Aus der Harness-Perspektive ist Planung nicht nur eine interne Argumentationsfähigkeit des LLM, sondern eine Form der Harness-Kontrolle: Sie strukturiert, wie der Agent seine Absicht in ausführbare Schritte externalisiert und Interaktionen mit Code-Artefakten und Werkzeugen plant.

• Lineare Zerlegungsplanung: Der Agent erstellt eine explizite, ausführbare Abfolge von Schritten und führt die Generierung dann gemäß dieser Zerlegung aus. Dies kann durch die Serialisierung von Gedanken, Aktionen und Beobachtungen in einer Trajektorie geschehen.
• Struktur-gestützte Planung: Die Planung basiert auf einer expliziten strukturierten Darstellung der Aufgabenumgebung, wie Abhängigkeitsgraphen oder Wissensgraphen. Diese Strukturen dienen als natürliche Harness-Gerüste, die relevante Entitäten offenlegen und die Reihenfolge der Unteraufgaben steuern.
• Suchbasierte Planung: Hierbei wird Rechenzeit für die systematische Erkundung, Bewertung und Auswahl mehrerer Kandidatenlösungspfade aufgewendet. Es wird der Entscheidungsraum erweitert und Feedback genutzt, um zu steuern, welche Alternativen verfolgt, überarbeitet oder verworfen werden sollen.
• Orchestrierungsbasierte Planung: Die Kernplanungsfunktion wird durch ein Harness-Design für systemweite Koordination realisiert. Der Harness steuert, wie Agenten oder Module Rollen spezialisieren, Phasen ausführen und Feedback-Schleifen auslösen.

Gedächtnis- und Kontext-Engineering für Agenten-Harness

Gedächtnis ist eine Kerninfrastruktur für Code-Agenten, da reale Software-Engineering-Aufgaben naturgemäß langwierig und zustandsintensiv sind. Aus Harness-Perspektive ist Gedächtnis eine Zustandsverwaltungsschicht, die entscheidet, welche Informationen im aktiven Modellkontext verbleiben, welche in Zusammenfassungen komprimiert und welche in dauerhaften externen Speicher ausgelagert werden sollten.

• Arbeitsspeicher: Unterstützt die Zustandsverwaltung entlang der aktuellen Code-Aufgaben-Trajektorie, oft in Form von strukturierten Prompt-Bereichen, Zustandszusammenfassungen oder Testfehlerprotokollen.
• Semantisches Gedächtnis: Bietet aufgabenrelevante externe Nachweise für den aktuellen Codierungsprozess, typischerweise Repository-spezifisch und programmstrukturiert.
• Erfahrungsspeicher: Erfasst wiederverwendbare Erfahrungen, die über Aufgaben hinweg gesammelt wurden, wie Fehlerfälle oder Debugging-Aufzeichnungen.
• Langzeitgedächtnis: Verwaltet das Wachstum des Gedächtnisses, die Verzerrung durch Komprimierung und die langfristige Drift, wobei der Fokus von der Gedächtniskapazität auf die Gedächtnisverwaltung verlagert wird.
• Multi-Agenten-Gedächtnis: Erweitert die Zustandsverwaltung von einem einzelnen Agenten auf ein gemeinsames Harness, um Informationsaustausch und Konsistenz über spezialisierte Rollen hinweg zu unterstützen.
• Kontext-Kompaktierung und Zustandsauslagerung: Kontrolliert die Grenze zwischen aktivem Modellkontext und dauerhaftem Aufgabenstatus, um die Skalierbarkeit und Überprüfbarkeit des Gedächtnisses zu verbessern.

Werkzeugnutzung für Agenten-Harness

Werkzeugnutzung ist die Aktions- und Beobachtungsschicht des Code-Agenten-Harness. Tools erweitern den Aktionsraum des Agenten und legen externe Feedbacksignale offen, die den Harness ausführbar und inspizierbar machen. Es ist eine gesteuerte Schnittstelle zwischen Modellabsicht und externen Systemen.

• Funktionsorientierte Werkzeugnutzung: Werkzeuge werden hauptsächlich verwendet, um Lücken im Programmierwissen des Modells zu füllen, insbesondere APIs, Bibliotheken und Dokumentationen.
• Umgebungsinteraktions-Werkzeugnutzung: Werkzeuge dienen als Schnittstelle, über die ein Agent innerhalb der Software-Engineering-Umgebung agiert, indem er Repositories, Entwicklungsobjekte und Ausführungsumgebungen bedient.
• Verifikationsgesteuerte Werkzeugnutzung: Werkzeuge werden hauptsächlich für die Post-Generierungs-Verifikation und iterative Verbesserung eingesetzt, wobei Tests, Ausführungsergebnisse und Compilerfehler als deterministische Sensoren dienen.
• Workflow-Orchestrierungs-Werkzeugnutzung: Hierbei wird der Fokus darauf gelegt, wie mehrere Werkzeuge, Rollen und Kontrollrichtlinien zu einem kohärenten Agenten-Workflow organisiert werden.

Harness-Kontrolle durch die Plan-Ausführen-Verifizieren (PEV)-Schleife

Code-as-Harness-Systeme erfordern eine Kontrollschleife, die Modellabsichten in begrenzte, beobachtbare und revidierbare Zustandsübergänge umwandelt. Diese Schleife wird als Plan-Ausführen-Verifizieren (PEV) bezeichnet, die Planung, Ausführung, Debugging, Verifizierung und Eskalation als Teile eines einzigen Kontrollprozesses auf Harness-Ebene vereint.

• Vom Debugging zur Kontrolle auf Harness-Ebene: Debugging wird als Kontrolle über den ausführbaren Programmzustand verstanden. Die PEV-Schleife externalisiert eine beabsichtigte Trajektorie, führt begrenzte Aktionen in einer kontrollierten Umgebung aus und verifiziert den resultierenden Zustand vor dem nächsten Übergang.
• Planung als Vertragsbildung: Die Planungsphase wandelt eine Benutzeranfrage in einen expliziten Vertrag über den nächsten Zustandsübergang um, der relevante Dateien, erwartete Invarianten und Verifikationskriterien festlegt.
• Sandboxed-Ausführung und Berechtigungs-Zustandsübergang: Die Ausführungsphase realisiert den Plan als begrenzten und beobachtbaren Zustandsübergang in einer sandboxed Umgebung, die isolierte Dateisysteme und Ressourcen bereitstellt.
• Verifizierung durch deterministische Sensoren: Die Verifizierungsphase schliesst die Schleife, indem sie den neuen Zustand mit expliziten Beschränkungen vergleicht. Compiler- und statische Analyse-Feedbacks sowie Test-basierte Rückmeldungen dienen als deterministische Sensoren.

Agentic Harness Engineering für adaptive Harness-Optimierung

Agentic Harness Engineering (AHE) ist ein Designproblem auf Harness-Ebene, das sich mit der Messung und Überarbeitung des Software-Substrats befasst, das ein Sprachmodell in einen Codierungsagenten verwandelt. Es behandelt die Betriebsumgebung selbst als Analyseobjekt, um die Zuverlässigkeit und Anpassungsfähigkeit des Harness zu verbessern.

• Tiefe Telemetrie als Optimierungssubstrat: Tiefe Telemetrie ist das zentrale Substrat von AHE und liefert strukturierte Spuren, die Modellentscheidungen, Harness-Aktionen, Umgebungszustände und Ergebnisse miteinander verbinden.
• Der Evolutionsagent: Ein Evolutionsagent ist ein Meta-Level-Agent, der tiefe Telemetrie nutzt, um Überarbeitungen von Harness-Komponenten vorzuschlagen, zu bewerten und zu fördern.
• Gesteuerte Harness-Mutation: Harness-Mutationen sollten wie Code-Änderungen an einer sicherheitskritischen Laufzeit behandelt werden, wobei jede vorgeschlagene Änderung einen Änderungsvertrag mit sich führen sollte, der die modifizierte Komponente, den Ziel-Fehlermodus und die erwartete Verbesserung beschreibt.

Skalierung des Harness: Multi-Agenten-Orchestrierung über Code

Wenn KI-Systeme immer komplexere Probleme bewältigen, stossen einzelne Agenten an fundamentale Grenzen. Multi-Agenten-Systeme (MAS) bieten hier eine Lösung, indem sie Verantwortlichkeiten auf spezialisierte Rollen verteilen. Code wird dabei zum gemeinsamen Unterbau, durch den das gesamte Harness plant, agiert, verifiziert und sich selbst verbessert.

Verbesserte Codierungsunterstützung durch Multi-Agenten-Kollaboration

MAS verbessern die Codierungsunterstützung, indem sie das Harness in spezialisierte, aber koordinierte Komponenten zerlegen. Diese Arbeitsteilung macht das gesamte Harness leistungsfähiger für komplexe Softwareaufgaben und gleichzeitig seinen internen Workflow inspizierbarer und kontrollierbarer.

• Spezialisierung funktionaler Rollen und menschlich gesteuerte Planung: Verschiedene Agenten übernehmen spezifische Rollen wie Programm-Synthese, -Verständnis, -Verifikation, -Ausführung und -Planung. Dies ermöglicht eine effiziente Aufgabenverteilung.
• Diverse Interaktionsmodi, die auf gemeinsamem Programmzustand basieren: Im Gegensatz zu allgemeinen MAS, bei denen die Agenteninteraktion hauptsächlich auf Nachrichtenübermittlung basiert, ist die Code-zentrierte Interaktion durch artefaktvermittelte Kommunikation gekennzeichnet. Agenten beobachten und modifizieren gemeinsame Code-Artefakte.
• Optimierte Workflow-Topologie für Agenten-Koordination: Die Topologie der Agenteninteraktion – wer mit wem, in welcher Reihenfolge und wie oft kommuniziert – ist eine der wichtigsten Designentscheidungen in einem MAS für die Code-Generierung.

Ausführungs-Feedback und Shared-Harness-Synchronisierung

Die Ausführbarkeit von Code und die Fähigkeit, einen konsistenten, gemeinsamen Blick auf den Programmzustand zu bewahren, sind definierend für Code-zentrierte MAS. Dies beinhaltet die Integration von Ausführungsfeedback und die Synchronisierung des gemeinsamen Zustands.

• Integration von Ausführungsfeedback: Verschiedene Arten von Feedback wie Compiler- und Syntax-Feedback, Test-Pass/Fail-Signale, Fuzzer-Crash-Traces, statische Analysewarnungen und Performance-Profiling-Ergebnisse werden genutzt, um die Codequalität zu verbessern.
• Shared-Harness-Synchronisierung: Mechanismen wie Shared Blackboards, parallele Branches mit Merges, strukturierte Kontextplanung und hierarchische Speicher werden eingesetzt, um einen konsistenten gemeinsamen Programmzustand über Agenten hinweg zu gewährleisten.

Position: Das gemeinsame Code-zentrierte Harness-Substrat

Ein zentraler Aspekt der nächsten Generation von Multi-Agenten-Intelligenz ist das gemeinsame Code-zentrierte Harness-Substrat. Dies ist notwendig, um robuste und skalierbare Multi-Agenten-Intelligenz zu erreichen.

• Gemeinsame Harness-Repräsentation: Der gemeinsame Programmzustand kann auf verschiedenen Formalisierungsstufen dargestellt werden, von impliziten/dateibasierten Repräsentationen bis hin zu Repository-basierten, ausführungsbasierten und Blackboard-/Shared-State-Repräsentationen.
• Harness-State-Konvergenz: Die Konvergenz bestimmt, wann ein Multi-Agenten-Codierungs-Harness die Iteration beenden und seinen aktuellen Programmzustand als zufriedenstellendes Ergebnis akzeptieren sollte, basierend auf objektiven Verhaltenssignalen.

Emerging Fields und Open Problems

Code-as-Harness-Systeme verlagern die zentrale Herausforderung der agentischen KI von isolierter Modellgenerierung hin zur Zuverlässigkeit der gesamten Ausführungsschleife. Wenn Agenten über Werkzeuge, Speicher, Code-Ausführung, gemeinsamen Zustand und Umgebungsfeedback agieren, können Fehler durch schwache Verifizierer, veralteten Kontext oder unsicheren Werkzeugzugriff entstehen. Diese Probleme lassen sich nicht allein durch den Erfolg der Endaufgabe diagnostizieren.

Emerging Fields und Tangible Applications

Fünf Anwendungsbereiche, in denen Code-as-Harness-Systeme besonders sichtbar geworden sind:

• Code-Assistenten: Moderne Code-Assistenten agieren über Repository-weite Workflows und sind in Entwicklungsumgebungen eingebettet, die Repository-Zustand, Werkzeuge, Validierungsroutinen und Kollaborations-Workflows bereitstellen.
• GUI/OS-Agenten als Programmwelt: Grafische Benutzeroberflächen und Betriebssysteme sind eine Programmwelt im wörtlichsten Sinne, wobei jede Beobachtung und Aktion des Agenten Code ist. Code dient hier als Brücke zwischen Benutzeroberflächen und GUI-Agenten, wobei Speicher als persistenter programmatischer Zustand und Simulatoren als ausführbare Dynamik dienen.
• Autonome verkörperte Agenten: Diese agieren in der physischen Welt oder deren Simulation, wobei Code als Kontrollgrenze dient, die Agenten und die Welt verbindet. Eine geschichtete Harness trennt semantische Argumentation von ausführbaren, physikalisch geerdeten Aktionen.
• Agenten für die wissenschaftliche Entdeckung als Programmwelten: Wissenschaftliche Forschung ist ein ideales Testfeld für Code als Agenten-Harness, da die wissenschaftliche Methode selbst eine geschlossene Schleife ist, die durch Programme vermittelt wird. Code ist das Medium der Argumentation, das Substrat des Handelns und die ausführbare Umgebung selbst.
• Agenten-Personalisierung: Hier ist die Umgebung nicht nur ein Softwaresystem, sondern auch ein menschlicher Benutzer, dessen Absicht, Zufriedenheit und langfristige Ziele nur teilweise beobachtet werden. Code ist nützlich, da er ein inspizierbares Substrat für die Präferenzrepräsentation, Feedback-Verarbeitung und Richtlinienanpassung bietet.

Open Problems

• Harness-Level-Evaluierung und Orakel-Angemessenheit: Die Bewertung wird schwierig, wenn ein LLM in einen Code-Agenten-Harness eingebettet ist, da die Leistung nicht allein vom Basismodell abhängt, sondern auch von der umgebenden Laufzeit.
• Semantische Verifizierung jenseits von ausführbarem Feedback: Die Orakel-Angemessenheit wird besonders herausfordernd, da Ausführungsfeedback ein falsches Gefühl von Korrektheit erzeugen kann. Eine zentrale fehlende Abstraktion ist ein Verifikationsstack mit explizitem Umfang.
• Selbstentwickelnde Harnesses ohne Regression: Die meisten aktuellen Harnesses sind manuell entworfen. Zukünftige Systeme sollten den Harness selbst als programmierbare Komponente behandeln, die sich an neue Umgebungen anpassen kann.
• Transaktionaler gemeinsamer Programmzustand und semantische Konfliktlösung: Die Skalierung von einzelnen Agenten zu Multi-Agenten-Systemen verwandelt die Codebasis in ein gemeinsames Harness-Substrat. Das offene Problem ist, dass die Synchronisierung allein keine transaktionalen Semantiken oder Konsistenz auf Annahmeebene bietet.
• Human-in-the-Loop-Sicherheit und Verantwortlichkeit als Harness-Zustand: In kritischen Bereichen kann Sicherheit nicht an das Basismodell delegiert oder nur als natürliche Sprachinstruktion kodiert werden. Ein Harness muss als Sicherheitsgovernor zwischen Modellabsicht und realer Konsequenz fungieren.
• Multimodale Code-Harness-Systeme: Die meisten Code-Agenten-Harnesses sind immer noch um textuellen Zustand herum konzipiert. Viele aufkommende agentische Systeme agieren jedoch in Umgebungen, in denen der kritische Zustand multimodal ist.
• Hin zu einer Wissenschaft des Harness-Engineerings: Diese offenen Probleme deuten darauf hin, dass die Code-as-Harness-Forschung sich zu einer breiteren Wissenschaft des Harness-Engineerings entwickelt.

Zusammenfassend lässt sich sagen, dass die Evolution von „Code as Agent Harness“ eine grundlegende Verschiebung darstellt: Code ist nicht mehr nur ein zu erzeugendes Produkt, sondern das lebendige, ausführbare Medium, durch das Agenten agieren, sich anpassen und kooperieren. Dies erfordert eine ganzheitliche Betrachtung von Agentensystemen, die über die reine Modellintelligenz hinausgeht und die Zuverlässigkeit, Überprüfbarkeit und Governance des gesamten Agenten-Harness in den Mittelpunkt rückt.

Referenzen

• [2605.18747] Code as Agent Harness - arXiv. (2026, 18. Mai). Abgerufen von https://arxiv.org/abs/2605.18747
• AutoHarness: improving LLM agents by automatically synthesizing a code harness. (n.d.). Abgerufen von https://arxiv.org/abs/2603.03329v1
• Code as Agent Harness ◆ Toward Executable, Verifiable, and Stateful Agent Systems ◆. (n.d.). Abgerufen von https://arxiv.org/html/2605.18747v1
• Code as agent harness. (n.d.). Abgerufen von https://deeplearn.org/arxiv/755650/code-as-agent-harness
• The Anatomy of an Agent Harness - LangChain. (2026, 11. März). Abgerufen von https://www.langchain.com/blog/the-anatomy-of-an-agent-harness
• Agentic Harness Engineering: Observability-Driven Automatic Evolution of Coding-Agent Harnesses. (n.d.). Abgerufen von https://arxiv.org/pdf/2604.25850
• Harness engineering for coding agent users - Martin Fowler. (n.d.). Abgerufen von https://martinfowler.com/articles/harness-engineering.html
• Harnesses Explained: The Inner and Outer Workings of the Coding Agent Harness. (2026, 24. April). Abgerufen von https://codagent.beehiiv.com/p/harnesses-explained
• Inženýrství harnessu: využití nástroje Codex ve světě agentů | OpenAI. (n.d.). Abgerufen von https://openai.com/cs-CZ/index/harness-engineering/
• Agent Harness: Initializer and Coding Agent Pattern - AgentPatterns.ai. (n.d.). Abgerufen von https://agentpatterns.ai/agent-design/agent-harness/