Issue 3 19.07.2026 · Lesezeit 8 Min Allgemein verfügbar

Claude schreibt jetzt sein eigenes Orchestrierungs-Skript.

Am 28. Mai 2026 kamen die Dynamic Workflows. Überall steht: „Hunderte Subagenten parallel." Das stimmt — und trifft trotzdem nicht den Kern. Der eigentliche Gewinn ist ein anderer.

Starter-Kit

Drei kommentierte Beispiel-Skripte · Kosten-Checkliste

Audit-Fan-out, Migration mit Verifikation, Loop-bis-grün — plus die Allowlist-Vorlage, die verhindert, dass dein Run mitten drin hängen bleibt.

Herunterladen

Doku-Quelle: code.claude.com/docs/en/workflows · Ab Claude Code v2.1.154

Vorab in eigener Sache

Diese Reihe war zwei Monate still. Der Grund war keine Schreibblockade, sondern ein Konstruktionsfehler in meiner eigenen Redaktions-Pipeline: Der wöchentliche Recherche-Agent hat brav jeden Donnerstag einen Entwurf erzeugt — aber es waren leere Gerüste, die noch jemand hätte ausschreiben müssen. Und er hat zehn Wochen lang dasselbe Thema vorgeschlagen, weil ein Dedup-Fehler dafür sorgte, dass nie freigegebene Entwürfe nicht als „schon behandelt" zählten.

Beides ist repariert. Ich erzähle das, weil es exakt die Klasse von Fehler ist, um die es heute geht: Ein Automatismus, der zuverlässig läuft und trotzdem nichts produziert. Zur Wiedergutmachung liegen vier Ausgaben bereit statt einer.

Der Denkfehler: Es geht nicht um Parallelität

Fast jeder Artikel über Dynamic Workflows führt mit derselben Zahl: hunderte Subagenten gleichzeitig. Beeindruckend — aber Parallelität konntest du vorher auch schon haben. Subagenten gibt es seit über einem Jahr.

Der Unterschied steht in der offiziellen Doku, und er lässt sich auf eine Frage eindampfen: Wer hält den Plan?

Bei normalen Subagenten hält Claude den Plan — im Context-Fenster. Jedes Zwischenergebnis, jede Schleife, jede Verzweigung frisst Kontext. Bei langen Aufgaben passiert dann das Bekannte: Claude verliert den Faden, wiederholt sich, vergisst, was in Schritt 3 herauskam.

Bei einem Dynamic Workflow schreibt Claude ein JavaScript-Skript, und eine separate Runtime führt es aus. Schleifen, Zähler, Zwischenergebnisse liegen dann in Skript-Variablen — nicht im Context-Fenster. In Claudes Kontext landet nur das Endergebnis.

Der Kern in einem Satz: Der Plan wandert aus Claudes Kopf in Code. Deshalb funktionieren Aufgaben, an denen ein Gesprächsverlauf erstickt — nicht, weil mehr Agenten laufen, sondern weil der Plan nicht mehr vergessen werden kann.

Die Abgrenzung, die alle verwechseln

Du kennst aus Band 1 und 2 bereits Subagenten und Skills. Dazu kamen Agent Teams und /goal. Fünf Dinge, die sich ähnlich anfühlen. Diese Tabelle stammt aus der offiziellen Doku und sortiert sie:

  Subagenten Skills Workflows
Was ist es? Ein Worker, den Claude startet Anweisungen, denen Claude folgt Ein Skript, das die Runtime ausführt
Wer entscheidet den nächsten Schritt? Claude, Zug um Zug Claude, dem Prompt folgend Das Skript
Wo liegen Zwischenergebnisse? Context-Fenster Context-Fenster Skript-Variablen
Skalierung Ein paar pro Turn wie Subagenten Dutzende bis Hunderte pro Run
Was ist wiederverwendbar? Die Worker-Definition Die Anweisungen Die Orchestrierung selbst

Und /goal? Das ist etwas ganz anderes.

