Wie Claude Code die Grenzen der Intelligenz verschiebt

Die Plattform Anthropic’s Claude Code entwickelt sich von einem leistungsstarken Coding-Assistenten zu einem vollständig anpassbaren Agent-Framework. Die neuen Funktionen ermöglichen erweitertes Denken, Tool-Nutzung, MCP-Integration, dauerhaftes Memory, die Bearbeitung des Kontexts, sichere Codeausführung und Agent Skills. Sie zeigen, wie Claude Code die Grenzen dessen verschiebt, was intelligente Systeme leisten können.

Die neuen Funktionen von Claude Code erweitern die Möglichkeiten intelligenter Agenten durch:

• Erweitertes Denken → tiefgründigeres Schlussfolgern

• Tool-Nutzung → Interaktion mit Systemen

• MCP → Kontextbewusstsein

• Memory → langfristige Kohärenz

• Kontextbearbeitung → effizientes Zustandsmanagement

• Codeausführung → sichere Nutzung echter Rechenleistung

• Agent Skills → Fachwissen und Autonomie

Zusammen bilden diese Funktionen eine flexible, leistungsstarke Agent-Plattform, die Schlussfolgern, Tools, Kontext und Skills vereint – die grundlegenden Zutaten für wirklich intelligente Systeme. Im Folgenden erhalten Sie einen Überblick über diese Funktionen, basierend auf Anthropics Präsentation auf der Veranstaltung AI Engineer Code im November 2025 in New York.

Erweitertes Denken

Mit erweitertem Denken können Entwickler Claude ausdrücklich ein Budget für Überlegungen zuweisen. So steuern Sie, wie tief und gründlich Claude nachdenkt und wie viel „Chain-of-Thought-Bandbreite“ das Modell bei der Lösung schwieriger Probleme nutzt.

response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=8192,
    thinking={
        "enabled": True,
        "budget_tokens": 20000  # You control the depth
    },
    messages=[{
        "role": "user",
        "content": "Help me debug why this system fails under load"
    }]
)

Mit thinking.enabled=True und einem konfigurierbaren budget_tokens können Sie:

• Claude Hypothesen gründlich untersuchen lassen.
  Die Qualität beim Debugging verbessern, indem das Modell mehr interne Schritte prüft.
  Intelligenz und Kosten je nach Anwendungsfall gegeneinander abwägen.

Damit erhalten Entwickler im Grunde einen „Regler für Überlegungen“, mit dem sie Agenten auch komplexere Schlussfolgerungsaufgaben bewältigen lassen können.

Tool-Nutzung

Claude Code unterstützt jetzt benutzerdefinierte Tools mit schemadefinierten Eingaben. Damit kann Ihr Agent sicher, typisiert und vorhersagbar mit externen Systemen interagieren – vom Ausführen von Tests bis zum Ändern von Dateien:

tools=[
    {"type": "bash"},
    {"type": "text_editor"},
    {
        "name": "run_tests",
        "description": "Run the project's test suite and return results",
        "input_schema": {
            "type": "object",
            "properties": {
                "test_path": {"type": "string", "description": "Specific test directory"},
                "verbose": {"type": "boolean", "description": "Include full output"}
            }
        }
    }
]

Das ermöglicht:

• Benutzerdefinierte Tools, die sich wie typisierte Funktionsaufrufe verhalten.

• Integrierte Bash- und Texteditor-Tools.

• Klare Ein- und Ausgabeschemas für sichere Tool-Aufrufe.

• Ideal für CI-Automatisierung, lokale Entwicklungs-Workflows oder benutzerdefinierte DevOps-Aktionen.

Tools machen aus Claude einen Chatbot, der in der realen Welt handeln kann.

Ein vollwertiger Agent im MCP-Ökosystem (Model Context Protocol)

Claude Code bietet native MCP-Unterstützung und kann so strukturierte externe Datenquellen wie GitHub und Sentry einbinden. MCP-Server fungieren als Adapter, die Claude mit APIs, Datenbanken oder internen Systemen verbinden.

response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=4096,
    mcp_servers=[
        {"url": "mcp://github-server", "name": "github"},
        {"url": "mcp://sentry-server", "name": "sentry"}
    ],
    messages=[{
        "role": "user",
        "content": "Why did this deploy cause a latency spike?"
    }]
)

MCPs ermöglichen dabei:

• Claude kann GitHub-PR-Diffs, CI-Logs und Deployment-Metadaten abrufen.

• Die Abstraktion durch MCP-Server macht das Jonglieren mit API-Schlüsseln und fragile HTTP-Aufrufe überflüssig.

• Ihr Agent kann Signale aus mehreren Systemen (hier: GitHub und Sentry) miteinander verknüpfen.

MCP verschafft Claude praktisch Augen und Ohren in Ihrer Infrastruktur.

Agent-Memory als native Funktion von Claude

Claude Code führt ein sicheres, strukturiertes Memory-System ein. Wenn diese Funktion aktiviert ist, kann Claude Wissen aus mehreren Interaktionen speichern und so Aufgaben mit längerem Zeithorizont wie Debugging oder Entwicklungsprojekte besser bewältigen.

response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=4096,
    tools=[{"type": "memory"}],
    messages=[{
        "role": "user",
        "content": "Debug why the payment service is timing out"
    }]
)

Mit dieser Memory-Grundfunktion kann sich Claude Folgendes merken:

• Der Zahlungsdienst verwendet ein 30-s-Timeout

• Die Retry-Logik befindet sich in PaymentClient.java

• Das Team bevorzugt ein Circuit-Breaker-Muster

