Individuelle KI-Agenten entwickeln: Architektur, Muster und Skalierung

Schritt 1: Architektur und Steuerungsrahmen des KI-Agenten festlegen

Die Architektur eines KI-Agenten besteht aus zwei Hauptteilen: dem Modell und der umgebenden Software. Diese Software umfasst neben dem Modell auch seine Tools, den Speicher und alles Weitere. Sie bildet einen fest programmierten, deterministischen Steuerungsrahmen mit Wenn-dann-Logik um das Kernmodell.

Die Unterscheidung ist offensichtlich. Teams, die lernen, individuelle KI-Agenten zu entwickeln, machen dennoch häufig den Fehler, dem Modell sämtliche Aufgaben zu überlassen. Das führt zu erheblichen Zuverlässigkeitsproblemen.

Das scheitert sofort. Das Modell erzeugt Text, aber der Steuerungsrahmen führt die Logik aus. Deshalb müssen Sie das Modell als eigenständige Einheit für Schlussfolgerungen behandeln, die niemals direkt auf Ihren Routing-Code zugreift.

Der Steuerungsrahmen verwaltet den Zustand, das Routing und die Fehlerbehandlung. Das Modell trifft diese Entscheidungen nicht. Nach der Bereitstellung eines solchen Systems für ein mittelgroßes SaaS-Unternehmen sanken die Bearbeitungszeiten im Support um 40 Prozent, weil der deterministische Steuerungsrahmen das Routing zuverlässig übernahm, statt sich auf Vermutungen des Modells zu verlassen.

Das leistete der Code. Ein klarer Systemablauf macht diese Trennung sichtbar. Der Steuerungsrahmen gibt den Ablauf vor, nicht das Modell. Dafür brauchen Sie einen strikten Implementierungsplan.

Verzichten Sie nicht auf die deterministischen Logikregeln. Anthropic hat ein Paper zu möglichen Entwurfsmustern für KI-Agenten veröffentlicht. Es beschreibt vier grundlegende Systemtypen: einzelne Agenten, sequenzielle Workflows, parallele Workflows und Evaluator-Optimizer.

Sie möchten wissen, wie Sie individuelle KI-Agenten entwickeln, die sich skalieren lassen? Dann muss das Muster zum Problem passen. Wenn ein einzelner Agent einen mehrstufigen parallelen Workflow bewältigen soll, steigt die Latenz Ihres Systems erheblich.

Einzelne Agenten erledigen jeweils eine Aufgabe gut.

• [ ] Deterministische Routing-Logik festlegen
• [ ] Tool-Zugriff über MCP planen
• [ ] Basismodell auswählen
• [ ] Schema für den Speicherzustand entwerfen
• [ ] Fallbacks für die Fehlerbehandlung konfigurieren

Welches Entwurfsmuster passt zum Anwendungsfall Ihres individuellen Agenten?

Sie lassen sich leicht debuggen, haben aber einen begrenzten Aufgabenbereich. Bei sequenziellen Workflows wird das Ergebnis eines Agenten an den nächsten weitergegeben. Das eignet sich für lineare Prozesse wie Recherchepipelines, die eine feste Abfolge von Schritten erfordern.

In einer Architektur mit parallelen Workflows erledigt eine Gruppe von KI-Agenten Aufgaben asynchron und gleichzeitig. Ähnlich wie Multithreading in klassischen Computerumgebungen verringert das die Latenz. Bei komplexen Aufgaben kann dieses Muster die Latenz erheblich senken.

Eine Evaluator-Optimizer-Architektur umfasst zwei Agentensysteme, die wiederholt zusammenarbeiten: Gruppe A erledigt die Aufgabe, Gruppe B bewertet und verbessert das Ergebnis, ähnlich wie beim Pair Programming.

Das führt bei Programmier- oder Schreibaufgaben zu besseren Ergebnissen. Der folgende Python-Ausschnitt konfiguriert einen parallelen Workflow mit asynchron arbeitenden Agenten. So führen Sie mehrere Agenten aus, ohne auf den Abschluss jedes einzelnen warten zu müssen.

Sehen Sie sich den Code an. `async def run_agent(task: str):`

# Simulate asynchronous agent task await asyncio.sleep(1)

import asyncio


return f"Result for {task}" async def parallel_workflow(tasks: list[str]): # Agents act asynchronously like multithreading results = await asyncio.gather(*[run_agent(task) for task in tasks])


