Das Ende des Prompt Engineerings ist da.

Du kennst das Muster bereits. Frag einen KI-Agenten, Variablen umzubenennen, einen Unit-Test zu schreiben oder eine Pull-Request zusammenzufassen, und es sieht brillant aus. Frag ihn, eine komplette Feature-Implementierung über Dutzende von Dateien, mehrere Dienste und eine Woche Iteration zu übernehmen, und es zerfällt leise in halb-fertige Branches, defekte Tests und halluzinierte APIs.

Entwickler versuchen es dennoch immer wieder. Sie starten „autonome“ Coding-Agenten, integrieren GitHub, Jira und einen Testlauf, und beobachten dann, wie das System bei zirkulären Refactorings ins Stocken gerät oder Anforderungen vergisst, die es vor 20 Minuten gesehen hat. Die Benchmarks sehen bei Spielaufgaben hervorragend aus, aber in realen Repositories übersehen die Agenten immer noch Randfälle, verschlechtern die Leistung oder überschreiten Sicherheitsvorgaben.

Deshalb ist Vibe Coding größtenteils ein Mythos geblieben. Die Fantasie sieht folgendermaßen aus: Beschreibe eine Funktion in wenigen Sätzen, weise dem Agenten dein Monorepo zu und kehre mit einem sauberen PR, grünem CI und bestandenen Integrationstests zurück. In der Praxis weichen Modelle vom Spezifikationen ab, verlieren den Überblick über langfristige Ziele und passen sich übermäßig an das letzte Kontextfenster an, mit dem du sie gefüllt hast.

Hinter den Kulissen hörte die Rohleistung von LLMs etwa im Jahr 2023 auf, sich im gleichen atemberaubenden Tempo zu vervielfachen. Größere Kontextfenster und bessere Eingabeaufforderungen halfen, aber sie beheben nie die grundlegenden Zuverlässigkeitsprobleme: eine brüchige Werkzeugnutzung, Kontextverfall und kein echtes Verständnis des projektbezogenen Zustands. Prompt-Engineering und Kontext-Engineering haben die Obergrenze verschoben; sie haben die Architektur nicht verändert.

Eine andere Schicht kommt leise zum Vorschein, um das zu beheben. Agent harnesses umhüllen Modelle mit expliziter Kontrolle über Gedächtnis, Werkzeuge und Unteragenten und verwandeln frei agierende Chatbots in Systeme, die tatsächlich einen Plan über Stunden oder Tage aufrechterhalten können. Projekte wie Anthropics langjähriger Harness, LangChains DeepAgent und Cole Medins Linear Agent Harness weisen alle in dieselbe Richtung.

Diese Serie geht der Veränderung auf den Grund: wie geschirrgestützte Architekturen es endlich ermöglichen, dass Agenten für ernsthafte Arbeiten vertrauenswürdig sind, wo sie weiterhin versagen und was nötig sein wird, damit echtes Vibe-Coding nicht länger eine Demo, sondern zum Standard wird.

Prompt-Engineering begann als die Volkwissenschaft, mit GPT-3 zu kommunizieren. Entwickler waren besessen von einzelnen Eingabeaufforderungen, optimierten Formulierungen, Beispielen und Ausgabeformaten, um bessere Antworten aus einer einzigen Interaktion mit 2.048 Token herauszuholen. Die Arbeitseinheit bestand aus einer Anfrage, einer Antwort, ohne Gedächtnis, ohne Plan.

Als GPT-3.5 und GPT-4 mit Chat und größeren Kontextfenstern auftauchten, brach diese Denkweise zusammen. Kontextoptimierung übernahm: Das Problem war nicht mehr „Was ist der perfekte Prompt?“, sondern „Was muss das Modell jetzt aus 100+ vorherigen Nachrichten und Megabyte von Dokumenten sehen?“ Teams kämpften gegen Kontextverfall, jonglierten mit System-Prompts, Zusammenfassungen und Abrufpipelines, nur um eine Sitzung kohärent zu halten.

Kontext-Engineering betrachtet eine KI-Sitzung wie ein sorgfältig kuratiertes Gespräch. Sie entscheiden, welche Spezifikationen, Codeschnipsel und Entscheidungen im Kontextfenster bleiben und welche in den Langzeit-Speicher verschoben werden. Werkzeuge wie Vektorsuche, hierarchische Zusammenfassungen und rollenbasierte Systemnachrichten sind zum Standard geworden, um ein einzelnes langes Gespräch zu verwalten.