/goal <Bedingung> setzt eine Abschlussbedingung. Nach jedem Turn prüft ein kleines, schnelles Modell (Standard: Haiku), ob die Bedingung erfüllt ist. Wenn nicht, macht Claude von selbst weiter. Technisch ist es eine Turn-Schleife mit Modell-Prüfer — die Kosten des Prüfers sind vernachlässigbar.

Merksatz: /goal ist Tiefe — eine Session läuft länger. Ein Workflow ist Breite — viele Agenten laufen gleichzeitig. Für „mach weiter, bis die Tests grün sind" brauchst du /goal, nicht einen Workflow. Das ist um Größenordnungen billiger.

Vorsicht bei Google: Mehrere gut rankende Artikel beschreiben /goal als „North-Star-Anker über dem Systemprompt". Das ist falsch. Es ist ein Stop-Hook mit Modell-Prüfer, mehr nicht.

So löst du es aus

Einzelne Aufgabe

ultracode: prüfe jeden API-Endpunkt unter src/routes/
auf fehlende Auth-Checks

Das Schlüsselwort ultracode im Prompt reicht. Natürliche Sprache geht auch: „nimm einen Workflow dafür". Versehentlich ausgelöst? Alt+W (Windows/Linux) bzw. Option+W (Mac) hebt es wieder auf.

Ganze Session

/effort ultracode          # Claude entscheidet selbst, wann ein Workflow passt
claude --effort ultracode  # oder direkt beim Start

Gilt nur für die aktuelle Session. Zurück mit /effort high. Achtung: Eine einzige Anfrage kann dann mehrere Workflows nacheinander auslösen — verstehen, ändern, verifizieren.

Beobachten und speichern

/workflows        # Live-Ansicht aller Runs
/deep-research    # mitgelieferter Workflow für Recherche

In /workflows: mit Enter in eine Phase reinzoomen (du siehst jeden Prompt und jedes Ergebnis), p pausiert, x stoppt, und s speichert das Skript als eigenen Slash-Command — danach liegt es in .claude/workflows/ und du rufst es mit /<name> auf. Das ist der Punkt, an dem aus einem Experiment ein Werkzeug wird.

Für Pro-Abos wichtig: Dynamic Workflows sind bei Max, Team, Enterprise und API standardmäßig an — im Pro-Plan musst du sie erst in /config einschalten.

Wie ein Skript aussieht

Das hier steht so in der offiziellen Doku. Es ist kürzer, als man erwartet:

export const meta = {
  name: 'audit-routes',
  description: 'Audit every route handler for missing auth checks',
}

const found = await agent('List every .ts file under src/routes/.', {
  schema: { type: 'object', required: ['files'], properties: { files: { type: 'array', items: { type: 'string' } } } },
})

const audits = await pipeline(found.files, file =>
  agent(`Audit ${file} for missing authentication checks.`, { label: file }),
)

return audits.filter(Boolean)

Zwei Funktionen musst du kennen, mehr nicht:

  • agent(prompt, {schema}) startet einen Subagenten. Mit schema ist die Antwort erzwungenes JSON — du kannst also direkt damit weiterrechnen.
  • pipeline(liste, fn) startet einen Agenten pro Listenelement. Das ist das Fan-out.

Was das Skript nicht kann: selbst auf Dateien oder die Shell zugreifen. Es koordiniert nur — lesen, schreiben und ausführen tun ausschließlich die Agenten. Jeder Run legt sein Skript als Datei unter ~/.claude/projects/<session>/ ab. Du kannst es lesen, ändern und neu starten lassen.

Die zwei Fallen

Falle 1: Die Kosten

Ein Workflow-Run zählt wie jede andere Session gegen dein Plan-Limit. Die harten Zahlen aus der Doku:

  • 16 Agenten laufen maximal gleichzeitig (weniger auf schwachen Rechnern)
  • 1.000 Agenten pro Run insgesamt — eine Notbremse gegen Endlosschleifen
  • Eine Warnung erscheint ab 25 Agenten oder 1,5 Millionen projizierten Tokens. Sie ist rein informativ und stoppt nichts.