return results tasks = ["fetch_market_data", "analyze_sentiment", "check_compliance"] results = asyncio.run(parallel_workflow(tasks)) print(results)

Berücksichtigen Sie bei der Gestaltung Ihres Workflows diese Abwägungen. Um einen KI-Agenten mit Claude zu entwickeln, kombinieren Entwickler das Claude Agent SDK mit Agent Skills. Wenn Sie sich mit der Entwicklung individueller KI-Agenten befassen, stehen Ihnen damit zwei Wege offen.

Wählen Sie Ihre Tools sorgfältig. Für eine enge Integration können Sie das Claude Agent SDK nutzen, für die Orchestrierung komplexer Zustandsautomaten LangGraph.

1. Latenz: Parallele Workflows verkürzen die Gesamtdauer erheblich.
2. Kosten: Parallele Workflows verbrauchen pro Sekunde mehr Tokens.
3. Genauigkeit: Evaluator-Optimizer-Zyklen verbessern die Genauigkeit, verdoppeln aber den Rechenaufwand.
4. Komplexität: Sequenzielle Workflows lassen sich am einfachsten debuggen.

Schritt 2: Basismodell und Orchestrierungsframework auswählen

Das Grundprinzip beim Entwickeln von Agenten mit Claude ist einfach: Das SDK stellt die Schleife bereit, Tools und MCP bestimmen, was der Agent tun kann, und Skills legen fest, wie er dabei vorgeht. So sind die Zuständigkeiten sauber getrennt. Das Claude Agent SDK bietet eine Agentenschleife, die Kontext sammelt, das Modell aufruft, ein Tool ausführt, dessen Ergebnis zurückgibt und den Ablauf wiederholt.

Sie lässt sich in Python oder TypeScript programmieren. LangGraph bietet mehr Kontrolle. Damit können Sie explizite Graphknoten für die Logik definieren und strikte Schutzregeln einrichten, die eigenmächtige Tool-Aufrufe des Modells verhindern.

Die Orchestrierungsebene sorgt mit wichtigen Schutzregeln dafür, dass Agenten bei ihrer Aufgabe bleiben. Diese Regeln lassen sich mit Tools wie LangGraph fest programmieren oder über grafische Tools wie Cursor Automations verwalten. Ohne Orchestrierung kann sich ein Agent bei einem einzigen Fehler endlos wiederholen.

Eine sichere Verwaltung von Zugangsdaten ist entscheidend. Schreiben Sie API-Schlüssel niemals fest in den System-Prompt. Für Produktivsysteme ist die Übergabe zur Laufzeit über Umgebungsvariablen der einzig sichere Weg.

Für komplexes Routing bevorzugen wir LangGraph. Es zwingt Sie dazu, Zustandsübergänge zu durchdenken. Das Claude SDK eignet sich dagegen besser für schnelle Prototypen und toolintensive Aufgaben, bei denen kurze Entwicklungszyklen wichtig sind.

{
 "orchestration": {
 "guardrails": {
 "max_iterations": 5,
 "timeout_seconds": 30
 },
 "secrets_manager": {
 "provider": "aws_secrets_manager",
 "keys": ["ANTHROPIC_API_KEY", "FIRECRAWL_API_KEY"]
 }
 }
}

Schritt 3: Tools, Webzugriff und Speicherverwaltung implementieren

KI-Agenten greifen über MCP (Model Context Protocol), CLI-Tools und Frameworks wie LangChain auf Tools zu. Wer individuelle KI-Agenten entwickeln will, muss wissen, wie er sie mit Daten aus der realen Welt versorgt. Das Wissen eines KI-Agenten braucht eine Grundlage in der Realität und in aktuellen Daten.

Ohne diese ist es auf gespeicherte Informationen und Trainingsdaten beschränkt.

Integrierte Abruf-Tools von Unternehmen wie OpenAI und Anthropic bieten nur begrenzten Webzugriff. Deshalb sind spezielle Webzugriffstools wie Firecrawl nötig. Der Abruf von Roh-HTML verbraucht unnötig Kontext und verwirrt das Modell.

Firecrawl bietet drei zentrale Endpunkte für den Webzugriff: /search (aktuelle Websuchen), /scrape (Websites als strukturierte Daten oder Markdown abrufen) und /interact (einen echten Browser öffnen, um Schaltflächen anzuklicken und Formulare auszufüllen).

