Open Agent SDK: Wie Multi-Agenten-Kollaboration die KI-Entwicklung revolutioniert

Die Entwicklung mit KI-Agenten steht vor einer zentralen Herausforderung: Ein einzelner Agent stößt schnell an seine Grenzen, wenn komplexe, mehrstufige Aufgaben anstehen. Ob die Analyse eines Codebasis, die Erstellung eines Implementierungsplans oder das Schreiben und Testen von Code – solche Prozesse erfordern spezialisierte Rollen, die nahtlos zusammenarbeiten. Der Open Agent SDK adressiert dieses Problem durch ein dreistufiges System, das Sub-Agents, ein Task-System und eine Team-Kommunikation ermöglicht. Diese Architektur transformiert isolierte Agenten in ein hochgradig effizientes, kollaboratives Ökosystem.

Die drei Säulen des Multi-Agenten-Systems

Der Open Agent SDK strukturiert die Zusammenarbeit mehrerer KI-Agenten in drei zentralen Ebenen, die jeweils eine spezifische Herausforderung lösen:

• Sub-Agents: Dynamische Erstellung spezialisierter Unteragenten, die Teilaufgaben übernehmen – etwa die Exploration eines Codebase oder die Erstellung eines Designplans.
• Task-System: Systematische Nachverfolgung von Fortschritten und Ergebnissen in mehrstufigen Arbeitsabläufen, um den Überblick zu behalten.
• Team + Messaging: Bildung von Agenten-Teams, die über eine Mailbox-ähnliche Struktur kommunizieren und Aufgaben delegieren.

Diese Ebenen arbeiten nicht isoliert, sondern ergänzen sich zu einem orchestrierten System, das die Effizienz und Skalierbarkeit von KI-gestützten Entwicklungsprozessen deutlich erhöht. Im Folgenden werden die technischen Grundlagen dieser Architektur detailliert beleuchtet.

Sub-Agents: Dynamische Delegation durch Protokolle und Tools

Ein zentrales Konzept des SDKs ist die Fähigkeit des Haupt-Agents, während der Laufzeit Sub-Agents zu erzeugen. Diese werden über das SubAgentSpawner-Protokoll gesteuert, das in der Datei Types/AgentTypes.swift definiert ist. Das Protokoll stellt zwei Methoden bereit: eine vereinfachte Version mit fünf Parametern und eine erweiterte mit 13 Parametern. Letztere bietet zusätzliche Steuerungsmöglichkeiten wie die Auswahl spezifischer Modellanbieter oder die Definition von Berechtigungsmodi.

public protocol SubAgentSpawner: Sendable {
    func spawn(
        prompt: String,
        model: String?,
        systemPrompt: String?,
        allowedTools: [String]?,
        maxTurns: Int?
    ) async -> SubAgentResult

    func spawn(
        prompt: String,
        model: String?,
        systemPrompt: String?,
        allowedTools: [String]?,
        maxTurns: Int?,
        disallowedTools: [String]?,
        mcpServers: [AgentMcpServerSpec]?,
        skills: [String]?,
        runInBackground: Bool?,
        isolation: String?,
        name: String?,
        teamName: String?,
        mode: PermissionMode?,
        resume: String?
    ) async -> SubAgentResult
}

Die Implementierung des Protokolls, DefaultSubAgentSpawner, befindet sich in Core/DefaultSubAgentSpawner.swift. Hier werden entscheidende Mechanismen wie die Verhinderung von Rekursionen und die Tool-Vererbung umgesetzt. Sub-Agents erben zunächst alle Tools des Elternagents – mit Ausnahme des Agent-Tools selbst, um Endlosschleifen zu vermeiden. Über die Parameter allowedTools und disallowedTools kann die Tool-Auswahl weiter eingeschränkt werden.

Praktische Steuerung durch AgentTool

Das AgentTool ist die Schnittstelle, über die der Haupt-Agent mit den Sub-Agents interagiert. Wenn der LLM (Large Language Model) das Agent-Tool aufruft, übergibt es einen Prompt und optional Parameter wie den Sub-Agent-Typ (Explore oder Plan). Das Tool leitet diese Anfrage an den SubAgentSpawner weiter und initiiert die Erstellung des Sub-Agents.

{
  "prompt": "Untersuche die Projektstruktur und finde alle Swift-Dateien",
  "description": "Codebase erkunden",
  "subagent_type": "Explore"
}