Agent nutzt den Schub, um die Fortschritte auf die nächste Stufe zu heben. Anstatt einen einzelnen Anruf oder eine einzelne Sitzung zu optimieren, orchestriert ein Harness viele Sitzungen, oft über mehrere Agenten hinweg, um eine mehrstündige oder mehrtägige Aufgabe zu erfüllen. Denken Sie "dieses Feature vom Anfang bis zum Ende ausliefern", nicht " diese Funktion umstrukturieren".

Ein moderner Agent koordiniert mehrere bewegliche Teile gleichzeitig: - Mehrere LLM-Sitzungen mit unterschiedlichen Rollen - Gemeinsame und agentenspezifische Speichersysteme - Werkzeuge für Codeausführung, Tests und externe APIs - Checkpoints, Rücksetzungen und Menschliche Überprüfungsgates

Projekte wie Anthropics Effektive Harnesses für langlaufende Agenten, LangChain DeepAgents und Cole Medins Linear Agent-Harness folgen alle diesem Muster. Ein Agent plant, ein anderer schreibt Code, ein weiterer führt Tests durch, und das Harness verfolgt den Zustand über Dutzende oder Hunderte von Aufrufen hinweg. Die Arbeitseinheit wird zu einem Workflow-Diagramm, nicht zu einem Chat-Protokoll.

Entscheidend ist, dass dies Evolution und nicht Amnesie ist. Harnesses basieren weiterhin auf präziser Prompt-Entwicklung innerhalb jedes Aufrufs und disziplinierter Kontextgestaltung innerhalb jeder Sitzung. Sie behandeln diese Fähigkeiten einfach als niedrigstufige Primitives in einem größeren Programm, bei dem die eigentliche Herausforderung darin besteht, viele imperfekte Agenten zu einem einzigen, zuverlässigen System zu koordinieren.

Die rohe Modellkraft folgt nicht mehr dem Science-Fiction-Diagramm, das die Leute 2020 im Kopf hatten. Der Sprung von GPT-3 zu GPT-4 fühlte sich an wie der Übergang von „schöne Demo“ zu „das könnte ich bei der Arbeit verwenden“, aber GPT-4.1, 4.1-mini und Claude 3.5 Sonnet wirken eher wie inkrementelle Abwägungen in Bezug auf Latenz, Kosten und Zuverlässigkeit als eine neue IQ-Klasse maschineller Intelligenz.

Benchmarks unterstützen dies. Akademische Ranglisten haben begonnen, sich zu sättigen, und Anbieter wenden sich heimlich von der Prahlerei mit MMLU-Punkten ab und preisen stattdessen „Tokens pro Sekunde“ und „Anfragen pro Dollar“ an. Wir erhalten weiterhin bessere Modelle, aber die Kurve sieht eher linear als exponential aus.

KI-Forscher äußern zunehmend laut, was bisher unausgesprochen blieb: die Skalierungs-Ära weicht einer Architektur-Ära. Das Hinzufügen von 10-mal mehr GPUs zu einem Transformer bringt jedes Jahr weniger, daher verlagert sich das eigentliche Geschehen darauf, wie man Systeme um ein Modell herum strukturiert: Planungszyklen, Speicherschichten, Tool-Router, Evaluatoren und menschliche Kontrollpunkte im Prozess.

Dieser Wandel erklärt, warum Anthropic technische Tiefenanalysen wie Effektive Harnesses für langlaufende Agenten verfasst und warum OpenAI, Google und Meta alle „Agenten“ vorantreiben, nicht nur größere LLMs. Die Spitze der Technologie verlagert sich von einem einzigen intransparenten Modellaufruf zu orchestrierten Netzwerken von Aufrufen mit explizitem Zustand und Kontrolle.

Agent nutzt im Zentrum dieses neuen Architektur-Stacks. Sie übernehmen die unauffällige, aber entscheidende Aufgabe, eine Funktionsanfrage in Schritte zu unterteilen, Subagenten zu koordinieren, den Speicher zu verwalten und zu entscheiden, wann ein Mensch gefragt werden sollte, anstatt einen fiktiven Weg nach vorne zu erfinden.

