Du hast diesen Monat ein Dutzend "KI-Agenten sind da!"-Posts gelesen. Anthropic hat am 8. April Managed Agents veröffentlicht. Google launchte ADK. OpenAI pushte ihr Agents SDK. Jedes Pitch Deck sagt "autonome Agenten" wie einen Zauberspruch. Aber du hast nie die eigentliche Schleife gebaut, die all das antreibt — die 50 Zeilen Python, in denen ein Modell eine Funktion aufruft, das Ergebnis liest und entscheidet, was als Nächstes passiert. Ohne das sieht jede Vendor-Demo gleich beeindruckend aus, und du kannst ein echtes Feature nicht von teurer Geschenkverpackung unterscheiden.

Warum "Nimm einfach eine Plattform" dich nicht weiterbringt

Der naheliegende Schritt: Eine Managed-Plattform wählen und alles dort erledigen lassen. Aber hier liegt das Problem — du lagerst Verständnis aus. Anthropics Managed Agents kostet $0,08 pro Session-Stunde. OpenAIs Agents SDK hat eigene Abstraktionen. Google ADK nutzt graphbasierte Workflows. Jede Plattform verpackt dasselbe Kernmuster in unterschiedliche Meinungen über Memory, Berechtigungen und Abrechnung — aber wenn du das Muster selbst nicht kennst, kannst du nicht beurteilen, welche Meinungen für DEINEN Anwendungsfall relevant sind. Eine Analyse des MIT Sloan Management Review von 2024 über KI-Projekte in Unternehmen beziffert die Erfolgsrate von agentischer KI vom Piloten zur Produktion auf etwa 5%. Der Fehlermodus ist nicht das Framework. Es sind Teams, die nicht verstehen, was darunter liegt.

Also bauen wir das Ding.

Das Rezept: 50 Zeilen für Röntgenblick

Schritt 0: SDK installieren

Stand 27. April 2026 ist das neueste Anthropic Python SDK — ein Toolkit, mit dem dein Python-Code mit Claudes Gehirn spricht — in Version v0.97.0. Ein Befehl:

pip install anthropic

Setz deinen API Key — ein geheimes Passwort, das deinen Account bei Anthropics Servern identifiziert:

export ANTHROPIC_API_KEY="sk-ant-..."

Schritt 1: Definiere deine Tools

Tools sind Funktionen, die Claude dich bitten kann auszuführen. Du beschreibst sie mit JSON Schema — einem standardisierten Format, das sagt "diese Funktion nimmt diese Eingaben in diesen Formen". Claude liest diese Beschreibungen wie eine Speisekarte und wählt, was es bestellen will.

Entscheidende Erkenntnis: Beschreibungen sind wichtiger als Namen. Claude entscheidet anhand der Beschreibung, wann es ein Tool aufruft. Vage Beschreibung = unvorhersehbares Verhalten.

/faion ist der faion-network Umbrella-Skill — er zieht relevante Methodik aus 12 Spezialistenbereichen (Dev, Produkt, Marketing, Ops, ...) in die Konversation, basierend auf deiner aktuellen Session.

/faion
What's the right way to design parameter schemas for an MCP tool that an
LLM will call autonomously? Focus on description quality, required fields,
and enum constraints.

Hier eine echte Tool-Definition — eine Wetterabfrage und ein Kalender-Ersteller:

tools = [
    {
        "name": "get_weather",
        "description": "Get current weather for a city. Use when the user asks about weather, temperature, or outdoor conditions.",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "City name, e.g. 'New York'"},
                "units": {"type": "string", "enum": ["celsius", "fahrenheit"]}
            },
            "required": ["city"]
        }
    },
    {
        "name": "create_event",
        "description": "Create a calendar event. Use when the user wants to schedule, book, or plan something.",
        "input_schema": {
            "type": "object",
            "properties": {
                "title": {"type": "string"},
                "start": {"type": "string", "format": "date-time"},
                "end": {"type": "string", "format": "date-time"}
            },
            "required": ["title", "start", "end"]
        }
    }
]

Beachte: required steuert das Verhalten. Lass ein Pflichtfeld weg und schau zu, wie Claude Werte halluziniert. Mach zu viele Felder erforderlich und gültige Aufrufe werden blockiert.

Schritt 2: Bau die Ausführungsschicht

Hier läuft DEIN Code. Claude führt selbst nie etwas aus — es schickt eine höfliche Anfrage wie "bitte führe get_weather mit {city: 'Chicago'} aus", und dein Code erledigt die eigentliche Arbeit:

def run_tool(name, input_data):
    if name == "get_weather":
        # In Produktion würdest du hier eine Wetter-API aufrufen
        return {"temp": 72, "condition": "sunny", "city": input_data["city"]}
    if name == "create_event":
        return {"event_id": "evt_456", "status": "created", "title": input_data["title"]}
    return {"error": f"Unknown tool: {name}"}

Schritt 3: Die Schleife — Wo Agenten-Verhalten entsteht

Das ist der Teil, den jede Plattform in Tausenden Zeilen Abstraktion verpackt. Die agentische Schleife — der Zyklus, in dem Claude Tools aufruft, Ergebnisse liest und seinen nächsten Schritt entscheidet — umfasst grob 20 Zeilen:

import json
import anthropic

client = anthropic.Anthropic()
messages = [{"role": "user", "content": "What's the weather in Chicago? If it's nice, schedule a picnic tomorrow at noon."}]

response = client.messages.create(
    model="claude-sonnet-4-20250514", max_tokens=1024,
    tools=tools, messages=messages
)

