Computernutzung (Beta)

Claude 3.7 Sonnet und Claude 3.5 Sonnet (neu) können mit Tools interagieren, die eine Computer-Desktop-Umgebung manipulieren können. Claude 3.7 Sonnet führt zusätzliche Tools ein und ermöglicht es Ihnen, das Denken zu aktivieren, wodurch Sie mehr Einblick in den Denkprozess des Modells erhalten.

Hier ist ein Beispiel, wie man Claude Computernutzungs-Tools über die Messages API zur Verfügung stellt:

​

Wie die Computernutzung funktioniert

Wir bezeichnen die Wiederholung der Schritte 3 und 4 ohne Benutzereingabe als “Agentenschleife” - d.h. Claude antwortet mit einer Tool-Nutzungsanfrage und Ihre Anwendung antwortet Claude mit den Ergebnissen der Auswertung dieser Anfrage.

​

Die Computerumgebung

Die Computernutzung erfordert eine sandboxed Computerumgebung, in der Claude sicher mit Anwendungen und dem Web interagieren kann. Diese Umgebung umfasst:

1. Virtuelle Anzeige: Ein virtueller X11-Display-Server (mit Xvfb), der die Desktop-Schnittstelle rendert, die Claude durch Screenshots sehen und mit Maus-/Tastaturaktionen steuern wird.

2. Desktop-Umgebung: Eine leichtgewichtige Benutzeroberfläche mit Fenstermanager (Mutter) und Panel (Tint2) unter Linux, die eine konsistente grafische Schnittstelle für Claude bereitstellt.

3. Anwendungen: Vorinstallierte Linux-Anwendungen wie Firefox, LibreOffice, Texteditoren und Dateimanager, die Claude zur Erledigung von Aufgaben nutzen kann.

4. Tool-Implementierungen: Integrationscode, der Claudes abstrakte Tool-Anfragen (wie “Maus bewegen” oder “Screenshot machen”) in tatsächliche Operationen in der virtuellen Umgebung übersetzt.

5. Agentenschleife: Ein Programm, das die Kommunikation zwischen Claude und der Umgebung handhabt, Claudes Aktionen an die Umgebung sendet und die Ergebnisse (Screenshots, Befehlsausgaben) zurück an Claude sendet.

Wenn Sie die Computernutzung verwenden, verbindet sich Claude nicht direkt mit dieser Umgebung. Stattdessen:

1. Empfängt Ihre Anwendung Claudes Tool-Nutzungsanfragen
2. Übersetzt sie in Aktionen in Ihrer Computerumgebung
3. Erfasst die Ergebnisse (Screenshots, Befehlsausgaben, etc.)
4. Gibt diese Ergebnisse an Claude zurück

Aus Sicherheits- und Isolationsgründen läuft die Referenzimplementierung all dies innerhalb eines Docker-Containers mit entsprechenden Port-Mappings für die Anzeige und Interaktion mit der Umgebung.

​

Wie man die Computernutzung implementiert

​

Beginnen Sie mit unserer Referenzimplementierung

Wir haben eine Referenzimplementierung erstellt, die alles enthält, was Sie brauchen, um schnell mit der Computernutzung zu beginnen:

• Eine containerisierte Umgebung, die für die Computernutzung mit Claude geeignet ist
• Implementierungen der Computernutzungs-Tools
• Eine Agentenschleife, die mit der Anthropic API interagiert und die Computernutzungs-Tools ausführt
• Eine Weboberfläche zur Interaktion mit dem Container, der Agentenschleife und den Tools.

​

Verstehen der Multi-Agenten-Schleife

Der Kern der Computernutzung ist die “Agentenschleife” - ein Zyklus, bei dem Claude Tool-Aktionen anfordert, Ihre Anwendung diese ausführt und Ergebnisse an Claude zurückgibt. Hier ist ein vereinfachtes Beispiel:

async def sampling_loop(
    *,
    model: str,
    messages: list[dict],
    api_key: str,
    max_tokens: int = 4096,
    tool_version: str,
    thinking_budget: int | None = None,
    max_iterations: int = 10,  # Iterationslimit hinzufügen, um Endlosschleifen zu verhindern
):
    """
    Eine einfache Agentenschleife für Claude-Computernutzungs-Interaktionen.

    Diese Funktion handhabt das Hin und Her zwischen:
    1. Senden von Benutzernachrichten an Claude
    2. Claude fordert die Verwendung von Tools an
    3. Ihre App führt diese Tools aus
    4. Senden von Tool-Ergebnissen zurück an Claude
    """
    # Tools und API-Parameter einrichten
    client = Anthropic(api_key=api_key)
    beta_flag = "computer-use-2025-01-24" if "20250124" in tool_version else "computer-use-2024-10-22"

    # Tools konfigurieren - diese sollten Sie bereits anderswo initialisiert haben
    tools = [
        {"type": f"computer_{tool_version}", "name": "computer", "display_width_px": 1024, "display_height_px": 768},
        {"type": f"text_editor_{tool_version}", "name": "str_replace_editor"},
        {"type": f"bash_{tool_version}", "name": "bash"}
    ]

    # Haupt-Agentenschleife (mit Iterationslimit zur Vermeidung unkontrollierter API-Kosten)
    iterations = 0
    while True and iterations < max_iterations:
        iterations += 1
        # Optionalen Thinking-Parameter einrichten (für Claude 3.7 Sonnet)
        thinking = None
        if thinking_budget:
            thinking = {"type": "enabled", "budget_tokens": thinking_budget}

        # Claude API aufrufen
        response = client.beta.messages.create(
            model=model,
            max_tokens=max_tokens,
            messages=messages,
            tools=tools,
            betas=[beta_flag],
            thinking=thinking
        )

        # Claudes Antwort zum Konversationsverlauf hinzufügen
        response_content = response.content
        messages.append({"role": "assistant", "content": response_content})

        # Prüfen, ob Claude Tools verwendet hat
        tool_results = []
        for block in response_content:
            if block.type == "tool_use":
                # In einer echten App würden Sie das Tool hier ausführen
                # Zum Beispiel: result = run_tool(block.name, block.input)
                result = {"result": "Tool erfolgreich ausgeführt"}

                # Das Ergebnis für Claude formatieren
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": result
                })

        # Wenn keine Tools verwendet wurden, ist Claude fertig - finale Nachrichten zurückgeben
        if not tool_results:
            return messages

        # Tool-Ergebnisse zu Nachrichten für die nächste Iteration mit Claude hinzufügen
        messages.append({"role": "user", "content": tool_results})

Die Schleife läuft weiter, bis entweder Claude ohne Anforderung von Tools antwortet (Aufgabenabschluss) oder das maximale Iterationslimit erreicht ist. Diese Sicherung verhindert potenzielle Endlosschleifen, die zu unerwarteten API-Kosten führen könnten.

Wir empfehlen, die Referenzimplementierung auszuprobieren, bevor Sie den Rest dieser Dokumentation lesen.

​

Modellleistung mit Prompting optimieren

Hier sind einige Tipps, wie Sie die beste Ausgabequalität erhalten:

1. Spezifizieren Sie einfache, klar definierte Aufgaben und geben Sie explizite Anweisungen für jeden Schritt.
2. Claude nimmt manchmal Ergebnisse seiner Aktionen an, ohne deren Ergebnisse explizit zu überprüfen. Um dies zu verhindern, können Sie Claude mit folgendem Prompt anweisen: Machen Sie nach jedem Schritt einen Screenshot und prüfen Sie sorgfältig, ob Sie das richtige Ergebnis erreicht haben. Zeigen Sie Ihr Denken explizit: "Ich habe Schritt X ausgewertet..." Wenn nicht korrekt, versuchen Sie es erneut. Gehen Sie erst zum nächsten Schritt über, wenn Sie bestätigt haben, dass ein Schritt korrekt ausgeführt wurde.
3. Einige UI-Elemente (wie Dropdown-Menüs und Scrollbalken) können für Claude schwierig sein, mit Mausbewegungen zu manipulieren. Wenn Sie dies erleben, versuchen Sie, das Modell zur Verwendung von Tastaturkürzeln aufzufordern.
4. Fügen Sie für wiederholbare Aufgaben oder UI-Interaktionen Beispiel-Screenshots und Tool-Aufrufe erfolgreicher Ergebnisse in Ihren Prompt ein.
5. Wenn Sie möchten, dass sich das Modell anmeldet, geben Sie ihm Benutzername und Passwort in Ihrem Prompt innerhalb von XML-Tags wie <robot_credentials>. Die Verwendung der Computernutzung in Anwendungen, die eine Anmeldung erfordern, erhöht das Risiko schlechter Ergebnisse durch Prompt-Injection. Bitte lesen Sie unseren Leitfaden zur Abschwächung von Prompt-Injections, bevor Sie dem Modell Anmeldedaten zur Verfügung stellen.

​

System-Prompts

Wenn eines der von Anthropic definierten Tools über die Anthropic API angefordert wird, wird ein computernutzungsspezifischer System-Prompt generiert. Er ähnelt dem Tool-Use-System-Prompt, beginnt aber mit:

Sie haben Zugriff auf eine Reihe von Funktionen, die Sie zur Beantwortung der Frage des Benutzers verwenden können. Dies beinhaltet den Zugriff auf eine sandboxed Computerumgebung. Sie haben derzeit NICHT die Möglichkeit, Dateien zu inspizieren oder mit externen Ressourcen zu interagieren, außer durch Aufruf der unten stehenden Funktionen.

Wie bei der regulären Tool-Nutzung wird das vom Benutzer bereitgestellte system_prompt-Feld weiterhin respektiert und bei der Konstruktion des kombinierten System-Prompts verwendet.

​

Anthropic-definierte Tools verstehen

Wir haben eine Reihe von Tools bereitgestellt, die es Claude ermöglichen, Computer effektiv zu nutzen. Bei der Spezifikation eines von Anthropic definierten Tools sind die Felder description und tool_schema nicht notwendig oder erlaubt.

Wir stellen eine Reihe von Anthropic-definierten Tools bereit, wobei jedes Tool Versionen hat, die sowohl für Claude 3.5 Sonnet (neu) als auch für Claude 3.7 Sonnet optimiert sind:

Das type-Feld identifiziert das Tool und seine Parameter für Validierungszwecke, das name-Feld ist der Tool-Name, der dem Modell zur Verfügung gestellt wird.

Wenn Sie das Modell auffordern möchten, eines dieser Tools zu verwenden, können Sie explizit auf das Tool über das name-Feld verweisen. Das name-Feld muss innerhalb der Tool-Liste eindeutig sein; Sie können kein Tool mit demselben Namen wie ein von Anthropic definiertes Tool im selben API-Aufruf definieren.

Verwenden Sie eine Maus und Tastatur, um mit einem Computer zu interagieren und Screenshots zu machen.
* Dies ist eine Schnittstelle zu einer Desktop-GUI. Sie haben keinen Zugriff auf ein Terminal oder Anwendungsmenü. Sie müssen auf Desktop-Icons klicken, um Anwendungen zu starten.
* Einige Anwendungen können Zeit benötigen, um zu starten oder Aktionen zu verarbeiten, daher müssen Sie möglicherweise warten und aufeinanderfolgende Screenshots machen, um die Ergebnisse Ihrer Aktionen zu sehen. Wenn Sie z.B. auf Firefox klicken und sich kein Fenster öffnet, versuchen Sie einen weiteren Screenshot zu machen.
* Die Bildschirmauflösung beträgt {{ display_width_px }}x{{ display_height_px }}.
* Die Display-Nummer ist {{ display_number }}
* Wenn Sie beabsichtigen, den Cursor zu bewegen, um auf ein Element wie ein Icon zu klicken, sollten Sie einen Screenshot konsultieren, um die Koordinaten des Elements zu bestimmen, bevor Sie den Cursor bewegen.
* Wenn Sie versucht haben, auf ein Programm oder einen Link zu klicken, aber es nicht geladen wurde, auch nach dem Warten, versuchen Sie die Cursorposition so anzupassen, dass die Cursorspitze visuell auf dem Element liegt, auf das Sie klicken möchten.
* Stellen Sie sicher, dass Sie auf Schaltflächen, Links, Icons etc. mit der Cursorspitze in der Mitte des Elements klicken. Klicken Sie nicht auf die Ränder von Boxen, es sei denn, Sie werden dazu aufgefordert.

