AI Prompt Engineering · Lektion

Orchestrator und Worker

Hierarchische Koordination

Orchestrator und Worker ist eine kostenlose AI Prompt Engineering-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Prompt Engineering-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Prompt Engineering-Kurs umfasst insgesamt 4 Lektionen.

Das Orchestrator-Muster

Beim Orchestrator-Workers-Muster ist ein einzelner Orchestrator-Agent für den Plan und das Ziel zuständig; Worker-Agents führen eng gefasste Teilaufgaben aus und melden die Ergebnisse zurück. Der Orchestrator zerlegt die Aufgabe, verteilt sie, integriert die Ergebnisse und entscheidet, wann die Aufgabe abgeschlossen ist.

Orchestrator: Planung, Routing, Synthese und Kontrollfluss.
Worker: fokussierte Ausführung innerhalb eines engen Vertrags.

Diese Hierarchie konzentriert die Entscheidungsfindung an einer Stelle und verteilt die ausführende Arbeit auf viele Agents.

Trennung von Planung und Ausführung

Die entscheidende Disziplin besteht darin, Planung und Ausführung getrennt zu halten. Der Orchestrator denkt mit einem kleinen, übergeordneten Kontext über die Strategie nach; Worker arbeiten mit einem detaillierten, aber eng begrenzten Kontext. Ihre Vermischung führt wieder zum überlasteten Generalisten.

Der Orchestrator sollte die rohen Tool-Ausgaben nur selten direkt verarbeiten - er sollte über Worker-Zusammenfassungen nachdenken.

plan = orchestrator.decompose(goal)        # high-level
results = [worker.run(sub) for sub in plan] # detailed, scoped
final = orchestrator.integrate(results)     # over summaries

Die Qualität der Zerlegung bestimmt alles

Das System ist nur so gut wie die Zerlegung durch den Orchestrator. Teilaufgaben müssen unabhängig genug für eine parallele Ausführung, klar genug für eine saubere Übergabe und zusammen vollständig sein. Lassen Sie den Orchestrator einen expliziten Plan ausgeben, den Sie prüfen können, bevor ein Worker ausgeführt wird.

Unabhängige Teilaufgaben - parallele Ausführung.
Vollständige Abdeckung - keine Lücken in der endgültigen Antwort.

plan = {
  'subtasks': [
    {'id': 1, 'goal': '...', 'inputs': [...], 'depends_on': []},
    {'id': 2, 'goal': '...', 'inputs': [...], 'depends_on': [1]}
  ]
}

Mit engen Verträgen dispatchen

Bei jeder Dispatch-Aktion erhält ein Worker genau sein Ziel, seine Inputs und das erwartete Ausgabeschema - nicht mehr. Ein Worker, der nur seinen Teilbereich kennt, kann nicht durch das übergeordnete Ziel abgelenkt werden und liefert eine vorhersehbare Struktur, die der Orchestrator integrieren kann.

Die Dispatch-Nachricht ist ein Vertrag: klares Ergebnis, klares Format und klare Kriterien für den Abschluss.

dispatch = {
  'goal': 'Summarize doc 7 risks',
  'context': doc7,
  'output_schema': {'risks': [{'text': str, 'severity': str}]},
  'done_when': 'all risk clauses covered'
}

Kontextisolierung zwischen Workern

Worker sollten standardmäßig nicht den vollständigen Kontext der jeweils anderen sehen. Isolation verhindert, dass Fehler oder Halluzinationen eines Workers einen anderen verunreinigen, und hält den Prompt jedes Workers klein und cachebar. Nur der Orchestrator verfügt über die globale Sicht.

Teilen Sie Informationen zwischen Workern ausschließlich über geprüfte Zusammenfassungen des Orchestrators, niemals über direkten Austausch roher Inhalte.

Parallele oder sequenzielle Teilaufgaben

Unabhängige Teilaufgaben werden zur Verringerung der Latenz parallel ausgeführt; abhängige Teilaufgaben müssen die Reihenfolge einhalten. Der Plan des Orchestrators bildet einen Abhängigkeitsgraphen ab, nach dem die Laufzeit die Ausführung plant - sie verteilt unabhängige Blätter und führt sie anschließend zusammen.

Fan-out: Alle bereiten Teilaufgaben gleichzeitig dispatchen.
Join: Vor dem Dispatch abhängiger Teilaufgaben auf die Abhängigkeiten warten.

def schedule(plan):
    ready = [t for t in plan if not t['depends_on']]
    run_parallel(ready)
    # then unlock tasks whose deps are now done

Integration und Konfliktlösung