Anstatt zu beten, dass GPT-5 magisch perfekte Pull-Requests erstellt, können Teams Vorrichtungen entwerfen, die:

• 1Setzen Sie Codierungsstandards und Testgate durch.
• 2Persistieren und Abrufen von projektspezifischem Kontext
• 3Aufgaben zwischen Planer-, Entwickler- und Prüfer-Agenten routen
• 4Schleifen, Regressionen und Spezifikationsdrift erkennen

Diese Steueroberfläche ist der Punkt, an dem Entwickler plötzlich wieder Einfluss haben. Man kann den Trainingslauf von OpenAI nicht ändern, aber man kann entscheiden, wie viele Agenten man erstellt, wie sie kommunizieren, welche Tools sie nutzen und wann sie aufhören und sich rechtfertigen müssen.

Agenten-Harnesse, nicht rohe Modellgewichte, werden zur primären Leinwand für Innovation. Der nächste „10-fache“ Sprung in der Leistungsfähigkeit wird weniger wie eine neue Modellkarte aussehen und mehr wie eine robuste, debuggbare, produktionsreife Agentenarchitektur.

Roh-LLM-Aufrufe sehen in einer Demo beeindruckend aus, verhalten sich jedoch eher wie ein leistungsstarkes, scheues Tier als wie ein zuverlässiger Mitarbeiter. Ein Agentengeschirr ist das Kontrollsystem, das um dieses Modell gewickelt ist und die stochastische Textvorhersage in etwas verwandelt, das beginnt, zuverlässige Software zu ähneln. Es definiert, wie der Agent sich erinnert, welche Werkzeuge er nutzt, wie er mit anderen Agenten zusammenarbeitet und wie er über Stunden oder Tage hinweg auf ein Ziel ausgerichtet bleibt, anstatt nur während einer einzelnen Chat-Interaktion.

Betrachten Sie das LLM als ein Rennpferd: schnell, stark und völlig desinteressiert an Ihrem Sprint-Backlog. Das Geschirr besteht aus Zaum, Zügeln und Sattel, die diese Kraft in vorhersehbare Bewegungen lenken. Ohne dieses Geschirr erhalten Sie Transkripte von Vibe-Coding und halluzinierte APIs; mit ihm erhalten Sie ein Codierungsinstrument, das tatsächlich eine Funktion umsetzen, Tests durchführen und Dokumente aktualisieren kann, ohne in Fan-Fiction abzudriften.

Die erste Aufgabe des Harness: Speicherverwaltung. LLMs arbeiten weiterhin innerhalb begrenzter Kontextfenster – 128K Tokens, vielleicht 200K, wenn man dafür bezahlt – deshalb entscheidet das Harness, was behalten, was zusammengefasst und was vergessen werden soll. Systeme wie Manus und die eigenen Harnesses von Anthropic kämpfen aktiv gegen „Kontextverfall“, indem sie veraltete Anweisungen entfernen und Retrieval nutzen, um nur die relevanten Teile des Repos, Tickets und vorherige Entscheidungen, die jetzt wichtig sind, zu ziehen.

Zweijob: Werkzeugkontrolle. Moderne Agenten rufen alles von Dateisystemen bis zu CI-Pipelines auf, und ein rohes Modell wird bereitwillig `rm -rf` auf deinem Repo ausführen, wenn der Prompt es anregt. Gateways kontrollieren diese Fähigkeiten: Sie entscheiden, wann ein Werkzeug eingesetzt wird, validieren Ausgaben und setzen Richtlinien durch wie „Tests müssen bestehen, bevor sie eingegeben werden“ oder „nie Produktion berühren ohne menschliche Genehmigung“.

Drittens koordiniert das Harness spezialisierte Unteragenten. Anstatt einen riesigen Prompt zu verwenden, der versucht, „die gesamte Funktion“ zu übernehmen, beobachten Sie Muster wie: - Planungsagent, der eine Spezifikation in Aufgaben umsetzt - Programmieragent, der Dateien bearbeitet - Testagent, der Tests ausführt und interpretiert - Prüfungsagent, der Stil und Architektur durchsetzt

Schließlich halten Harnesses langandauernde Aufgaben auf Kurs. Sie verfolgen den globalen Zustand, erkennen Schleifen, setzen Prüfpunkte und zeigen Entscheidungspunkte für Menschen an. Ein direkter LLM-Aufruf ist zustandslos und amnesisch; ein geharnester Agent kann über Hunderte von Aufrufen hinweg arbeiten, über Nacht pausieren und am nächsten Tag fortfahren, wobei er genau weiß, welcher Sonderfall den letzten Testlauf unterbrochen hat.