{
    "properties": {
        "action": {
            "description": "Die auszuführende Aktion. Die verfügbaren Aktionen sind:\n"
            "* `key`: Eine Taste oder Tastenkombination auf der Tastatur drücken.\n"
            "  - Dies unterstützt xdotool's `key`-Syntax.\n"
            '  - Beispiele: "a", "Return", "alt+Tab", "ctrl+s", "Up", "KP_0" (für die Numpad 0 Taste).\n'
            "* `hold_key`: Eine Taste oder mehrere Tasten für eine bestimmte Dauer (in Sekunden) gedrückt halten. Unterstützt die gleiche Syntax wie `key`.\n"
            "* `type`: Eine Zeichenkette auf der Tastatur eingeben.\n"
            "* `cursor_position`: Die aktuelle (x, y) Pixelkoordinate des Cursors auf dem Bildschirm abrufen.\n"
            "* `mouse_move`: Den Cursor zu einer bestimmten (x, y) Pixelkoordinate auf dem Bildschirm bewegen.\n"
            "* `left_mouse_down`: Die linke Maustaste drücken.\n"
            "* `left_mouse_up`: Die linke Maustaste loslassen.\n"
            "* `left_click`: Die linke Maustaste an der angegebenen (x, y) Pixelkoordinate auf dem Bildschirm klicken. Sie können auch eine Tastenkombination zum Halten während des Klickens mit dem `text`-Parameter einschließen.\n"
            "* `left_click_drag`: Klicken und den Cursor von `start_coordinate` zu einer bestimmten (x, y) Pixelkoordinate auf dem Bildschirm ziehen.\n"
            "* `right_click`: Die rechte Maustaste an der angegebenen (x, y) Pixelkoordinate auf dem Bildschirm klicken.\n"
            "* `middle_click`: Die mittlere Maustaste an der angegebenen (x, y) Pixelkoordinate auf dem Bildschirm klicken.\n"
            "* `double_click`: Doppelklick mit der linken Maustaste an der angegebenen (x, y) Pixelkoordinate auf dem Bildschirm.\n"
            "* `triple_click`: Dreifachklick mit der linken Maustaste an der angegebenen (x, y) Pixelkoordinate auf dem Bildschirm.\n"
            "* `scroll`: Den Bildschirm in eine bestimmte Richtung um eine bestimmte Anzahl von Klicks des Scrollrads an der angegebenen (x, y) Pixelkoordinate scrollen. Verwenden Sie NICHT PageUp/PageDown zum Scrollen.\n"
            "* `wait`: Eine bestimmte Dauer (in Sekunden) warten.\n"
            "* `screenshot`: Einen Screenshot des Bildschirms machen.",
            "enum": [
                "key",
                "hold_key",
                "type",
                "cursor_position",
                "mouse_move",
                "left_mouse_down",
                "left_mouse_up",
                "left_click",
                "left_click_drag",
                "right_click",
                "middle_click",
                "double_click",
                "triple_click",
                "scroll",
                "wait",
                "screenshot",
            ],
            "type": "string",
        },
        "coordinate": {
            "description": "(x, y): Die x (Pixel vom linken Rand) und y (Pixel vom oberen Rand) Koordinaten, zu denen die Maus bewegt werden soll. Nur erforderlich bei `action=mouse_move` und `action=left_click_drag`.",
            "type": "array",
        },
        "duration": {
            "description": "Die Dauer, für die die Taste gedrückt gehalten werden soll. Nur erforderlich bei `action=hold_key` und `action=wait`.",
            "type": "integer",
        },
        "scroll_amount": {
            "description": "Die Anzahl der 'Klicks' zum Scrollen. Nur erforderlich bei `action=scroll`.",
            "type": "integer",
        },
        "scroll_direction": {
            "description": "Die Richtung, in die der Bildschirm gescrollt werden soll. Nur erforderlich bei `action=scroll`.",
            "enum": ["up", "down", "left", "right"],
            "type": "string",
        },
        "start_coordinate": {
            "description": "(x, y): Die x (Pixel vom linken Rand) und y (Pixel vom oberen Rand) Koordinaten, von denen aus das Ziehen beginnen soll. Nur erforderlich bei `action=left_click_drag`.",
            "type": "array",
        },
        "text": {
            "description": "Nur erforderlich bei `action=type`, `action=key` und `action=hold_key`. Kann auch bei Klick- oder Scroll-Aktionen verwendet werden, um Tasten während des Klickens oder Scrollens gedrückt zu halten.",
            "type": "string",
        },
    },
    "required": ["action"],
    "type": "object",
}