Integration bedeutet nicht bloßes Aneinanderhängen. Der Orchestrator muss sich überschneidende, widersprüchliche oder wenig verlässliche Worker-Outputs zu einem kohärenten Ergebnis zusammenführen, entscheiden, welchen er vertraut, und ungelöste Konflikte sichtbar machen.

Geben Sie dem Orchestrator einen expliziten Abgleichsschritt mit Regeln: Bevorzugen Sie Ergebnisse mit höherer Konfidenz, kennzeichnen Sie Widersprüche und fordern Sie eine erneute Ausführung an, wenn die Abdeckung unvollständig ist.

merged = orchestrator.reconcile(
  results,
  rules='prefer higher confidence; flag contradictions; re-dispatch on gaps'
)

Der Orchestrator als Controller

Der Orchestrator ist auch für den Kontrollfluss zuständig: Er entscheidet, wann er stoppt, wann er einen fehlgeschlagenen Worker erneut ausführt, wann er neu plant und wann er eskaliert. Dadurch kann er Budgets durchsetzen - maximale Iterationen, maximale Ausgaben und maximale Tiefe - und Endlosschleifen verhindern.

Ohne einen steuernden Orchestrator geraten Multi-Agenten-Systeme außer Kontrolle.

if iterations > MAX_ITERS or spend > BUDGET:
    return orchestrator.best_effort_answer()

Rekursive Zerlegung

Ein Worker kann selbst als Orchestrator für ein Teilproblem fungieren und so eine Hierarchie bilden. Das bewältigt komplexe Aufgaben, erhöht jedoch Latenz und Tiefe der Fehlerweitergabe. Begrenzen Sie die Rekursionstiefe und verlangen Sie von jeder Ebene eine klare Zusammenfassung, damit die übergeordneten Ebenen nicht in Details der unteren Ebenen untergehen.

Fehlerisolierung

Entwerfen Sie das System so, dass der Ausfall eines einzelnen Workers sich kontrolliert auswirkt. Der Orchestrator sollte fehlerhafte oder leere Worker-Ausgaben erkennen, den Worker mit einem präzisierten Vertrag erneut ausführen und auf eine Alternative zurückgreifen, statt abzustürzen. Worker fallen isoliert aus; der Orchestrator fängt den Fehler ab und leitet die Verarbeitung daran vorbei.

Validieren Sie jede Rückgabe eines Workers anhand ihres Schemas.
Erneuter Versuch, dann Fallback - propagieren Sie niemals einen rohen Fehler nach oben.

def collect(worker, dispatch):
    out = worker.run(dispatch)
    if not valid(out, dispatch['output_schema']):
        out = worker.run(clarify(dispatch))
    return out or fallback(dispatch)

Ein Orchestrierungsentwurf

Der Entwurf: Der Orchestrator zerlegt die Aufgabe in einen überprüfbaren Plan als Abhängigkeitsgraphen, verteilt enge Verträge an isolierte Worker, führt unabhängige Teilaufgaben parallel aus, validiert und gleicht Ergebnisse anhand expliziter Konfliktregeln ab, setzt Budgets und Abbruchbedingungen durch und kapselt Worker-Fehler mit erneutem Versuch und anschließendem Fallback. Die Entscheidungsfindung bleibt zentral, die Arbeit verteilt.

Kurze Überprüfung

Sie entwerfen ein Orchestrator-Worker-System für eine Rechercheaufgabe mit mehreren unabhängigen Teilthemen.

Zusammenfassung: Orchestrator und Worker

Bündeln Sie Planung, Routing, Integration und Steuerung in einem Orchestrator; übertragen Sie die fokussierte Ausführung unter klar definierten Verträgen auf isolierte Worker. Zerlegen Sie die Aufgabe in einen überprüfbaren Abhängigkeitsgraphen, parallelisieren Sie unabhängige Teilaufgaben, führen Sie Ergebnisse anhand expliziter Konfliktregeln zusammen, setzen Sie Budgets und Abbruchbedingungen durch und begrenzen Sie Worker-Fehler mit validate-retry-fallback. Der Orchestrator schließt aus Zusammenfassungen, niemals aus dem unaufbereiteten Austausch zwischen Workern, und hält so die Hierarchie konsistent und steuerbar.

Häufig gestellte Fragen

Ist die Lektion „Orchestrator und Worker“ kostenlos?

Ja — der vollständige Text von „Orchestrator und Worker“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Prompt Engineering-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Prompt Engineering-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Orchestrator und Worker“?

Hierarchische Koordination Du übst AI Prompt Engineering mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um AI Prompt Engineering zu starten?

Keine Vorkenntnisse erforderlich. AI Prompt Engineering auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Orchestrator und Worker“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser AI Prompt Engineering-Lektion Code schreiben und ausführen?

Ja. Jede AI Prompt Engineering-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu AI Prompt Engineering