Moderne Harnesses öffnen normalerweise mit einem Initialisierungsagenten, der weniger wie ein Chatbot und mehr wie ein Projektmanager agiert. Er liest die Benutzerspezifikation, inspiziert das Repository oder die Umgebung und erstellt einen konkreten Plan: Meilensteine, zu verwendende Werkzeuge, zu bearbeitende Dateien und explizite Erfolgskriterien. Das eigene Harness von Anthropic beschreibt dies als eine Trennung zwischen "Initialisierer" und "Coder", wobei der Initialisierer den Umfang festlegt, bevor Änderungen am Code vorgenommen werden.

Sobald der Initialisierer abgeschlossen ist, übernimmt ein Aufgabenagent die Kontrolle, der tatsächlich die Arbeit verrichtet. Dieser Agent läuft in einer Schleife, nimmt einen einzelnen Schritt, führt Werkzeuge aus und löscht dann den Großteil seines Kontextfensters. Jede Schleifeniteration stellt gerade genug Zustand aus dem Speicher wieder her, sodass das Modell in einem 200-Nachrichten-Chatprotokoll nicht untergeht.

Diese Schleife sieht normalerweise wie ein straffes Kontrollsystem aus, anstatt wie ein freies Gespräch. Der Aufgabenagent: - Zieht den aktuellen Planschnipsel und relevante Dateien aus dem Gedächtnis - Schlägt eine Änderung oder Handlung vor - Führt Tools aus (Tests, Linter, Compiler, HTTP-Anfragen) - Schreibt Ergebnisse und Unterschiede zurück und wiederholt dann den Vorgang

Richtlinien umrahmen jede Iteration. Vorbereitungskontrollen validieren, dass die nächste Aktion des Agenten mit dem Plan und den erlaubten Werkzeugen übereinstimmt; Nachbereitungskontrollen überprüfen die Ausgaben gegen Einschränkungen wie „Tests müssen bestehen“ oder „keine Geheimnisse in Logs“. Systeme wie LangChain DeepAgent und OutSystems Agent Workbench integrieren diese Kontrollen als Richtlinien, die zu einem harten Fehler führen oder eine menschliche Überprüfung anfordern können.

Checkpoints geben dem Framework eine Struktur. Nach einem bedeutenden Fortschritt – zum Beispiel einem bestandenen Test-Set oder einer abgeschlossenen API-Integration – erstellt das Framework Momentaufnahmen des Zustands: Planposition, Dateihashes, Tool-Ausgaben und wichtige Entscheidungen. Wenn der Agent später halluziniert oder eine Datei beschädigt, kann das Framework auf den letzten stabilen Checkpoint zurückgreifen, anstatt zu raten, was schiefgelaufen ist.

Übergaben übertragen den Kontext zwischen spezialisierten Agenten. Ein Planungsagent könnte einem Programmieragenten einen strukturierten Aufgabenbaum übergeben; ein Programmieragent könnte einem Prüfungsagenten einen Patch sowie einen Testplan übergeben. Jede Übergabe verwendet strenge Schemata, sodass Agenten keine vagen Texte, sondern maschinenprüfbare Zustände austauschen.

Nichts davon funktioniert ohne eine ernsthafte Speicherschicht. Moderne Systeme setzen auf RAG für Code und Dokumente, langfristige Speicher für Entscheidungen und Gedächtniskompaktierung durch Zusammenfassungen oder Einbettungen, um den Kontextverlust zu bekämpfen. Menschliche Kontrollpunkte liegen auf dieser Schicht, die die Schleife für Genehmigungen bei riskanten Aktionen pausieren – Schema-Migrationen, Zahlungsflüsse oder sicherheitskritische Refaktoren –, damit das vibrierende Coden nicht stillschweigend zu einer Katastrophe führt.

Anthropic hat leise einen der klarsten Entwürfe für ernsthafte, langfristige Code-Agenten veröffentlicht: ein System, das Claude näher an einen Junior-Entwickler als an ein geschwätziges Autocomplete verwandelt. Ihr langfristiges Agentensystem sucht nicht nach Neuheiten; es systematisiert Planung, Ausführung und Überprüfung, damit das Modell mehrstündige Codierungsaufgaben bewältigen kann, ohne den Faden zu verlieren.