{
    "properties": {
        "action": {
            "description": """Die auszuführende Aktion. Die verfügbaren Aktionen sind:
                * `key`: Eine Taste oder Tastenkombination auf der Tastatur drücken.
                  - Dies unterstützt xdotool's `key`-Syntax.
                  - Beispiele: "a", "Return", "alt+Tab", "ctrl+s", "Up", "KP_0" (für die Numpad 0 Taste).
                * `type`: Eine Zeichenkette auf der Tastatur eingeben.
                * `cursor_position`: Die aktuelle (x, y) Pixelkoordinate des Cursors auf dem Bildschirm abrufen.
                * `mouse_move`: Den Cursor zu einer bestimmten (x, y) Pixelkoordinate auf dem Bildschirm bewegen.
                * `left_click`: Die linke Maustaste klicken.
                * `left_click_drag`: Klicken und den Cursor zu einer bestimmten (x, y) Pixelkoordinate auf dem Bildschirm ziehen.
                * `right_click`: Die rechte Maustaste klicken.
                * `middle_click`: Die mittlere Maustaste klicken.
                * `double_click`: Doppelklick mit der linken Maustaste.
                * `screenshot`: Einen Screenshot des Bildschirms machen.""",
            "enum": [
                "key",
                "type",
                "mouse_move",
                "left_click",
                "left_click_drag",
                "right_click",
                "middle_click",
                "double_click",
                "screenshot",
                "cursor_position",
            ],
            "type": "string",
        },
        "coordinate": {
            "description": "(x, y): Die x (Pixel vom linken Rand) und y (Pixel vom oberen Rand) Koordinaten, zu denen die Maus bewegt werden soll. Nur erforderlich bei `action=mouse_move` und `action=left_click_drag`.",
            "type": "array",
        },
        "text": {
            "description": "Nur erforderlich bei `action=type` und `action=key`.",
            "type": "string",
        },
    },
    "required": ["action"],
    "type": "object",
}

Benutzerdefiniertes Bearbeitungstool zum Anzeigen, Erstellen und Bearbeiten von Dateien
* Der Status bleibt über Befehlsaufrufe und Diskussionen mit dem Benutzer hinweg erhalten
* Wenn `path` eine Datei ist, zeigt `view` das Ergebnis von `cat -n` an. Wenn `path` ein Verzeichnis ist, listet `view` nicht versteckte Dateien und Verzeichnisse bis zu 2 Ebenen tief auf
* Der `create`-Befehl kann nicht verwendet werden, wenn der angegebene `path` bereits als Datei existiert
* Wenn ein `command` eine lange Ausgabe generiert, wird sie abgeschnitten und mit `<response clipped>` markiert
* Der `undo_edit`-Befehl macht die letzte Bearbeitung an der Datei bei `path` rückgängig