Bei einer typischen Seite liefert die bereinigte Extraktion mit Firecrawl ungefähr 2,788 Tokens sauberes Markdown statt 38,381 Tokens Roh-HTML. Firecrawl benötigt damit 94 Prozent weniger Eingabetokens als der Abruf von Roh-HTML. Das verbessert unmittelbar die Leistung des Agenten.

Die Struktur von Webseiten kann sich ändern. Außerdem können sie irrelevante Navigationselemente oder Skripte enthalten. Bevorzugen Sie einen dokumentierten Endpunkt für strukturierte Daten, sofern einer verfügbar ist, und testen Sie die Extraktion anhand repräsentativer Seiten und bei Layoutänderungen.

import requests


def search_web(query: str):
    response = requests.post("https://api.firecrawl.dev/v1/search", 
        json={"query": query, "limit": 5},
        headers={"Authorization": f"Bearer {API_KEY}"})
    return response.json()


def scrape_site(url: str):
    response = requests.post("https://api.firecrawl.dev/v1/scrape",
        json={"url": url, "formats": ["markdown"]},
        headers={"Authorization": f"Bearer {API_KEY}"})
    return response.json()

Für langlebige KI-Systeme ist ein Speicher unverzichtbar, weil alle Modelle mit einem begrenzten Kontextfenster arbeiten. Ist dessen Grenze erreicht, muss der Kontext neu aufgebaut werden. KI-Modelle haben beispielsweise ein Kontextfenster von 200,000 Tokens.

Danach müssen sie den Kontext mithilfe gespeicherter Informationen wiederherstellen.

Sie müssen den Gesprächsverlauf und den Zustand in einer externen Datenbank speichern. Wenn das Kontextfenster voll ist, rufen Sie eine Zusammenfassung und relevante Fakten ab. Anschließend bauen Sie den Prompt neu auf.

Gehen Sie niemals davon aus, dass sich das Modell an etwas erinnert, das nicht in seiner aktuellen Eingabe steht.

Wie verwalten Sie Kosten und API-Schlüssel, und wie testen Sie das System?

Wenn Sie fünf Agenten gleichzeitig ausführen, bezahlen Sie fünf Modellaufrufe zur selben Zeit. Single Agents kosten pro Durchlauf weniger, brauchen aber deutlich länger. Sie müssen also Geschwindigkeit und Budget gegeneinander abwägen.

Sehen wir uns ein konkretes Beispiel für einen Support-Agenten mit mittlerem Anfragevolumen an: Bei 10,000 Durchläufen pro Monat und manuellen Kosten von $5 pro Ticket entstehen insgesamt $50,000. Die automatisierten Kosten setzen sich anders zusammen.

Das Hosting kostet $100. Der Break-even ist damit fast sofort erreicht. Tests für den Agenten-Wrapper sind unverzichtbar: Simulieren Sie Fehler bei Tools und prüfen Sie die Timeout-Logik gründlich, bevor Sie etwas im Produktivbetrieb einsetzen.

Für den Wrapper verwenden wir deterministische Testfälle, für das Modell probabilistische Evaluierungen. Einen Agenten setzen wir nie ein, ohne seine Fehlerbehandlung getestet zu haben. Überladen Sie System-Prompts nicht länger.

Agent Skills sind Ordner mit einer SKILL.md-Datei, die dem Agenten Spezialwissen für bestimmte Aufgaben vermitteln. Sie werden nur bei Bedarf geladen, sodass das Kontextfenster übersichtlich bleibt. Wenn Sie lernen möchten, individuelle KI-Agenten zu entwickeln, müssen Sie diese Zuständigkeiten trennen.

Ein oft übersehener Punkt: Warum prozedurales Wissen in Skills gehört

Das Grundprinzip beim Entwickeln von Claude-Agenten ist klar: Das SDK steuert die Schleife, Tools/MCP bestimmen, was der Agent tun kann, und Skills vermitteln ihm, wie er es tut. Tools sind Verben, Skills sind Handbücher. Wenn Sie sämtliche Anweisungen in den System-Prompt packen, verschwenden Sie Kontext: Das Modell liest dann auch Anweisungen, die es für die aktuelle Aufgabe nicht braucht.

Das Laden nach Bedarf löst dieses Problem. Der Agent lädt die SKILL.md-Datei nur, wenn er die jeweilige Aufgabe ausführen muss. So bleibt das Kontextfenster schlank und Halluzinationen werden seltener.

Außerdem werden Ihre Agenten dadurch modular. Einen Skill können Sie aktualisieren, ohne die zentrale Orchestrierungslogik anzufassen.