Im Kern befindet sich ein Initializer-Agent, der wie ein technischer Leiter agiert. Er verarbeitet eine umfassende Spezifikation, inspiziert das Repository, enumeriert Einschränkungen und erstellt einen strukturierten Plan: konkrete Aufgaben, Listen berührter Dateien, Abhängigkeitsnotizen und Abnahmekriterien. Dieser Plan wird zum Vertrag für einen separaten Coder-Agenten, der die mühsame Arbeit des Bearbeitens von Dateien, des Aufrufs von Tools und des Ausführens von Tests übernimmt.

Anthropics Harness behandelt den Zustand als ein erstklassiges Problem, nicht als nachträgliche Überlegung. Anstatt alles in ein riesiges Kontextfenster zu stopfen, hält es fest: - Einen kanonischen Aufgabenbaum und eine Checkliste - Dateiebene Verlaufshistorien und Diffs - Zusammenfassungen vorheriger Tool-Aufrufe und Testläufe

Der Initialisierer schreibt diesen Zustand; der Coder liest daraus Abschnitte und fügt dann neue Artefakte hinzu, die zukünftige Aufrufe abrufen können. Dieses Muster ermöglicht es dem System, über viele kleine, fokussierte Kontextfenster zu springen, während es sich weiterhin wie eine einzige fortlaufende Sitzung verhält.

Tooling hält das Ganze zusammen. Der Code-Agent halluziniert keine Dateiänderungen; er ruft explizite Tools auf für: - Lesen und Schreiben von Dateien - Ausführen von Unit- und Integrationstests - Ausführen von Linter- und Formatter-Tools

Jeder Aufruf des Tools liefert eine strukturierte Ausgabe, die vom Harness protokolliert, zusammengefasst und selektiv in den Kontext zurückgeführt wird. Fehlgeschlagene Tests werden beispielsweise zu präzisen Fehlerberichten, die der Programmer beheben muss, bevor der Harness eine Aufgabe als abgeschlossen kennzeichnet.

Selbstvalidierung ist überall präsent. Der Initialisierer bewertet seinen eigenen Plan im Vergleich zur ursprünglichen Spezifikation, der Programmierer prüft die Abweichungen im Vergleich zum Plan, und das Testsystem erzwingt Kontrollschleifen, die den Fortschritt blockieren, wenn Tests fehlschlagen oder Deckungslücken auftreten. Menschliche Kontrollpunkte können in dieselbe Schleife für Änderungen mit hohem Risiko integriert werden.

Anthropics Design entspricht nahezu eins zu eins dem allgemeinen Harness-Blaupause: langlebiger Speicher, explizite Werkzeuge, spezialisierte Unteragenten und enge Kontrollschleifen. Projekte wie Linear-Coding-Agent-Harness spiegeln dasselbe Muster wider, das schnell zur de facto Architektur für alle wird, die „Vibe-Coding“ zu mehr als nur einem Partytrick machen möchten.

Vibe-Coding klang immer nach Science-Fiction: Beschreibe ein Feature „Vibe“, geh Kaffee holen und komm zurück zu einem fertigen Pull-Request. Mit Agenten-Harnesses rückt diese Fantasie näher an die Realität, aber nur „so ungefähr“. Du kannst jetzt einen Agenten auf ein Git-Repo richten und ihn planen, bearbeiten, Tests ausführen und stundenlang iterieren lassen, ohne jeden Tastenanschlag überwachen zu müssen.

Gurte ermöglichen dies, indem sie das Rohmodell in ein Steuerungssystem einbinden. Ein gut gestalteter Gurt verwaltet Werkzeuge (Git, Testläufer, Linter), verfolgt den Zustand über Dutzende oder Hunderte von Aufrufen und setzt Kontrollpunkte durch. Der langlaufende Codierungsgurt von Anthropic verwendet beispielsweise einen Initialisierungsagenten, um einen Plan aufzustellen, gefolgt von einer Programmierer-Testerschleife, um die Implementierung und Überprüfung zu durchlaufen.