Hinweise zur Verwendung des `str_replace`-Befehls:
* Der `old_str`-Parameter sollte EXAKT eine oder mehrere aufeinanderfolgende Zeilen aus der Originaldatei entsprechen. Achten Sie auf Leerzeichen!
* Wenn der `old_str`-Parameter in der Datei nicht eindeutig ist, wird der Ersatz nicht durchgeführt. Stellen Sie sicher, dass Sie genügend Kontext in `old_str` einschließen, um ihn eindeutig zu machen
* Der `new_str`-Parameter sollte die bearbeiteten Zeilen enthalten, die `old_str` ersetzen sollen

{
    "properties": {
        "command": {
            "description": "Die auszuführenden Befehle. Erlaubte Optionen sind: `view`, `create`, `str_replace`, `insert`, `undo_edit`.",
            "enum": ["view", "create", "str_replace", "insert", "undo_edit"],
            "type": "string",
        },
        "file_text": {
            "description": "Erforderlicher Parameter des `create`-Befehls, mit dem Inhalt der zu erstellenden Datei.",
            "type": "string",
        },
        "insert_line": {
            "description": "Erforderlicher Parameter des `insert`-Befehls. Der `new_str` wird NACH der Zeile `insert_line` von `path` eingefügt.",
            "type": "integer",
        },
        "new_str": {
            "description": "Optionaler Parameter des `str_replace`-Befehls, der die neue Zeichenkette enthält (wenn nicht angegeben, wird keine Zeichenkette hinzugefügt). Erforderlicher Parameter des `insert`-Befehls, der die einzufügende Zeichenkette enthält.",
            "type": "string",
        },
        "old_str": {
            "description": "Erforderlicher Parameter des `str_replace`-Befehls, der die zu ersetzende Zeichenkette in `path` enthält.",
            "type": "string",
        },
        "path": {
            "description": "Absoluter Pfad zu Datei oder Verzeichnis, z.B. `/repo/file.py` oder `/repo`.",
            "type": "string",
        },
        "view_range": {
            "description": "Optionaler Parameter des `view`-Befehls, wenn `path` auf eine Datei zeigt. Wenn keiner angegeben ist, wird die gesamte Datei angezeigt. Wenn angegeben, wird die Datei im angegebenen Zeilennummernbereich angezeigt, z.B. [11, 12] zeigt die Zeilen 11 und 12. Indexierung bei 1 beginnend. Die Einstellung `[start_line, -1]` zeigt alle Zeilen von `start_line` bis zum Ende der Datei.",
            "items": {"type": "integer"},
            "type": "array",
        },
    },
    "required": ["command", "path"],
    "type": "object",
}

Befehle in einer Bash-Shell ausführen
* Bei der Verwendung dieses Tools muss der Inhalt des "command"-Parameters NICHT XML-escaped sein.
* Sie haben Zugriff auf einen Spiegel von gängigen Linux- und Python-Paketen über apt und pip.
* Der Status bleibt über Befehlsaufrufe und Diskussionen mit dem Benutzer hinweg erhalten.
* Um einen bestimmten Zeilenbereich einer Datei zu inspizieren, z.B. Zeilen 10-25, versuchen Sie 'sed -n 10,25p /pfad/zur/datei'.
* Bitte vermeiden Sie Befehle, die eine sehr große Menge an Ausgabe produzieren könnten.
* Bitte führen Sie langlebige Befehle im Hintergrund aus, z.B. 'sleep 10 &' oder starten Sie einen Server im Hintergrund.

{
    "properties": {
        "command": {
            "description": "Der auszuführende Bash-Befehl. Erforderlich, es sei denn, das Tool wird neu gestartet.",
            "type": "string",
        },
        "restart": {
            "description": "Die Angabe von true startet dieses Tool neu. Andernfalls lassen Sie dies unspezifiziert.",
            "type": "boolean",
        },
    }
}

​

Denkfähigkeit in Claude 3.7 Sonnet aktivieren