Vorgefertigte Sub-Agent-Typen wie Explore (für die Codebase-Analyse) oder Plan (für die Erstellung von Implementierungsplänen) sind bereits im SDK integriert. Diese nutzen Tools wie Read, Glob, Grep und Bash, um ihre Aufgaben effizient zu erfüllen. Der Eltern-Agent wartet währenddessen auf die Rückmeldung des Sub-Agents, bevor er weitere Schritte einleitet – ein Prozess, der als blockierende Ausführung bezeichnet wird.

Task-System: Fortschritt transparent verfolgen

Mehrstufige Aufgaben erfordern eine klare Nachverfolgung, um den Überblick über Zwischenstände und Ergebnisse zu behalten. Das Task-System des Open Agent SDK übernimmt diese Rolle, indem es:

• Meilensteine definiert und deren Erreichung dokumentiert.
• Ergebnisse der Sub-Agents zentral speichert und für den Haupt-Agenten zugänglich macht.
• Fehlerbehandlungen ermöglicht, etwa durch das Zurücksetzen auf vorherige Zustände.

Diese Struktur ist besonders wertvoll für Entwicklungsprozesse, die iterative Verbesserungen erfordern – etwa das schrittweise Refaktorieren von Code oder das Testen neuer Implementierungen.

Team-Kommunikation: Agenten-Teams über Mailbox-Systeme verbinden

Die höchste Ebene der Architektur ermöglicht die Bildung von Agenten-Teams, die über eine dezentrale Mailbox kommunizieren. Jeder Agent kann Nachrichten an andere Teammitglieder senden oder empfangen, ohne dass eine direkte Kopplung erforderlich ist. Dies fördert:

• Modularität: Teams können dynamisch erweitert oder reduziert werden.
• Robustheit: Ausfälle einzelner Agenten wirken sich nicht auf das gesamte System aus.
• Skalierbarkeit: Aufgaben können auf mehrere Teams verteilt werden, die parallel arbeiten.

Die Mailbox-Architektur folgt dabei dem Prinzip der asynchronen Kommunikation, bei der Nachrichten in einer Warteschlange zwischengespeichert und bei Verfügbarkeit des Empfängers verarbeitet werden.

Ein vollständiges Beispiel: Vom Codebase-Exploration zur Planung

Das SDK bietet ein praktisches Beispiel, das die gesamte Kollaborationskette demonstriert. Ein Haupt-Agent mit der Rolle eines Koordinators delegiert eine Aufgabe an einen Sub-Agenten vom Typ Explore. Dieser analysiert die Codebase, identifiziert relevante Swift-Dateien und übergibt die Ergebnisse zurück an den Haupt-Agenten. Dieser fasst die Erkenntnisse zusammen und leitet gegebenenfalls weitere Schritte ein – etwa die Erstellung eines Implementierungsplans durch einen Plan-Sub-Agenten.

let systemPrompt = """
Du bist ein Koordinations-Agent. Bei einer Aufgabe delegierst du sie an einen Sub-Agenten
mithilfe des Agent-Tools. Der Sub-Agent (z. B. vom Typ "Explore") nutzt Tools wie Read, Glob,
Grep und Bash, um die Codebase zu untersuchen. Nach Abschluss fasst du die Ergebnisse für den Nutzer zusammen.
"""

let agent = createAgent(options: AgentOptions(
    apiKey: apiKey,
    model: defaultModel,
    systemPrompt: systemPrompt,
    maxTurns: 10,
    tools: getAllBaseTools() + [AgentTool()]
))

Dieses Beispiel verdeutlicht, wie der Open Agent SDK die Grenzen einzelner KI-Agenten überwinden und komplexe, kollaborative Arbeitsabläufe ermöglichen kann – ein Game-Changer für die KI-gestützte Softwareentwicklung.

Die Zukunft der KI-Entwicklung liegt in der Zusammenarbeit. Der Open Agent SDK setzt mit seiner Multi-Agenten-Architektur einen neuen Standard, der Entwicklern die Werkzeuge an die Hand gibt, um skalierbare und effiziente KI-Systeme zu realisieren. Mit der weiteren Reifung solcher Frameworks wird die KI-gestützte Programmierung nicht nur schneller, sondern auch zugänglicher für ein breiteres Spektrum an Anwendungsfällen – von der Codegenerierung bis hin zur Systemarchitektur.