Der Entwickler Nate Herk berichtet öffentlich, ein einziger Workflow-Prompt habe „die Hälfte meines 200-Dollar-Monatsplans in etwa 30 Minuten" verbraucht. Ich konnte die Zahl nicht unabhängig prüfen — aber sie ist plausibel, und sie beschreibt genau das Risiko.

Gegenmittel: In /config gibt es eine Größen-Empfehlung — small hält Runs unter 5 Agenten, medium unter 15. Und: erst auf einem Unterverzeichnis testen, nicht auf dem ganzen Repo.

Falle 2: Die Berechtigungen

Das steht in der Doku, wird aber in fast keinem Artikel erwähnt — und es ist der Punkt, an dem ich beim ersten Mal reingefallen bin:

Die Subagenten eines Workflows laufen immer im acceptEdits-Modus — unabhängig davon, in welchem Berechtigungs-Modus deine Session läuft. Datei-Änderungen werden automatisch genehmigt.

Shell-Befehle, Web-Zugriffe und MCP-Tools außerhalb deiner Allowlist können dagegen mitten im Run nachfragen — und dann steht dein 40-Agenten-Lauf und wartet. Setz die Allowlist, bevor du einen langen Run startest. Die Vorlage dafür liegt im Starter-Kit.

Wann es sich lohnt — und wann nicht

Lohnt sich

  • Audits über die ganze Codebasis, bei denen jeder Fund gegengeprüft werden muss — mehrere Agenten versuchen, einen Befund zu widerlegen, bevor er gemeldet wird
  • Große Migrationen — 500 Dateien umbauen, jede in einer isolierten Kopie, danach eine Verifikations-Phase
  • Recherche mit Quellen-Kreuzprüfung/deep-research lässt über jede Behauptung abstimmen und filtert raus, was den Check nicht übersteht
  • PR-Review — ein Reviewer pro geänderter Datei, danach ein Agent, der alle Funde dedupliziert

Lohnt sich nicht

  • Alles, was eine Handvoll Subagenten in einem Turn erledigt — dann ist der Overhead pure Verschwendung
  • Aufgaben, bei denen du zwischendrin freigeben willst — im laufenden Workflow ist kein Eingreifen möglich
  • „Mach weiter, bis die Tests grün sind" — das ist der Job von /goal und um ein Vielfaches billiger
  • Exploratives Arbeiten — der Workflow läuft im Hintergrund und liefert am Ende einen Report, kein Gespräch

Mein Fazit

Das ist die erste Neuerung seit Langem, die nicht nur „mehr vom Gleichen" ist. Der Referenz-Fall aus dem Anthropic-Blog: Jarred Sumner hat die JavaScript-Runtime Bun von Zig nach Rust portiert — rund 750.000 Zeilen Rust, 99,8 Prozent der bestehenden Tests grün, elf Tage vom ersten Commit bis zum Merge, hunderte Agenten parallel, zwei Reviewer pro Datei. Der Blog schreibt ausdrücklich dazu: „noch nicht in Produktion." Trotzdem: Das war vorher schlicht nicht machbar.

Für dich als Solo-Selbständigen ist die Lehre aber eine bescheidenere: Nimm es für Audits und Migrationen, nicht für den Alltag. Starte klein, beobachte den Verbrauch in /workflows mit, und wenn ein Run entgleist — x drücken. Fertige Arbeit geht dabei nicht verloren. Und wenn ein Workflow einmal gut lief: s drücken, speichern, ab dann ist es dein eigener Befehl.

Zum Ausprobieren

Dynamic-Workflows Starter-Kit

Drei kommentierte Skripte (Audit-Fan-out, Migration mit Verifikation, Loop-bis-grün), die Allowlist-Vorlage und eine Kosten-Checkliste vor dem ersten großen Run.

Herunterladen

Original-Doku: code.claude.com/docs/en/workflows


Das war Issue 3 der Velo-Wissen-Reihe. Jeden Sonntag um 15 Uhr eine Empfehlung — ein Tool, eine Bibliothek, ein Workflow oder ein Skill, das ich selbst getestet habe und für nützlich halte.