Regenbogen und Gänseblümchen enden dort. Vollautonome Vibe-Codierung scheitert immer noch, sobald sie auf ein chaotisches Monolith trifft, fehlende Tests oder unklare Produktanforderungen. Harnesses verstärken das technische Know-how, das Sie bereits haben; sie ersetzen es nicht.

Der Erfolg korreliert stark mit einem gut strukturierten Codebase und reichhaltigen Werkzeugen. Die Entwickler, die tatsächlich zuverlässig Funktionen bereitstellen, befinden sich häufig in Umgebungen mit: - Hoher Testabdeckung und schnellem Feedback (Sekunden, nicht Minuten) - Strengen Linters und Formatierern (ESLint, Prettier, Ruff) - Klaren Modulkriterien und typisierten APIs (TypeScript, mypy)

Der Mensch im Entscheidungsprozess bleibt für alles Wichtige unverzichtbar. Die effektivsten Vibe-Coding-Setups binden Menschen an kritischen Kontrollpunkten ein: Validierung des ursprünglichen Plans, Genehmigung von architektonischen Änderungen, Überprüfung riskanter Migrationen und Zusammenführung von Pull-Requests. Cole Medins eigene Beispiele für Harness setzen auf explizite Prüfungsphasen anstelle von blindem Auto-Merge-Pipelines.

Vibe-Coding ist also „zurück“, aber als Workflow und nicht als Magie. Du entlastest dich von der mühseligen Arbeit – Dateiänderungen, Boilerplate, Refaktorisierungen – während du über Absicht, Architektur und Abwägungen im Bilde bleibst. Die Fantasie von Einrichtungs- und Vergessen-Agenten kann warten; die praktische Version wird heute ausgeliefert, vorausgesetzt, du gestaltest das Gestell und den Code so, dass sie es verdienen.

Agenten, die in Geschirre eingehüllt sind, stoßen immer noch auf ein hartes Problem: Ausrichtung über die Zeit. Kurze Eingaben können den Vorgaben entsprechen; 500-Schritte-Coding-Marathons können das nicht. Selbst mit Anthropics Initialisierungs-Coder-Schleife oder LangChains DeepAgent interpretieren Modelle leise Anforderungen um, erfinden Datamodelle neu oder „optimieren“ Einschränkungen weg, die im ursprünglichen Brief nicht verhandelbar waren.

Abgleichabweichungen zeigen sich auf subtile Weise. Ein Kodierungsagent könnte während einer Neugestaltung mittendrin REST durch GraphQL ersetzen oder ein Leistungsbudget ignorieren, sobald die Tests bestanden sind. Harnesses fügen Leitplanken hinzu – Kontrollpunkte, Selbstkritik, Regressionstests – aber niemand hat einen narrensicheren Weg gefunden, ein großes, stochastisches Modell über Stunden oder Tage der Werkzeugnutzung treu zu einer Architektur und Produktspezifikation zu halten.

Noch schwieriger: Die Ausrichtung muss einen veränderten Kontext überstehen. Anforderungen entwickeln sich während des Ablaufs weiter, Menschen geben teilweise Rückmeldungen und externe Systeme fallen aus. Heutige Ansätze approximieren die Absicht mit Heuristiken – „nicht an Authentifizierung anfassen“, „dieses Verzeichnis niemals bearbeiten“, „Tests alle N Schritte ausführen“ – dennoch verfehlen sie weiterhin übergeordnete Ziele wie „die UX-Äquivalenz wahren“ oder „diesen Codebase idiomatisch halten“.

Dann gibt es die Kosten für den Aufbau eines ernsthaften Rahmens. Ein Produktionssystem benötigt: - Persistente Zustände und Speichersysteme - Werkzeugorchestrierung (Editoren, Testläufer, kontinuierliche Integration, Ticketing, Beobachtbarkeit) - Sicherheitsprüfungen, Rollback-Pfade und menschliche Überprüfungen - Domänenspezifische Evaluatoren und Kennzahlen

Dieser Stapel sieht weniger nach einem Prompt aus und mehr nach einem neuen Produkt. Das eigene langlaufende Harness von Anthropic umfasst mehrere Agenten, Planungsphasen und Validierungsebenen; Cole Medins Linear-Agent-Harness verbindet Git, Issue-Tracker und die Codeausführung. Nichts davon kommt „kostenlos“ aus einem SDK.