Claude 3.7 Sonnet führt eine neue “Denkfähigkeit” ein, die es Ihnen ermöglicht, den Denkprozess des Modells zu sehen, während es komplexe Aufgaben bearbeitet. Diese Funktion hilft Ihnen zu verstehen, wie Claude ein Problem angeht und kann besonders wertvoll für Debugging oder Bildungszwecke sein.

Um das Denken zu aktivieren, fügen Sie einen thinking-Parameter zu Ihrer API-Anfrage hinzu:

"thinking": {
  "type": "enabled",
  "budget_tokens": 1024
}

Der budget_tokens-Parameter gibt an, wie viele Token Claude für das Denken verwenden kann. Dies wird von Ihrem gesamten max_tokens-Budget abgezogen.

Wenn das Denken aktiviert ist, wird Claude seinen Denkprozess als Teil der Antwort zurückgeben, was Ihnen helfen kann:

1. Den Entscheidungsprozess des Modells zu verstehen
2. Potenzielle Probleme oder Missverständnisse zu identifizieren
3. Von Claudes Herangehensweise an Problemlösungen zu lernen
4. Mehr Einblick in komplexe mehrstufige Operationen zu bekommen

Hier ist ein Beispiel, wie die Denkausgabe aussehen könnte:

[Thinking]
Ich muss ein Bild einer Katze auf dem Desktop speichern. Lassen Sie mich dies in Schritte aufteilen:

1. Zuerst mache ich einen Screenshot, um zu sehen, was auf dem Desktop ist
2. Dann suche ich nach einem Webbrowser, um nach Katzenbildern zu suchen
3. Nachdem ich ein geeignetes Bild gefunden habe, muss ich es auf dem Desktop speichern

Lassen Sie mich damit beginnen, einen Screenshot zu machen, um zu sehen, was verfügbar ist...

​

Computernutzung mit anderen Tools kombinieren

Sie können reguläre Tool-Nutzung mit den von Anthropic definierten Tools für die Computernutzung kombinieren.

​

Eine benutzerdefinierte Computernutzungsumgebung erstellen

Die Referenzimplementierung soll Ihnen helfen, mit der Computernutzung zu beginnen. Sie enthält alle Komponenten, die benötigt werden, damit Claude einen Computer nutzen kann. Sie können jedoch Ihre eigene Umgebung für die Computernutzung erstellen, die Ihren Bedürfnissen entspricht. Sie benötigen:

• Eine virtualisierte oder containerisierte Umgebung, die für die Computernutzung mit Claude geeignet ist
• Eine Implementierung von mindestens einem der von Anthropic definierten Computernutzungs-Tools
• Eine Agentenschleife, die mit der Anthropic API interagiert und die tool_use-Ergebnisse mit Ihren Tool-Implementierungen ausführt
• Eine API oder UI, die Benutzereingaben ermöglicht, um die Agentenschleife zu starten

​

Einschränkungen der Computernutzung verstehen

Die Computernutzungsfunktionalität befindet sich in der Beta-Phase. Während Claudes Fähigkeiten hochmodern sind, sollten Entwickler sich seiner Einschränkungen bewusst sein:

