Anatomie einer Agenten-Flotte

Die teuerste Lüge im AI-Tooling ist die Demo: Ein Prompt geht rein, eine perfekte Antwort kommt raus. Echte Produktionsarbeit funktioniert nicht so.

Was funktioniert, ähnelt eher einer kleinen Firma. Ein Planer liest die Aufgabe und zerlegt sie in eine Arbeitsliste. Builder besitzen je ein Teilstück und sonst nichts. Reviewer beurteilen Code, den sie nie geschrieben haben. Tester bekommen die Spezifikation und den Diff in den Kontext, und kein Wort über irgendjemandes Absichten. Keiner von ihnen ist klüger als das Modell darunter; sie sind alle dasselbe Modell. Die Struktur lässt sie unterschiedlich handeln, und die Struktur ist der konstruierte Teil.

Warum überhaupt eine Flotte

Eine einzelne lange Konversation mit einem Modell degradiert vorhersehbar. Der Kontext füllt sich mit dem eigenen Output des Modells, und es stützt sich zunehmend auf seine früheren Antworten statt auf den Code. Frühe Fehler werden tragend.

Arbeit aufzuteilen kauft dasselbe wie in einem menschlichen Team. Ein Reviewer, der die Überlegungen des Builders nie gesehen hat, kann dessen blinde Flecken nicht erben. Frischer Kontext ist der Punkt.

So sieht eine Schleife aus, die ich laufen lasse. Eine Bug-Pipeline, die ein Ticket ohne weitere Prompts vom Auslöser bis zum konvergierten Pull Request trägt:

Jede Verzweigung in dem Bild ist eine benannte Barriere, und ein Gate, das scheitert, versucht es entweder innerhalb eines Limits erneut oder stoppt mit einem Report. Nichts wird durchgewinkt.

Der Harness

Die Agenten bekommen auf nichts direkten Zugriff. Jeder Tool-Aufruf läuft durch Hooks: kleine deterministische Skripte, die vor und nach dem Aufruf laufen und ihn blockieren können. Ein Agent, der einen Shell-Befehl ausführen will, stellt einen Antrag, er handelt nicht. Die Datenbank ist das strengste Beispiel. Die Verbindung selbst ist read-only, und ein Hook verwirft zusätzlich alles, was als Mutation parst, in jedem Berechtigungsmodus; selbst ein Lauf, der Bestätigungen ausdrücklich überspringen darf, kann nicht schreiben. Ein Prompt ist ein Vorschlag. Ein Hook ist ein Fakt.

Für die Orchestrierung gilt dieselbe Regel. Die Pipeline oben ist Code. Das Modell füllt die Blätter:

assert(database.isReadOnly);

await isolateWorktree(`fix/${bug.id}`);
const prior = await memory.recall(bug);

const [brief, sites, history] = await parallel([
  readTicket(bug),
  locateCode(bug),
  priorArt(bug),
]);

const repro = await reproduce(brief, sites);
if (!repro.ok) return report("NOT REPRODUCED");

const candidates = hypotheses(prior, brief, sites, history);
const verdicts   = await parallel(candidates.map(selfDisprove));
const cause      = pickSurvivor(verdicts);
if (!cause) return report("NO SURVIVING HYPOTHESIS");

const test = await writeFailingTest(repro);
assert(test.failsBeforeFix);

await parallel([fixFrontend(cause), fixBackend(cause), bootAppForSmoke()]);
const checks = await parallel([runScopedTests(cause), runSmoke(repro)]);
assert(checks.every((check) => check.green));

const commits = commitLogically();
const pr = await openPullRequest(push(commits));
await convergeReview(pr, { maxRounds: 3 });

return report({ cause, evidence: test, commits, pr });

Der Kontrollfluss ist deterministisch, und der Zustand des Laufs lebt in einem Ledger, einer Datei, die an jeder Phasengrenze neu geschrieben wird. Ein Bug-Lauf dauert eine Stunde, meist wartend auf Builds, und überlebt damit Sessions. Stirbt eine Session, setzt der Lauf am letzten bestandenen Gate wieder auf, weil die Struktur nie in einem Kontextfenster lag. Sie lag im Code.

Zehn aktive Bugs heißt zehn isolierte Worktrees in paralleler Arbeit. Und geht ein Versuch schief, heißt Aufräumen einen Ordner löschen, nicht schlechte Commits aus einem gemeinsamen Checkout herauslösen.

Was sie wissen

Agenten sind genau so scharf wie das, was sie nachschlagen können, deshalb ist Recall die erste und billigste Phase der Pipeline. Codebasen und Dokumente werden zerlegt und eingebettet, und „wo ist das Ding, das sich so verhält" wird ein Nachschlagen statt einer Grep-Safari. Entscheidungen leben in einem Wissensgraphen. Systeme, Constraints und Trade-offs sind die Knoten; ersetzt durch, hängt ab von, brach wegen sind die Kanten. Embeddings beantworten, wo die Dinge sind. Der Graph beantwortet, warum sie so sind.

Jeder abgeschlossene Lauf schreibt zurück, was er gelernt hat: die Ursache, die Falle, das Gotcha. Das ist der Unterschied zwischen einer Flotte, die mit jedem Bug klüger wird, und einer, die dieselbe Ursache zweimal entdeckt.

Was kaputtgeht

Sich selbst überlassen, scheitert eine Flotte selbstbewusst. Funde, die plausibel klingen und falsch sind. Reviewer, die alles durchwinken, was mit Autorität formuliert ist. Die Lösung war nie ein besserer Prompt. Sie ist adversariale Struktur: Hypothesen mit dem Auftrag, sich selbst zu widerlegen; Verifier mit dem Auftrag zu widerlegen. Ein Schluss überlebt nur, wenn die Skeptiker ihn nicht töten können. Dieses eine Muster hat für mich mehr Fehlalarme beseitigt als jede Formulierung von „sei sorgfältig und gründlich".

Und manche Aktionen kann die Flotte konstruktionsbedingt nicht ausführen, egal wie sicher sie ist: eine Datenbankmigration anwenden, Daten mutieren, den Pull Request abschließen, das Ticket schließen. Sie bereitet alles vor, berichtet und wartet. Der gefährliche letzte Schritt bleibt menschlich, denn wenn eine Migration schiefgeht, steht dafür ein Mensch gerade. Die Flotte multipliziert das Urteilsvermögen, das man ihr gibt, einschließlich der Fehlurteile.

Jedes Tool unter dieser Pipeline wird irgendwann ersetzt. Ihre Form (kontrollierte Aktionen, deterministische Struktur, adversariales Review, Gedächtnis, das sich aufbaut) nicht. Genau diese Fähigkeit belohnt die Agenten-Ära: Modelle als Ingenieursmaterial zu behandeln.