Gespräch vereinbaren
AI

Claude Managed Agents: Autonome KI-Agenten ohne Infrastruktur-Aufwand

— Felix Schmidt

Einen KI-Agenten zu bauen, der wirklich etwas tut – Code ausführt, im Web sucht, Dateien liest und schreibt – ist schwieriger als es aussieht. Neben der Wahl des Modells braucht man einen zuverlässigen Agent-Loop, eine gesandboxte Ausführungsumgebung, Tool-Integrationen, State-Management und Streaming-Infrastruktur. Das ist viel Klempnerarbeit, bevor man überhaupt den eigentlichen Use Case angeht.

Claude Managed Agents ändert diese Rechnung. Es ist Anthropics vorgefertigter, vollständig verwalteter Agent-Harness: Man definiert was der Agent tun soll, und die Plattform kümmert sich um wie er läuft.

Claude Managed Agents Architektur

Das zentrale Konzept

Claude Managed Agents baut auf vier Konzepten auf, die sich direkt auf die eigene Denkweise über Agenten übertragen lassen:

Agent — das „Wer": Modell, System-Prompt, Tools, MCP-Server und Skills, die Fähigkeiten und Persönlichkeit des Agenten definieren. Einmal konfiguriert, über viele Sessions hinweg wiederverwendet.

Environment — das „Wo": ein Cloud-Container-Template, das verfügbare Pakete (Python, Node.js, Go usw.), Netzwerk-Zugriffsregeln und vorinstallierte Dateien festlegt. Der Arbeitsraum des Agenten.

Session — das „Was": eine laufende Agent-Instanz, die einen konkreten Task ausführt und Ergebnisse produziert. Sessions sind ephemer, aber ihre Event-History wird serverseitig persistiert.

Events — das „Wie": der Nachrichtenaustausch zwischen der eigenen Anwendung und der Session. Man sendet User-Turns, Claude streamt Tool-Calls und Ergebnisse via Server-Sent Events (SSE) zurück, und neue Nachrichten können jederzeit zur Steuerung oder zum Unterbrechen eingefügt werden.

Der Ablauf einer Session

Der Lebenszyklus ist erfrischend geradlinig: Agent anlegen (einmalig), Environment konfigurieren (einmalig oder pro Task), Session mit einem Task starten. Claude nimmt den Task auf, ruft bei Bedarf Tools auf – Bash-Befehle, File-Reads, Web-Suchen – und streamt Ergebnisse in Echtzeit zurück. Wer die Ausführung umlenken will, sendet einfach ein weiteres Event. Nach Abschluss des Tasks schließt sich die Session und Outputs sind abrufbar.

Was das für den Produktionseinsatz attraktiv macht, ist das, was man nicht bauen muss: Retry-Logik, Tool-Execution-Layer, Context-Compaction bei langen Konversationen, Prompt-Caching für Effizienz. All das ist bereits enthalten.

Wann Managed Agents die richtige Wahl ist

Managed Agents passt gut, wenn der Workload eines der folgenden Merkmale aufweist:

Lang laufende Ausführung — Tasks, die Minuten oder Stunden dauern und viele sequenzielle Tool-Calls erfordern. Ein synchrones Request-Response-Muster versagt hier; asynchrone Sessions mit SSE-Streaming nicht.

Cloud-Infrastruktur-Bedarf — der Agent muss Python ausführen, Pakete installieren, Shell-Skripte laufen lassen oder kontrolliert auf das Netzwerk zugreifen. Managed Agents liefert einen sicheren Container out of the box.

Minimales Infrastruktur-Budget — schnelles Shippen ohne eigene Agent-Runtime aufzubauen. Managed Agents komprimiert monatelange Infrastrukturarbeit in wenige API-Aufrufe. Frühe Nutzer wie Notion und Asana berichten von 10-fachen Verbesserungen in der Time-to-Ship.

Stateful Interaktionen — persistente Dateisysteme und Konversationshistorie über mehrere Austausche mit demselben Agenten hinweg.

Wer hingegen feinkörnige Kontrolle über den Agent-Loop benötigt oder eine hochgradig angepasste Tool-Execution-Schicht baut, findet in der rohen Messages API mehr Flexibilität.

Eingebaute Tools

Claude hat out of the box Zugriff auf Bash (Shell-Befehle), Dateioperationen (Lesen, Schreiben, Bearbeiten, Glob, Grep), Web-Suche und Web-Fetch sowie MCP-Server für externe Dienste. Das deckt eine breite Palette realer Aufgaben ab: Code schreiben und ausführen, Datenverarbeitung, Recherche, Dateimanipulation und Integration mit Drittanbieter-APIs.

Praktische Beispiele

Beispiel 1: Wettbewerbs-Recherche mit Web Search

Einer der natürlichsten Anwendungsfälle für Managed Agents ist Recherche, die mehrere Quellen erfordert und Ergebnisse zusammenführt. Hier ein Agent, der Konkurrenzpreise überwacht:

import anthropic

client = anthropic.Anthropic()

# Agent einmalig erstellen
agent = client.beta.agents.create(
    model="claude-sonnet-4-6",
    name="Competitor Research Agent",
    system_prompt="""Du bist ein Marktforschungsassistent. Wenn du eine Produktkategorie erhältst,
durchsuchst du das Web nach aktuellen Preisen der Top-5-Wettbewerber, extrahierst strukturierte Daten
und erstellst einen Markdown-Report mit einer Vergleichstabelle.""",
    tools=[{"type": "agent_toolset_20260401"}],  # enthält web_search + web_fetch
)