1. Latenz: die aktuelle Computernutzungslatenz für Mensch-KI-Interaktionen könnte im Vergleich zu regulären menschengesteuerten Computeraktionen zu langsam sein. Wir empfehlen, sich auf Anwendungsfälle zu konzentrieren, bei denen Geschwindigkeit nicht kritisch ist (z.B. Hintergrundinformationssammlung, automatisierte Softwaretests) in vertrauenswürdigen Umgebungen.
2. Computervision-Genauigkeit und -Zuverlässigkeit: Claude kann Fehler machen oder halluzinieren, wenn es spezifische Koordinaten bei der Generierung von Aktionen ausgibt. Claude 3.7 Sonnet führt die Denkfähigkeit ein, die Ihnen helfen kann, den Denkprozess des Modells zu verstehen und potenzielle Probleme zu identifizieren.
3. Tool-Auswahl-Genauigkeit und -Zuverlässigkeit: Claude kann Fehler machen oder halluzinieren bei der Auswahl von Tools während der Generierung von Aktionen oder unerwartete Aktionen zur Problemlösung ausführen. Zusätzlich kann die Zuverlässigkeit niedriger sein bei der Interaktion mit Nischenanwendungen oder mehreren Anwendungen gleichzeitig. Wir empfehlen, dass Benutzer das Modell sorgfältig prompen, wenn sie komplexe Aufgaben anfordern.
4. Scroll-Zuverlässigkeit: Während Claude 3.5 Sonnet (neu) Einschränkungen beim Scrollen hatte, führt Claude 3.7 Sonnet dedizierte Scroll-Aktionen mit Richtungssteuerung ein, die die Zuverlässigkeit verbessern. Das Modell kann jetzt explizit in jede Richtung (hoch/runter/links/rechts) um eine bestimmte Menge scrollen.
5. Tabellenkalkulationsinteraktion: Mausklicks für Tabellenkalkulationsinteraktion wurden in Claude 3.7 Sonnet mit der Hinzufügung von präziseren Maussteuerungsaktionen wie left_mouse_down, left_mouse_up und neuer Modifikatortastenunterstützung verbessert. Die Zellauswahl kann zuverlässiger sein durch die Verwendung dieser feingranularen Steuerungen und die Kombination von Modifikatortasten mit Klicks.
6. Kontoerstellung und Inhaltsgenerierung auf sozialen und Kommunikationsplattformen: Während Claude Websites besucht, beschränken wir seine Fähigkeit, Konten zu erstellen oder Inhalte zu generieren und zu teilen oder anderweitig menschliche Impersonation über Social-Media-Websites und -Plattformen zu betreiben. Wir könnten diese Fähigkeit in Zukunft aktualisieren.
7. Schwachstellen: Schwachstellen wie Jailbreaking oder Prompt-Injection können über Frontier-KI-Systeme hinweg bestehen bleiben, einschließlich der Beta-Computer-Use-API. Unter bestimmten Umständen wird Claude Befehle in Inhalten befolgen, manchmal sogar im Widerspruch zu den Anweisungen des Benutzers. Zum Beispiel können Claude-Anweisungen auf Webseiten oder in Bildern enthaltene Anweisungen überschreiben oder dazu führen, dass Claude Fehler macht. Wir empfehlen: a. Beschränkung der Computernutzung auf vertrauenswürdige Umgebungen wie virtuelle Maschinen oder Container mit minimalen Berechtigungen b. Vermeidung der Gewährung von Computernutzungszugriff auf sensible Konten oder Daten ohne strenge Überwachung c. Information der Endbenutzer über relevante Risiken und Einholung ihrer Einwilligung vor der Aktivierung oder Anforderung von Berechtigungen, die für Computernutzungsfunktionen in Ihren Anwendungen erforderlich sind
8. Unangemessene oder illegale Aktionen: Gemäß Anthropics Nutzungsbedingungen dürfen Sie die Computernutzung nicht einsetzen, um Gesetze oder unsere Acceptable Use Policy zu verletzen.

Überprüfen Sie immer sorgfältig Claudes Computernutzungsaktionen und -protokolle. Verwenden Sie Claude nicht für Aufgaben, die perfekte Präzision oder sensible Benutzerinformationen ohne menschliche Überwachung erfordern.

​

Preisgestaltung

Als Teilmenge von Tool-Use-Anfragen werden Computernutzungsanfragen genauso bepreist wie jede andere Claude API-Anfrage.

Wir fügen auch automatisch einen speziellen System-Prompt für das Modell hinzu, der die Computernutzung ermöglicht.

Zusätzlich zu den Basis-Token werden die folgenden zusätzlichen Input-Token für die von Anthropic definierten Tools benötigt:

Wenn Sie das Denken mit Claude 3.7 Sonnet aktivieren, werden die für das Denken verwendeten Token gegen Ihr max_tokens-Budget basierend auf den budget_tokens angerechnet, die Sie im Thinking-Parameter angeben.