Es existiert noch kein universeller, einheitlicher Standard für Harnesses. Ein Fintech-Backend, ein React-Designsystem und eine Data-Science-Notebook-Pipeline benötigen alle unterschiedliche Werkzeuge, verschiedene Sicherheitsprüfungen und unterschiedliche Definitionen von „fertig“. Frameworks wie LangChain DeepAgent und Plattformen wie OutSystems Agent Workbench deuten auf eine mögliche Annäherung hin, erfordern jedoch weiterhin umfangreiche Anpassungen pro Team und Fachgebiet.

Statt Dealbreaker sind diese beiden Hindernisse die nächste Grenze. Das Rennen geht nun weniger um ein leicht intelligenteres Modell, sondern vielmehr um anpassungsfähige, wiederverwendbare Harnesses, die das Vibe-Coding langweilig zuverlässig statt gelegentlich magisch machen.

Beginnen Sie damit, Ihren Agenten als zustandsbehafteten Workflow zu skizzieren, nicht als magischen Prompt. Schreiben Sie die konkreten Phasen auf: Spezifikationseingabe, Planung, Implementierung, Testen, Refactoring, Bereitstellung und Überprüfung. Ihr Framework wird zur Schicht, die den Zustand zwischen diesen Phasen bewegt, entscheidet, wann das LLM aufgerufen werden soll und wann ein Mensch einbezogen werden muss.

Für praxisnahe Beispiele sind LangChains DeepAgents der zugänglichste Punkt, um darauf zuzugreifen. DeepAgents zeigen, wie Planer, Executor und Kritiker miteinander verbunden werden, wobei die Nutzung von Werkzeugen und das Gedächtnis in eine Schleife integriert sind, anstatt in einem einzelnen Aufruf. Sie können verfolgen, wie sie mehrstufige Aufgaben wie Repository-weite Refaktorisierungen oder Multi-Service-API-Integrationen verwalten.

Cole Medins eigener Linear Coding Agent Harness auf GitHub ist ein noch stärker meinungsbasierter Entwurf. Er umhüllt einen Coding-Agenten mit Linear-Themen und bietet Ihnen konkrete Abläufe für das Lesen von Tickets, das Planen von Änderungen, das Bearbeiten von Dateien und das Zurückposten von Updates an Linear. Sie erhalten echte Muster für Kontrollpunkte, Fehlerbehandlung und wie man sich erholt, wenn das Modell von der Spezifikation abweicht.

Wenn Sie in einem Unternehmens-Stack arbeiten, bringt Sie OutSystems Agent Workbench weiter nach oben auf der Abstraktionsleiter. Es integriert Schutzmaßnahmen, Beobachtbarkeit und Genehmigungen durch Menschen, sodass Sie Richtlinien definieren können wie „nie Produktionsumgebungen ohne Überprüfung ändern“ oder „Tests müssen bestehen, bevor zusammengeführt wird“. Das Outshift-Team von Cisco skizziert ähnliche Muster für Produktivsysteme in Wie Unternehmen AI-Agenten für intelligentere Automatisierung nutzen können.

Betrachten Sie das Design von Harness als ein Softwarearchitekturproblem, nicht als eine Spielerei mit Eingabeaufforderungen. Identifizieren Sie den langanhaltenden Zustand Ihres Agents (Aufgabenbaum, Dateien, Tickets), Ihre Werkzeuge (Repo-Zugriff, CI, Dokumentationssuche) und Ihre Sicherheitsvorkehrungen (Tests, Linter, menschliche Überprüfung). Kodifizieren Sie diese dann als explizite Zustände und Übergänge, anstatt darauf zu hoffen, dass das Modell sich „erinnert“.

Ein praktisches Starterrezept sieht folgendermaßen aus: - Ein Planungsagent, der Spezifikationen in eine Aufgabenliste umwandelt - Ein Ausführungsagent, der Code bearbeitet und Werkzeuge ausführt - Ein Bewertungsagent, der Änderungen und Testergebnisse bewertet - Eine Steuerungsschleife, die entscheidet, wann eine Neupplanung oder Eskalation erforderlich ist

Sobald Sie so denken, wird Prompt-Engineering zu einem Implementierungsdetail innerhalb eines Rahmens, der tatsächlich für Zuverlässigkeit sorgt.