# Session mit einem konkreten Task starten
session = client.beta.sessions.create(
    agent=agent.id,
    environment_id=environment.id,
    title="Wettbewerber-Preisrecherche",
)

# Task als Event senden und Ergebnisse streamen
with client.beta.sessions.events.stream(session.id) as stream:
    client.beta.sessions.events.send(
        session.id,
        events=[{
            "type": "user.message",
            "content": [{"type": "text", "text": (
                "Recherchiere aktuelle Preise für Projektmanagement-SaaS-Tools. "
                "Fokus auf Asana, Linear, Monday.com, Notion und Basecamp. "
                "Plan-Stufen und monatliche/jährliche Preise inklusive."
            )}],
        }],
    )
    for event in stream:
        if event.type == "agent.message":
            for block in event.content:
                print(block.text, end="")
        elif event.type == "session.status_idle":
            break

Claude sucht eigenständig im Web, besucht die Preisseiten jedes Wettbewerbers, extrahiert die relevanten Daten und stellt den Report zusammen – alles innerhalb einer einzigen Session. Keine Orchestrierungslogik auf der eigenen Seite nötig. Dieselbe Agent-Definition lässt sich für beliebige Produktkategorien wiederverwenden.

Beispiel 2: Automatisierte Datenpipeline mit Code-Ausführung

Managed Agents glänzt auch bei Aufgaben, die Code-Generierung mit sofortiger Ausführung kombinieren – ein Muster, das mühsam selbst zu bauen, aber trivial zu delegieren ist. Hier ein Agent, der einen CSV-Upload verarbeitet und eine Analyse produziert:

import anthropic

client = anthropic.Anthropic()

# Persistenten Datenanalyse-Agenten erstellen
agent = client.beta.agents.create(
    model="claude-sonnet-4-6",
    name="Data Analyst Agent",
    system_prompt="""Du bist ein Datenanalyst. Wenn du einen CSV-Dateipfad erhältst, lädst du ihn mit pandas,
führst eine explorative Analyse durch (Shape, Dtypes, fehlende Werte, Schlüsselstatistiken), identifizierst
interessante Muster und schreibst einen prägnanten Zusammenfassungsreport nach /output/report.md.
Speichere Diagramme als PNG-Dateien in /output/.""",
    tools=[{
        "type": "agent_toolset_20260401",
        "configs": [
            {"name": "web_search", "enabled": False},  # Web-Zugriff deaktivieren
            {"name": "web_fetch", "enabled": False},
        ],
    }],
)

# Environment konfigurieren
environment = client.beta.environments.create(
    name="data-analysis-env",
    config={
        "type": "cloud",
        "networking": {"type": "unrestricted"},
    },
)

# Analyse starten
session = client.beta.sessions.create(
    agent=agent.id,
    environment_id=environment.id,
)

with client.beta.sessions.events.stream(session.id) as stream:
    client.beta.sessions.events.send(
        session.id,
        events=[{
            "type": "user.message",
            "content": [{"type": "text", "text": "Analysiere /data/sales_data.csv und erstelle einen Report mit deinen wichtigsten Erkenntnissen."}],
        }],
    )
    for event in stream:
        if event.type == "agent.message":
            for block in event.content:
                print(block.text, end="")
        elif event.type == "agent.tool_use":
            print(f"\n[Tool: {event.name}]")
        elif event.type == "session.status_idle":
            print("\n\nFertig.")
            break

Der Agent schreibt Python-Code und führt ihn im sicheren Container aus, iteriert bei Fehlern und schreibt den fertigen Report nach /output/. Der gesamte Workflow – Code-Generierung, Ausführung, Fehlerbehandlung und Output – findet innerhalb der verwalteten Session statt.

Preisgestaltung

Managed Agents nutzt verbrauchsbasierte Preisgestaltung: Es gelten die üblichen Claude-Platform-Token-Tarife, plus $0,08 pro Session-Stunde für aktive Laufzeit. Keine fixen Infrastrukturkosten – man zahlt nur für das, was tatsächlich läuft.

Aktueller Status

Claude Managed Agents wurde am 8. April 2026 in die öffentliche Beta gestartet. Alle Endpunkte benötigen den managed-agents-2026-04-01-Beta-Header (das SDK setzt diesen automatisch). Drei Features – Outcomes, Multi-Agent-Orchestrierung und Memory – befinden sich in der Research Preview und erfordern separaten Zugang.

Rate Limits liegen bei 60 Requests pro Minute für Create-Operationen und 600 für Reads, pro Organisation.

Einstieg

Man benötigt einen Claude-API-Key – der Zugang ist standardmäßig für alle API-Accounts aktiviert. Der Quickstart führt durch die erste Session, und die API-Referenz deckt die vollständige Endpunkt-Oberfläche ab.

Für die meisten Teams, die KI-gestützte Automatisierung ausliefern, entfernt Managed Agents die schwierigsten Teile der Infrastruktur-Geschichte – und das ist eine bedeutende Verschiebung.

Quellen

Dieses Thema betrifft dein Team? Lass uns besprechen, wie ich helfen kann.

Kontakt aufnehmen← Zurück zum Blog

Diese Website verwendet Drittdienste (Google reCAPTCHA, Calendly), die Cookies setzen können. Mehr dazu in meiner Datenschutzerklärung .