Memory ermöglicht die fortlaufende Anreicherung des Kontexts – entscheidend bei mehrtägigen oder mehrstufigen Aufgaben.

Kontextbearbeitung in Claude Code

Große Tool-Ausgaben wie Logs, Diffs und JSON-Dumps können das Kontextfenster schnell ausschöpfen. Mit der Kontextbearbeitung kann Claude Code gezielt Kontextabschnitte entfernen oder ersetzen.

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=4096,
    messages=[...],
    context_management={
        "edits": [
            {"type": "clear_tool_uses_20250919"}
        ]
    }
)

Die Möglichkeit, den Kontext präzise zu steuern, verbessert agentische Workflows, zum Beispiel:

• Alte Tool-Spuren nach der Verarbeitung entfernen.

• Nur aussagekräftige Zusammenfassungen beibehalten.

• Die effektive Kontextlänge deutlich erhöhen.

Ihr Agent bleibt auf Zack, statt sich mit veralteten Logs aufzuhalten.

Codeausführung in einer sicheren Sandbox-Laufzeitumgebung

Claude Code bietet eine sichere Remote-Ausführungsumgebung – ohne lokale Sandbox und ohne Sicherheitsrisiko für Ihren Rechner.

response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=8192,
    tools=[{"type": "code_execution_20250825"}],
    messages=[{
        "role": "user",
        "content": "Make the animation more sparkly"
    }]
)

Vorteile einer Sandbox-Umgebung:

• Python, JS und anderen Code sicher ausführen.

• Animationen, Simulationen oder Datentransformationen erstellen und testen.

• Rechenintensive Aufgaben an sichere, von Anthropic verwaltete VMs auslagern.

Claude wird zu einem echten programmierbaren Agenten statt zu einem bloßen Generator.

Das Modell mit Agent Skills ausstatten

Agent Skills sind strukturierte Ordner mit Skripten, Markdown-Anweisungen, Mustern oder Fachwissen, die Claude autonom nutzen kann. Sie ergänzen MCP perfekt:

• MCP verschafft Claude Zugriff auf Tools und Kontext.

• Skills geben Claude das nötige Fachwissen, um diese effektiv einzusetzen.

response = client.beta.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=4096,
    container={
        "skills": [
            {
                "type": "user",
                "skill_id": "web-design-system",
                "version": "latest"
            }
        ]
    },
    messages=[{
        "role": "user",
        "content": "Build a landing page for our new product"
    }],
    tools=[{
        "type": "code_execution_20250825",
        "name": "code_execution"
    }]
)

Agent Skills ermöglichen von Haus aus:

• Fachspezifische Skill-Pakete, etwa für Design-Systeme, DevOps-Workflows oder Debugging.

• Claude entscheidet automatisch, wann ein Skill zum Einsatz kommt.

• Skills, MCP und Tools für vollständige Agent-Autonomie kombinieren.

Mit Skills und MCP wird aus Claude ein intelligenter Assistent und ein vollständig autonomer Full-Stack-Agent.

Sicherheitsleitplanken für autonome Agenten

Die neuen Funktionen von Claude Code – von Agent Skills und Tool-Nutzung bis zur nativen MCP-Integration – erweitern die Grenzen autonomer Entwicklung. Doch sobald Ihre Agenten Code schreiben und ausführen können, entstehen neue Sicherheitsrisiken mit der Geschwindigkeit von KI. Autonome Agenten benötigen Sicherheit von Anfang an.

Die Lösung: Snyk Studio

Snyk Studio ist die umfassende Sicherheitslösung für KI-gestützte Entwicklung. Mit dem Snyk-MCP-Server integriert sie die branchenführende Sicherheitsintelligenz von Snyk direkt in Ihre KI-gestützten Workflows – etwa in Workflows mit Claude Code.

Mit Snyk Studio können Ihre Agenten:

• Autonom scannen: Snyk-Sicherheitsprüfungen (Code, Open Source, IaC) ausführen, bevor Code generiert oder committet wird.

• Richtlinien durchsetzen: Einheitliche Sicherheitsleitplanken auf alle KI-Assistenten anwenden.

• Im KI-Tempo beheben: Mit intelligenter, dialogbasierter Behebung Sicherheitsrückstände schneller abbauen.

Mehr über die Sicherheit von KI-Agenten erfahren

Für einen tieferen technischen Einblick entdecken Sie die Pionierarbeit von Snyk Labs:

1. Den Kontext des Agenten absichern (MCP): Erfahren Sie, wie sich der Standard für sichere KI-Kommunikation weiterentwickelt. Lesen Sie „Snyk trägt neue MCP-Sicherheitskontrollen zum OWASP LLM Security Verification Standard bei.“

2. Die Autonomie Ihres Agenten testen: Erfahren Sie, wie Sie leistungsstarke LLM-Agenten auf Schwachstellen prüfen, bevor sie in die Produktion gelangen. Sehen Sie sich die Demo „Red Teaming für Ihre LLM-Agenten – bevor Angreifer es tun“ an.

Ihre Agenten sind jetzt verbunden. Sind sie auch abgesichert?

Claude-Code-Agenten nutzen den MCP-Server, um sich direkt mit Ihren kritischen Systemen zu verbinden. Diese neue Integrationsstelle muss bei der modernen Sicherheit höchste Priorität haben. Möchten Sie einen praxisnahen Leitfaden zum Schutz dieses wichtigen neuen Ökosystems? Laden Sie noch heute den Guide „Das MCP-Server-Ökosystem absichern“ herunter.