Prompt-Engineering hatte eine gute Laufzeit, aber der Schwerpunkt hat sich verlagert. Die Kraft liegt jetzt in der Orchestrierung: Agenten, die Gedächtnis, Werkzeuge, Unteragenten und menschliche Kontrollpunkte verwalten, sodass ein einzelner LLM-Aufruf zu einem kohärenten, langlebigen System wird, anstatt nur ein schlauer Autovervollständigungs-Trick zu sein.

Wir beobachten, wie KI denselben Verlauf nimmt wie die Software selbst. Frühe „Skripte“ von manuell abgestimmten Eingabeaufforderungen weichen robuster Systemtechnik: Planer, Überprüfer, Regressionstests, Telemetrie und Rückrollfunktionen, alles um ein Modell herum, das möglicherweise nur 10–20% besser pro Generation ist, anstatt 10x.

Lösen Sie die beiden großen Hindernisse – langfristige Ausrichtung und architektonische Treue –, und Agenten hören auf, Spielzeuge zu sein, und beginnen, gesamte Arbeitsabläufe zu übernehmen. Ein gut gestaltetes System kann prinzipiell einen vollständigen Wachstumszyklus, einen durchgängigen Onboarding-Trichter oder eine mehrmonatige Umstrukturierung eines 500.000 Zeilen umfassenden Codes durchführen, während es den Vorgaben entspricht.

Das ist der Moment, in dem der „KI-Coding-Assistent“ zum „Mitglied des KI-Engineering-Teams“ wird. Dasselbe Muster erstreckt sich auf wissenschaftliche Arbeiten: Literaturrecherchen, Simulationskampagnen und die Planung von Experimenten werden über Tausende von LLM-Aufrufen hinweg verknüpft, wobei das System Einschränkungen durchsetzt, Entscheidungen protokolliert und nur kritische Entscheidungszweige den Menschen präsentiert.

Entwickler, die in dieser agentischen Ära erfolgreich sind, werden nicht diejenigen sein, die sich Prompthacks einprägen; sie werden diejenigen sein, die Kontrollsysteme entwerfen. Ihre Aufgabe verschiebt sich vom Gespräch mit einem Modell hin zu der Architektur von Planern, Kritikern, Tool-Routern und Überprüfungssystemen, die Tage oder Wochen autonomer Betrieb in der Lage sind.

Fang klein an, aber fang jetzt an. Nutze Anthropics langjährige Harness, Cole Medins Linear-Agent-Harness, LangChains DeepAgent oder Manus' Muster zur Kontextgestaltung und verbinde ein Harness für einen einzigen schmerzhaften Arbeitsablauf, den du heute besitzt.

Instrumentiere es, zerbrich es und härte es. Die nächste Welle des Hebels in der KI gehört denjenigen, die Modelle orchestrieren, nicht denjenigen, die sie nur anstoßen.

Was ist ein KI-Agent?

Ein Agenten-Harness ist ein System, das um einen KI-Agenten herum aufgebaut ist, um das Gedächtnis zu verwalten, Werkzeuge zu steuern, Unteragenten zu koordinieren und den Zustand aufrechtzuerhalten, sodass er komplexe, langanhaltende Aufgaben zuverlässig ausführen kann.

Wie unterscheidet sich ein Agent Harness von Prompt Engineering?

Prompt-Engineering optimiert einzelne Interaktionen mit einem LLM. Ein Agenten-Harness ist eine vollständige Architektur, die viele Interaktionen und Kontextfenster orchestriert, um ein größeres Projekt abzuschließen, indem es Techniken des Prompt- und Kontext-Engineerings in seinem Rahmenwerk integriert.

Ist 'Vibe-Coding' mit Agenten-Harnesses möglich?

Agenten-Harnesses bringen uns näher an das „Vibe-Coding“ (hands-off Funktionalität) heran, indem sie Agenten zuverlässiger machen. Dennoch ist das Problem nicht vollständig gelöst; komplexe Aufgaben erfordern weiterhin eine menschliche Validierung und gut gestaltete Sicherheitsvorkehrungen.

Warum werden Agenten-Geschirre jetzt wichtig?

Während die rohe Leistung von LLMs zu stagnieren beginnt, verlagert sich die Innovation auf die Systeme, die um sie herum aufgebaut sind. Harnesses bieten die Struktur, die erforderlich ist, um die nächste Stufe der Leistungsfähigkeit für unternehmensgerechte, autonome Agenten freizuschalten.