while response.stop_reason == "tool_use":
    # Claude kann MEHRERE Tools gleichzeitig anfordern — verarbeite ALLE
    tool_results = []
    for block in response.content:
        if block.type == "tool_use":
            result = run_tool(block.name, block.input)
            tool_results.append({
                "type": "tool_result",
                "tool_use_id": block.id,
                "content": json.dumps(result)
            })

    messages.append({"role": "assistant", "content": response.content})
    messages.append({"role": "user", "content": tool_results})

    response = client.messages.create(
        model="claude-sonnet-4-20250514", max_tokens=1024,
        tools=tools, messages=messages
    )

print(response.content[0].text)

Dieser Prompt löst ZWEI autonome Tool-Aufrufe aus: zuerst get_weather (um Chicago zu checken), dann create_event (um das Picknick zu planen) — und Claude kettet sie, ohne dass du es anweist. Das ist der "Aha"-Moment: Das Modell liest das Wetterergebnis, entscheidet, dass das Wetter gut ist, und ruft das nächste Tool eigenständig auf.

Jede Agentenplattform ist diese Schleife plus Meinungen über Memory, Berechtigungen, Abrechnung und Deployment obendrauf.

Schritt 4: Fehlerbehandlung — Nicht abstürzen, sondern beibringen

Wenn ein Tool fehlschlägt, lass deine Schleife nicht abstürzen. Schick den Fehler mit is_error: True zurück, damit Claude sich anpassen kann — mit anderen Eingaben nochmal versuchen, das Problem erklären oder einen anderen Ansatz wählen:

/faion
What error handling patterns work best in agentic tool-use loops —
specifically for recoverable errors vs fatal ones? When should the
agent retry vs bail out?

def run_tool_safe(name, input_data):
    try:
        return run_tool(name, input_data), False
    except Exception as e:
        return {"error": str(e)}, True

# Innerhalb der Schleife, ersetze die tool_results-Konstruktion:
result, is_err = run_tool_safe(block.name, block.input)
tool_results.append({
    "type": "tool_result",
    "tool_use_id": block.id,
    "content": json.dumps(result),
    "is_error": is_err
})

Claude liest den Fehler und reagiert intelligent: "Ich habe versucht, das Picknick einzutragen, aber der Kalender erlaubt nur Termine während der Geschäftszeiten. Soll ich Samstagmorgen probieren?"

Schritt 5: Sicherung einbauen

Eine außer Kontrolle geratene Schleife verbrennt Tokens — kleine Wortbrocken, die Claude verarbeitet, grob ¾ eines englischen Wortes — bis du sie abschießt. Bau einen Zähler ein:

MAX_ITERATIONS = 10
iteration = 0

while response.stop_reason == "tool_use" and iteration < MAX_ITERATIONS:
    iteration += 1
    # ... gleicher Schleifenkörper ...

if iteration >= MAX_ITERATIONS:
    print("Loop hit safety limit. Something's probably wrong.")

Keine Managed-Plattform sagt dir, dass das das Erste ist, was du einbauen solltest. Sie regeln das im Stillen — und kassieren dich für das Privileg.

Fallstricke, die in Produktion zubeißen

1. Der "Nur das erste Tool"-Bug. Claude kann mehrere tool_use-Blöcke in einer Antwort zurückgeben — zum Beispiel gleichzeitig das Wetter in drei Städten abfragen. Wenn du nur den ersten Block verarbeitest (in Tutorials häufig), wird das Modell durch fehlende Ergebnisse verwirrt. Symptom: Claude wiederholt dieselbe Anfrage endlos. Fix: Iteriere über ALLE Blöcke, gib ALLE Ergebnisse in einer Nachricht zurück. Das offizielle Tutorial nennt das die Ring-2 → Ring-3-Progression.

2. Context-Window-Aufblähung. Das Context Window — wie viel Text Claude gleichzeitig "sehen" kann, wie ein Arbeitsspeicher — füllt sich schnell. Jeder Tool-Aufruf und jedes Ergebnis sammelt sich an. Eine ausufernde Befehlsausgabe kann Tausende Tokens in einem Turn verbrauchen. Das Agent SDK übernimmt die Komprimierung automatisch; das reine SDK nicht. Fix: Fasse große Ausgaben zusammen, bevor du sie zurückfütterst, oder kürze auf die relevanten Teile.

3. Kein Sandboxing. Deine run_tool-Funktion läuft mit DEINEN Berechtigungen. Wenn Claude bittet, eine Datei zu löschen, und dein Tool gehorcht, ist die Datei weg. Laut Momentics Analyse hat deren Team das über 3 Monate autonomer Agentenläufe am eigenen Leib erfahren: "Sandboxing ist keine Option... Dinge geraten schneller außer Kontrolle, als man denkt."

4. Fehlende required-Felder. Wenn dein Schema required: ["city"] sagt, aber ein Nutzer fragt "Wie ist das Wetter?", wird Claude eine Stadt halluzinieren statt nachzufragen. Fix: Mach die Beschreibung explizit — "Wenn der Nutzer keine Stadt nennt, frag nach, statt zu raten."

Was du jetzt tun kannst

Du hast eine funktionierende agentische Schleife. Jede Vendor-Ankündigung von hier an lässt sich direkt darauf abbilden. Managed Agents? Das ist deine Schleife plus Checkpointing, Monitoring und Crash Recovery — für $0,08 pro Session-Stunde. OpenAIs Agents SDK vs Google ADK? Gleiche Schleife, andere Meinungen zu Handoffs und Graphen.

Der nächste Plattform-Pitch landet auf deinem Tisch. Statt der Demo zu vertrauen, fragst du: Welche Schicht MEINER Schleife ersetzt das — und ist diese Schicht tatsächlich mein Engpass?