Claude Platform Docs
MessagesTools

Computer-Use-Tool

Gib Claude mit dem Computer-Use-Tool, dem Client-Toolset computer_toolset_20260801, die Steuerung einer Desktop-Umgebung über Screenshots, Maus und Tastatur.

Claude kann über das „computer use tool“ (Computer-Use-Tool) mit Computerumgebungen interagieren. Es bietet Screenshot-Funktionen sowie Maus- und Tastatursteuerung für autonome Desktop-Interaktion.

Das Computer-Use-Tool ist ein von Anthropic definiertes „client toolset“ (Client-Toolset): Ein einziger Eintrag {"type": "computer_toolset_20260801"} in tools gibt Claude 17 Member-Tools wie screenshot, left_click, type und zoom, und deine Anwendung führt jeden Aufruf in einer Umgebung aus, die du kontrollierst. Es ist derzeit nicht in Claude Managed Agents verfügbar. Claudes Aufrufe sind tool_use-Blöcke, deren name das Member ist und die "toolset_name": "computer" enthalten, oft mehrere in einem Zug (eine Batch-Aktion).

Für Aufgaben, die innerhalb von Webseiten bleiben, ist das Browser-Use-Tool besser geeignet: Seine Member-Tools lesen die Seite selbst und agieren direkt auf ihr, und es benötigt keine vollständige Desktop-Umgebung.

Unter API-Unterstützung findest du die Modelle und Plattformen, die das Toolset unterstützen. Frühere Tool-Versionen listet für jede frühere Version den Beta-Header und die Modelle auf, mit denen sie verwendet werden kann.

Sicherheitsaspekte

Computer Use birgt besondere Risiken, die sich von denen der Standard-API-Funktionen unterscheiden. Diese Risiken sind bei der Interaktion mit dem Internet erhöht.

Unter bestimmten Umständen befolgt Claude Befehle, die in Inhalten gefunden werden, selbst wenn sie deinen Anweisungen widersprechen. Beispielsweise können Anweisungen auf Webseiten oder in Bildern deine Anweisungen überschreiben oder Claude zu Fehlern veranlassen. Triff Vorsichtsmaßnahmen, um Claude von sensiblen Daten und Aktionen zu isolieren und so Risiken im Zusammenhang mit „prompt injection“ (Prompt-Injection) zu vermeiden.

Anthropic hat das Modell darauf trainiert, diesen Prompt-Injections zu widerstehen, und eine zusätzliche Verteidigungsebene hinzugefügt. Wenn du das Computer-Use-Tool verwendest, scannen Klassifikatoren automatisch, was das Tool zurückgibt, etwa Screenshots, um potenzielle Prompt-Injections zu markieren. Wenn diese Klassifikatoren eine potenzielle Prompt-Injection erkennen, veranlassen sie das Modell zu prüfen, ob die Anweisung wirklich von dir stammt, bevor es danach handelt.

Dieser zusätzliche Schutz ist nicht für jeden Anwendungsfall ideal (zum Beispiel für Anwendungsfälle ohne menschliche Beteiligung). Wenn du ihn abwählen und deaktivieren möchtest, kontaktiere den Support. Die zuvor aufgeführten Vorsichtsmaßnahmen bleiben auch mit diesen Klassifikatoren wichtig.

Informiere Endnutzer über relevante Risiken und hole ihre Zustimmung ein, bevor du Computer Use in deinen eigenen Produkten aktivierst.

Schnellstart

Füge das Computer-Use-Toolset als {"type": "computer_toolset_20260801"} zum tools-Array einer Messages APIVorschau mit Links zur API-Referenz verfügbar – drücke Tab, bis der Fokus in die Karte wechselt, und Escape, um zurückzukehren.-Anfrage hinzu. Die Anfrage benötigt keinen Beta-Header. Dieses Beispiel deklariert außerdem das Text-Editor-Tool und das Bash-Tool, die Claude typischerweise zusammen mit Computer Use verwendet:

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    tools=[
        {"type": "computer_toolset_20260801"},
        {"type": "text_editor_20250728", "name": "str_replace_based_edit_tool"},
        {"type": "bash_20250124", "name": "bash"},
    ],
    messages=[{"role": "user", "content": "Save a picture of a cat to my desktop."}],
)
print(response)

Wenn Claude auf dem Desktop agiert, hat die Antwort einen stop_reason von tool_use und enthält einen oder mehrere Member-tool_use-Blöcke, die jeweils ein Member-Tool benennen und "toolset_name": "computer" enthalten. Mitten in dieser Aufgabe, nachdem Claude einen Screenshot des Desktops erhalten hat, könnte eine Antwort so aussehen:

Output
{
  "id": "msg_01UZ3bXcQH8mTqNhVfL9eK2p",
  "type": "message",
  "role": "assistant",
  "model": "claude-opus-5-5",
  "content": [
    {
      "type": "text",
      "text": "I'll open the web browser to find a picture of a cat."
    },
    {
      "type": "tool_use",
      "id": "toolu_01WkoTUvSHDzTBu2xnGk8Ep8",
      "name": "left_click",
      "toolset_name": "computer",
      "input": { "coordinate": [512, 742] }
    },
    {
      "type": "tool_use",
      "id": "toolu_017nJn3RgSCkTMwuZDb4uUov",
      "name": "screenshot",
      "toolset_name": "computer",
      "input": {}
    }
  ],
  "stop_reason": "tool_use",
  "stop_sequence": null
}

Deine Anwendung führt jeden Aufruf der Reihe nach in deiner eigenen Umgebung aus, gibt für jeden tool_use-Block einen tool_result-Block zurück und ruft die API erneut auf; Wie Computer Use funktioniert beschreibt diese Schleife, und der Rest dieser Seite zeigt, wie du sie implementierst.


Wie Computer Use funktioniert

  1. Stelle Claude das Computer-Use-Tool und einen Nutzer-Prompt bereit

    • Füge das Computer-Use-Toolset (und optional weitere Tools) zum tools-Array deiner API-Anfrage hinzu.
    • Füge einen Nutzer-Prompt hinzu, der Desktop-Interaktion erfordert, zum Beispiel „Speichere ein Bild einer Katze auf meinem Desktop.“
  2. Claude antwortet mit Member-Tool-Aufrufen

    • Claude beurteilt, ob Aktionen auf dem Desktop bei der Anfrage des Nutzers helfen können.
    • Falls ja, antwortet Claude mit einem oder mehreren Member-tool_use-Blöcken wie screenshot, left_click oder type, die jeweils "toolset_name": "computer" enthalten. Eine Antwort mit mehreren solchen Blöcken ist eine Batch-Aktion.
    • Die API-Antwort hat einen stop_reason von tool_use, was eine Anfrage zur Tool-Nutzung signalisiert.
  3. Führe die Aufrufe der Reihe nach aus und gib Ergebnisse zurück

    • Iteriere der Reihe nach über jeden tool_use-Block in der Antwort. Verzweige für jeden anhand des Member-name zusammen mit toolset_name und führe diese Aktion mit dem input des Blocks auf deinem Container oder deiner virtuellen Maschine aus.
    • Setze die Unterhaltung mit einer neuen user-Nachricht fort, die für jeden tool_use-Block einen tool_result-Block enthält, zugeordnet über tool_use_id und jeweils mit "toolset_name": "computer". Gib für screenshot und zoom ein Bild zurück; für die anderen Aktionen genügt ein kurzer Text wie OK.
    • Wenn eine Aktion fehlschlägt, gib für diesen Block is_error: true zurück und beantworte den Rest des Batches wie unter Batch-Aktionen beschrieben.
  4. Claude fährt fort, bis die Aufgabe abgeschlossen ist

    • Claude analysiert die Tool-Ergebnisse, um festzustellen, ob weitere Aktionen nötig sind oder die Aufgabe abgeschlossen ist.
    • Wenn Claude feststellt, dass weitere Aktionen nötig sind, antwortet es mit einem weiteren tool_use-stop_reason; kehre zu Schritt 3 zurück.
    • Andernfalls gibt es eine Textantwort an den Nutzer zurück.

Die Schritte 3 und 4, ohne Nutzereingabe wiederholt, bilden die „agent loop“ (Agenten-Schleife): Claude antwortet mit einer Anfrage zur Tool-Nutzung, und deine Anwendung antwortet Claude mit den Ergebnissen der Auswertung dieser Anfrage.

Batch-Aktionen

Claude kann eine kurze Abfolge von Aktionen planen, etwa klicken, tippen und dann einen Screenshot aufnehmen, und sie gemeinsam in einer Antwort zurückgeben. Dies wird als „batch action“ (Batch-Aktion) bezeichnet; sie verwendet dieselbe Antwortstruktur wie die parallele Tool-Nutzung, mit einem Unterschied: Du führst die Blöcke der Reihe nach statt gleichzeitig aus.

Eine Antwort mit einem Batch aus drei Aktionen sieht so aus:

{
  "role": "assistant",
  "content": [
    {
      "type": "tool_use",
      "id": "toolu_01HqCF3nJ4Vzr8sTkPZ2wxYA",
      "name": "left_click",
      "toolset_name": "computer",
      "input": { "coordinate": [640, 60] }
    },
    {
      "type": "tool_use",
      "id": "toolu_01Ppr3sZ3TnE9m6VUu4RyH2K",
      "name": "type",
      "toolset_name": "computer",
      "input": { "text": "pictures of cats" }
    },
    {
      "type": "tool_use",
      "id": "toolu_01Xf5W1sD8Q9aBcJ7kLmN2pQ",
      "name": "screenshot",
      "toolset_name": "computer",
      "input": {}
    }
  ]
}

Gib für jeden tool_use-Block einen tool_result-Block zurück, zugeordnet über tool_use_id, alle in der nächsten user-Nachricht. Jedes Ergebnis für ein Member-Tool muss "toolset_name": "computer" enthalten; ein Ergebnis, das es weglässt oder ein anderes Toolset als sein tool_use-Block nennt, wird abgelehnt. Nur die Ergebnisse von screenshot und zoom benötigen ein Bild; für die anderen Members genügt eine kurze Textbestätigung wie OK (cursor_position gibt die Koordinaten als Text zurück):

{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01HqCF3nJ4Vzr8sTkPZ2wxYA",
      "toolset_name": "computer",
      "content": [{ "type": "text", "text": "OK" }]
    },
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01Ppr3sZ3TnE9m6VUu4RyH2K",
      "toolset_name": "computer",
      "content": [{ "type": "text", "text": "OK" }]
    },
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01Xf5W1sD8Q9aBcJ7kLmN2pQ",
      "toolset_name": "computer",
      "content": [
        {
          "type": "image",
          "source": {
            "type": "base64",
            "media_type": "image/png",
            "data": "iVBORw0KGgo..."
          }
        }
      ]
    }
  ]
}

Führe Blöcke der Reihe nach aus und stoppe beim ersten Fehler. Spätere Aktionen in einem Batch hängen meist von früheren ab: Das type in diesem Beispiel gibt Text in das Element ein, das der vorherige Klick fokussiert hat. Führe die Blöcke nacheinander in der Reihenfolge aus, in der sie in content erscheinen, und wenn einer fehlschlägt, führe die restlichen nicht aus. Jeder tool_use-Block benötigt trotzdem ein tool_result, also beantworte den Batch wie folgt:

  • Gib für jede erfolgreiche Aktion ihr normales Ergebnis zurück.
  • Gib für die fehlgeschlagene Aktion is_error: true mit einer Textbeschreibung dessen zurück, was schiefgelaufen ist.
  • Gib für jede spätere Aktion im Batch is_error: true mit genau diesem Text zurück (das Browser-Use-Tool verwendet seinen eigenen Abbruchtext):
{
  "type": "tool_result",
  "tool_use_id": "toolu_01Xf5W1sD8Q9aBcJ7kLmN2pQ",
  "toolset_name": "computer",
  "is_error": true,
  "content": "Not executed: an earlier computer action in this turn failed."
}

Claude liest dann, welche Aktionen erfolgreich waren, welche fehlgeschlagen ist und welche übersprungen wurden, und plant in seinem nächsten Zug neu. Eine Anfrage, die einen tool_use-Block im Batch unbeantwortet lässt, wird mit einem invalid_request_error abgelehnt, sodass eine Agenten-Schleife, die nur den ersten Block liest, bei ihrem nächsten Aufruf fehlschlägt. Wenn deine Anwendung einen Menschen bittet, folgenreiche Aktionen zu bestätigen, führe diese Prüfung vor jedem Block durch, da ein Batch eine mehrstufige Aktion innerhalb eines Zuges abschließen kann.

Claude beendet einen Batch typischerweise mit screenshot, damit es das Ergebnis beobachten kann, bevor es über den nächsten Schritt entscheidet. Wenn ein Batch nicht mit einem Screenshot endet, kann deine Anwendung einen Screenshot als zusätzlichen image-Block an das letzte Ergebnis im Batch anhängen, sodass Claude immer den aktuellen Zustand des Bildschirms erhält. Das spart einen Roundtrip im Vergleich dazu, darauf zu warten, dass Claude danach fragt. Du kannst Claude auch per Prompt anweisen, jeden Batch mit einem Screenshot zu beenden (siehe Modellleistung durch Prompting optimieren).

Die Computerumgebung

Computer Use erfordert eine abgeschottete (sandboxed) Computerumgebung, in der Claude sicher mit Anwendungen und dem Web interagieren kann. Diese Umgebung umfasst:

  1. Virtuelles Display: Einen virtuellen X11-Displayserver (mit Xvfb), der die Desktop-Oberfläche rendert, die Claude als Screenshots erhält und mit Maus-/Tastaturaktionen steuert.

  2. Desktop-Umgebung: Eine schlanke Benutzeroberfläche mit Fenstermanager (Mutter) und Panel (Tint2) unter Linux, die Claude eine konsistente grafische Oberfläche zur Interaktion bietet.

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

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

  5. Agenten-Schleife: Ein Programm, das die Kommunikation zwischen Claude und der Umgebung übernimmt, Claudes Aktionen an die Umgebung sendet und die Ergebnisse (Screenshots, Befehlsausgaben) an Claude zurückgibt.

Wenn du Computer Use verwendest, verbindet sich Claude nicht direkt mit dieser Umgebung. Stattdessen übernimmt deine Anwendung Folgendes:

  1. Sie empfängt Claudes Anfragen zur Tool-Nutzung.
  2. Sie übersetzt sie in Aktionen in deiner Computerumgebung.
  3. Sie erfasst die Ergebnisse (wie Screenshots und Befehlsausgaben).
  4. Sie gibt diese Ergebnisse an Claude zurück.

Aus Gründen der Sicherheit und Isolation führt die Referenzimplementierung all dies in einem Docker-Container mit geeigneten Port-Mappings aus, um die Umgebung anzusehen und mit ihr zu interagieren.


Wie du Computer Use implementierst

Du aktualisierst eine bestehende computer_20251124-Integration? Beginne mit Migration von computer_20251124; der Rest dieses Abschnitts gilt sowohl für neue als auch für migrierte Integrationen.

Die Agenten-Schleife verstehen

Der Kern von Computer Use ist die „Agenten-Schleife“: ein Zyklus, in dem Claude Tool-Aktionen anfordert und deine Anwendung sie ausführt und die Ergebnisse an Claude zurückgibt. Die Schleife verwendet den Client, den du im Schnellstart erstellt hast, ein tools-Array, das nur das Computer-Use-Toolset deklariert, und die Hilfsfunktion zur Verarbeitung von Tool-Aufrufen unter Das Computer-Use-Tool implementieren. Wenn du auch andere Tools deklarierst, etwa die Bash- und Text-Editor-Tools aus dem Schnellstart, verarbeite deren tool_use-Blöcke im selben Durchlauf; die Hilfsfunktion beantwortet nur Member-Aufrufe von Computer Use, und die Schleife behandelt einen Zug ohne beantwortete Aufrufe als abgeschlossen. Hier ist ein vereinfachtes Beispiel:

def sampling_loop(model: str, messages: list[MessageParam], max_iterations: int = 10):
    """
    Run the computer-use agent loop until Claude stops requesting tools
    or the iteration limit is reached.
    """
    for _ in range(max_iterations):
        response = client.messages.create(
            model=model,
            max_tokens=4096,
            messages=messages,
            tools=TOOLS,
        )

        # Add Claude's response to the conversation history
        messages.append({"role": "assistant", "content": response.content})

        # Run the actions Claude requested, in order, and collect the results
        tool_results = process_tool_calls(response)
        if not tool_results:
            return messages  # No more tool use; task complete

        # Send every result back to Claude in a single user message
        messages.append({"role": "user", "content": tool_results})

    return messages

Die Schleife läuft weiter, bis entweder Claude ohne Anforderung von Tools antwortet (Aufgabe abgeschlossen) oder das maximale Iterationslimit erreicht ist. Diese Schutzmaßnahme verhindert mögliche Endlosschleifen, die zu unerwarteten API-Kosten führen könnten.

Modellleistung durch Prompting optimieren

  1. Gib klar definierte Aufgaben vor und stelle explizite Anweisungen für jeden Schritt bereit.
  2. Claude verhält sich manchmal so, als wären seine Aktionen erfolgreich gewesen, ohne deren Ergebnisse explizit zu prüfen. Um dies zu verhindern, kannst du Claude folgenden Prompt geben: After each step, take a screenshot and carefully evaluate if you have achieved the right outcome. State in one sentence what the screenshot shows and whether the step succeeded. If it didn't, try again. Only when you confirm a step was executed correctly should you move on to the next one.
  3. Manche UI-Elemente (wie Dropdowns und Scrollbalken) sind für Claude mit Mausbewegungen möglicherweise schwer zu bedienen. Wenn du dies feststellst, versuche, das Modell per Prompt zur Verwendung von Tastenkürzeln anzuweisen.
  4. Füge für wiederholbare Aufgaben oder UI-Interaktionen Beispiel-Screenshots und Tool-Aufrufe erfolgreicher Ergebnisse in deinen Prompt ein.
  5. Wenn sich das Modell anmelden muss, gib ihm Benutzername und Passwort in deinem Prompt innerhalb von XML-Tags wie <robot_credentials>. Die Verwendung von Computer Use in Anwendungen, die eine Anmeldung erfordern, erhöht das Risiko schlechter Ergebnisse infolge von Prompt-Injection. Lies Jailbreaks und Prompt-Injections abschwächen, bevor du dem Modell Anmeldedaten gibst.
  6. Wenn du das content-Array eines Nutzer-Zuges erstellst, platziere den Anweisungstext vor dem Screenshot-Bild. Wenn die Zielbeschreibung bereitgestellt wird, bevor das Bild verarbeitet wird, verbessert sich die Klickgenauigkeit.
  7. Claude verwendet die Aktion zoom, um einen Bereich in voller Auflösung zu untersuchen, wenn es nach kleinem Text oder bestimmten UI-Elementen gefragt wird, die in der Standardauflösung des Screenshots nicht lesbar sind, etwa Dateinamen in einer Seitenleiste, Tab-Titel, Statusleistentext, Zeilennummern oder Schaltflächenbeschriftungen. Wenn Claude nicht zoomt, obwohl du es erwartest, frage nach einem bestimmten Bereich oder Element statt nach dem Bildschirm als Ganzem.
  8. Wenn jede Batch-Aktion mit einem Screenshot enden soll, sage das im System-Prompt, zum Beispiel: End each group of actions with a screenshot so you can verify the result before continuing.

Wenn du wiederholt auf eine klar umrissene Reihe von Problemen stößt oder im Voraus weißt, welche Aufgaben Claude erledigen muss, gib Claude im System-Prompt explizite Tipps oder Anweisungen dafür.

Führe bei Agenten, die sich über mehrere Sitzungen erstrecken, zu Beginn jeder Sitzung eine End-to-End-Verifizierung durch, nicht nur nach der Implementierung. Browserbasierte Prüfungen erkennen Regressionen aus früheren Sitzungen, die eine reine Code-Review übersieht. Siehe Effective harnesses for long-running agents für Details.

System-Prompts

Wenn du das Computer-Use-Tool in eine Anfrage aufnimmst, generiert die API einen Computer-Use-spezifischen System-Prompt. Er ähnelt dem System-Prompt für Tool-Nutzung, beginnt aber mit:

You have access to a set of functions you can use to answer the user’s question. This includes access to a sandboxed computing environment. You do NOT currently have the ability to inspect files or interact with external resources, except by invoking the below functions.

Wie bei der regulären Tool-Nutzung wird der vom Nutzer bereitgestellte system-Parameter weiterhin berücksichtigt und beim Aufbau des kombinierten System-Prompts verwendet.

Verfügbare Aktionen

Jede Aktion ist ein Member-Tool des Computer-Use-Toolsets: Claude benennt das Member in einem tool_use-Block, der "toolset_name": "computer" enthält, und der input des Blocks enthält nur die Parameter dieses Members, ohne action-Feld. Das Toolset hat 17 Member-Tools:

MemberEingabeBeschreibung
screenshotKeine ({})Erfasst das gesamte Display und gibt es als Bild zurück.
zoomregion: [x0, y0, x1, y1], die obere linke und untere rechte Ecke des zu untersuchenden BereichsErfasst nur diesen Bereich des Displays in voller Auflösung und gibt ihn als Bild zurück, skaliert auf deine üblichen Screenshot-Abmessungen unter Beibehaltung des Seitenverhältnisses. So kann Claude kleinen Text oder dichte UI lesen, die in einem herunterskalierten vollständigen Screenshot nicht lesbar ist.
left_clickcoordinate (optional): [x, y]; text (optional): Modifikatortasten, die während des Klicks gehalten werden: shift, ctrl, alt, super (die Command- oder Windows-Taste) oder eine mit + verbundene Kombination wie ctrl+shiftKlickt mit der linken Maustaste bei coordinate oder an der aktuellen Cursorposition, wenn coordinate weggelassen wird.
right_click, middle_click, double_click, triple_clickWie bei left_clickAndere Maustasten und Mehrfachklicks.
left_click_dragstart_coordinate: [x, y]; coordinate: [x, y]; text (optional): ModifikatortastenDrückt bei start_coordinate, zieht zu coordinate und lässt los.
mouse_movecoordinate: [x, y]Bewegt den Cursor ohne Klick, zum Beispiel zum Hovern.
left_mouse_down, left_mouse_upKeine ({})Drückt oder löst die linke Maustaste an der aktuellen Cursorposition, für Ziehvorgänge, die left_click_drag nicht abbilden kann. Bewege den Cursor zuerst mit mouse_move.
cursor_positionKeine ({})Meldet die aktuelle [x, y]-Position des Cursors als Text.
scrollscroll_direction: "up", "down", "left" oder "right"; scroll_amount: Anzahl der Mausrad-Klicks; coordinate (optional): [x, y]; text (optional): ModifikatortastenScrollt bei coordinate oder an der aktuellen Cursorposition.
typetext: die zu tippende ZeichenfolgeTippt wörtlichen Text am aktuellen Tastaturfokus.
keytext: eine Taste oder eine mit + verbundene Kombination wie "Return", "ctrl+s" oder "alt+Tab"; repeat (optional): 1 bis 100, Standard 1Drückt eine Taste oder Tastenkombination repeat-mal.
hold_keytext: eine Taste oder Kombination; duration: Sekunden, bis zu 300Hält eine Taste für die angegebene Dauer gedrückt.
waitduration: Sekunden, bis zu 300Pausiert vor der nächsten Aktion, zum Beispiel während eine Anwendung lädt.

Beachte Folgendes bei der Implementierung der Members:

  • Koordinaten sind in Screenshot-Pixeln. Jeder Wert von coordinate, start_coordinate und region sowie die von cursor_position gemeldete Position liegt im Pixelraum der vollständigen Display-Screenshots, die du zurückgibst, mit dem Ursprung oben links. Zoom-Bilder ändern daran nichts: Nach einem zoom gibt Claude Koordinaten weiterhin im Raum des vollständigen Screenshots an, nie relativ zum gezoomten Bild. Wenn du Screenshots vor der Rückgabe herunterskalierst, skaliere Claudes Koordinaten wieder hoch, bevor du sie auf das echte Display anwendest (siehe Screenshots an die Bildlimits anpassen).
  • Alle Members sind standardmäßig aktiviert, einschließlich zoom. Wenn deine Umgebung keine Zoom-Bilder erzeugen kann, schließe das Member mit configs aus (siehe Tool-Parameter), statt es aktiviert zu lassen und Fehler zurückzugeben. Wenn Claude ein Member aufruft, das du ausgeschlossen hast oder nicht implementierst, gib für diesen Block ein tool_result mit is_error: true zurück.
  • Verzweige anhand des Paares (toolset_name, name). toolset_name kennzeichnet einen Block als Computer-Aktion: Ein benutzerdefiniertes Tool in derselben Anfrage kann den Namen eines Members teilen, und eine spätere Toolset-Version kann Members hinzufügen (siehe Client-Toolsets).

Tool-Parameter

Der Toolset-Eintrag im tools-Array akzeptiert vier Parameter; die Regeln, die sie mit dem Browser-Use-Toolset teilen, sind unter Client-Toolsets aufgeführt.

ParameterErforderlichBeschreibung
typeJacomputer_toolset_20260801
configsNeinEinstellungen pro Member, nach Member-Name geschlüsselt; jedes Member akzeptiert enabled (Standard true für alle 17, einschließlich zoom) und defer_loading (Standard false, für die Tool-Suche), und Members, die du weglässt, behalten ihre Standardwerte.
cache_controlNeinPrompt-Caching-Breakpoint an der Toolset-Definition; nur am Eintrag. Ein Breakpoint an einem beliebigen tool_use- oder tool_result-Block in einem Batch wird am Ende dieses Batches wirksam; siehe Tool-Nutzung mit Prompt-Caching.
allowed_callersNeinNur ["direct"].

Dieser Eintrag schließt zum Beispiel zoom für eine Umgebung aus, die es nicht implementiert, und setzt einen Cache-Breakpoint an der Toolset-Definition:

{
  "type": "computer_toolset_20260801",
  "configs": {
    "zoom": { "enabled": false }
  },
  "cache_control": { "type": "ephemeral" }
}

Wenn deine Agenten-Schleife pro Roundtrip nur eine Aktion ausführen kann, setze disable_parallel_tool_use in tool_choice auf true; Claude gibt dann pro Zug höchstens einen Member-tool_use-Block zurück (siehe Parallele Tool-Nutzung deaktivieren).

Der Eintrag lehnt diese Parameter aus früheren Tool-Versionen ab, und eine Anfrage, die einen davon enthält, gibt einen invalid_request_error zurück:

  • name: Member-Namen sind durch die Toolset-Version festgelegt.
  • display_width_px, display_height_px und display_number: Koordinaten liegen immer im Pixelraum der Screenshots, die du zurückgibst.
  • enable_zoom: Zoom ist ein Member-Tool, das du über configs steuerst.

Der Eintrag kann außerdem nicht in derselben Anfrage wie ein computer_20251124-Eintrag oder ein anderes Tool namens computer deklariert werden. Zu strict, input_examples, der Platzierung von defer_loading, tool_choice, Streaming und Aufrufer-Einschränkungen siehe Client-Toolsets.

Kombination mit Nachdenken

Um Computer Use mit Nachdenken zu kombinieren, siehe Nachdenken.

Computer Use mit anderen Tools erweitern

Um neben Computer Use weitere Tools hinzuzufügen, nimm sie in dasselbe tools-Array auf. Der Abschnitt Schnellstart zeigt dieses Muster mit dem Bash-Tool und dem Text-Editor-Tool. Du kannst auf die gleiche Weise deine eigenen benutzerdefinierten Tool-Definitionen hinzufügen.

Für Aufgaben, die innerhalb von Webseiten bleiben, kannst du auch das Browser-Use-Tool in derselben Anfrage deklarieren. Die beiden Toolsets arbeiten unabhängig voneinander, jedes in seinem eigenen Koordinatensystem. Der Wert toolset_name unterscheidet Aufrufe von Members, die einen Namen teilen, etwa screenshot oder key.

Eine eigene Computer-Use-Umgebung erstellen

Die Referenzimplementierung soll dir den Einstieg in Computer Use erleichtern. Sie enthält alle Komponenten, die nötig sind, damit Claude einen Computer verwenden kann. Du kannst jedoch deine eigene Umgebung für Computer Use nach deinen Bedürfnissen erstellen. Du benötigst:

  • Eine virtualisierte oder containerisierte Umgebung, die für Computer Use mit Claude geeignet ist
  • Eine Implementierung der Aktionen des Computer-Use-Tools
  • Eine Agenten-Schleife, die mit der Claude API interagiert und die tool_use-Ergebnisse mit deinen Tool-Implementierungen ausführt
  • Eine API oder UI, die Nutzereingaben zum Starten der Agenten-Schleife ermöglicht

Das Computer-Use-Tool implementieren

Das Computer-Use-Tool ist als schemaloses Tool implementiert. Wenn du dieses Tool verwendest, musst du kein Eingabeschema wie bei anderen Tools angeben; das Schema ist in Claudes Modell integriert und kann nicht geändert werden.

  1. Richte deine Computerumgebung ein

    Erstelle ein virtuelles Display oder verbinde dich mit einem bestehenden Display, mit dem Claude interagiert. Dies umfasst typischerweise die Einrichtung von Xvfb (X Virtual Framebuffer) oder einer ähnlichen Technologie.

  2. Implementiere Aktions-Handler

    Erstelle Funktionen, um jeden Aktionstyp zu verarbeiten, den Claude anfordern könnte:

    # Placeholder image data; a real executor captures the screen and returns the PNG bytes
    PLACEHOLDER_PNG = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="
    
    
    def capture_screenshot() -> list[ImageBlockParam]:
        # screenshot answers with an image block rather than text: return the result content list
        return [
            {
                "type": "image",
                "source": {
                    "type": "base64",
                    "media_type": "image/png",
                    "data": PLACEHOLDER_PNG,
                },
            }
        ]
    
    
    def click(coordinate=None):
        if coordinate is None:
            return "clicked at current cursor"
        x, y = coordinate
        return f"clicked at ({x}, {y})"
    
    
    def type_text(text):
        return f"typed: {text}"
    
    
    def handle_computer_action(name, tool_input):
        match name:
            case "screenshot":
                return capture_screenshot()
            case "left_click":
                # coordinate is optional; without it, click where the cursor already is
                return click(tool_input.get("coordinate"))
            case "type":
                return type_text(tool_input["text"])
        # Handle other actions as needed
        raise ValueError(f"Unknown or unimplemented member: {name}")
  3. Verarbeite Claudes Tool-Aufrufe

    Extrahiere Tool-Aufrufe aus Claudes Antworten und führe sie aus:

    NOT_EXECUTED = "Not executed: an earlier computer action in this turn failed."
    
    
    def process_tool_calls(response: Message) -> list[ToolResultBlockParam]:
        """
        Run the computer actions in Claude's response in order and answer each
        one. After the first failure the rest are skipped, because Claude planned
        them assuming the earlier actions succeeded.
        """
        tool_results: list[ToolResultBlockParam] = []
        failed = False
        for block in response.content:
            # Only the computer toolset is declared; route other tools here if you add them
            if block.type != "tool_use" or block.toolset_name != "computer":
                continue
            result: ToolResultBlockParam = {
                "type": "tool_result",
                "tool_use_id": block.id,
                "toolset_name": "computer",
            }
            if failed:
                result["content"] = NOT_EXECUTED
                result["is_error"] = True
            else:
                try:
                    # A string, or a list of content blocks such as the screenshot image
                    result["content"] = handle_computer_action(block.name, block.input)
                except Exception as err:
                    result["content"] = f"Error: {err}"
                    result["is_error"] = True
                    failed = True
            tool_results.append(result)
        return tool_results
  4. Implementiere die Agenten-Schleife

    Verpacke die beiden vorherigen Schritte in eine Schleife, die die Ergebnisse zurücksendet und sich wiederholt, bis Claude keine Member-Tool-Aufrufe mehr zurückgibt; Die Agenten-Schleife verstehen zeigt diese Schleife.

Fehler behandeln

Melde eine fehlgeschlagene Aktion an Claude als tool_result mit is_error: true und einer kurzen Beschreibung, und füge wie bei jedem anderen Member-Ergebnis "toolset_name": "computer" hinzu. Wenn die fehlgeschlagene Aktion Teil einer Batch-Aktion war, beantworte die verbleibenden Blöcke im Batch mit dem dort gezeigten Abbruchtext, statt sie auszuführen.

Zum Beispiel, wenn die Screenshot-Erfassung fehlschlägt:

{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
      "toolset_name": "computer",
      "content": "Error: Failed to capture screenshot. Display may be locked or unavailable.",
      "is_error": true
    }
  ]
}

Verwende dieselbe Struktur für Koordinaten außerhalb der Display-Grenzen und für Aktionen, die nicht ausgeführt werden können, mit einer Meldung, die beschreibt, was schiefgelaufen ist.

Screenshots an die Bildlimits anpassen

Screenshots und Zoom-Bilder, die du an das Computer-Use-Toolset zurückgibst, müssen bereits in die Bildgrößenlimits deines Modells passen: Das Toolset nimmt keine Anzeigeabmessungen entgegen und die API skaliert nicht für dich herunter, daher wird ein zu großes tool_result-Bild mit einem Validierungsfehler abgelehnt. Da Claude Koordinaten im Pixelraum des Bildes zurückgibt, das es erhält, solltest du den verwendeten Skalierungsfaktor aufbewahren, damit du diese Koordinaten zurück auf deinen Bildschirm abbilden kannst.

Wenn dein Bildschirm größer als das Limit ist, skaliere jeden Screenshot, bevor du ihn zurückgibst, und rechne die von Claude zurückgegebenen Koordinaten wieder in den ursprünglichen Bildschirmraum um. Da das Toolset keine Anzeigeabmessungen entgegennimmt, brauchst du nur die Skalierung und die Koordinatenumrechnung in deinem Anwendungscode:

import math

screen_width, screen_height = 1512, 982


def get_scale_factor(width, height):
    """Calculate scale factor to meet API constraints."""
    long_edge = max(width, height)
    total_pixels = width * height

    long_edge_scale = 1568 / long_edge
    total_pixels_scale = math.sqrt(1_150_000 / total_pixels)

    return min(1.0, long_edge_scale, total_pixels_scale)


# Beim Erstellen eines Screenshots
scale = get_scale_factor(screen_width, screen_height)
scaled_width = int(screen_width * scale)
scaled_height = int(screen_height * scale)

# Skaliere das Bild auf die skalierten Abmessungen, bevor du es an Claude sendest
screenshot = capture_and_resize(scaled_width, scaled_height)


# Skaliere die Koordinaten von Claude bei der Verarbeitung wieder hoch
def execute_click(x, y):
    screen_x = x / scale
    screen_y = y / scale
    perform_click(screen_x, screen_y)

Wenn du eine Anzeigeauflösung wählst und Screenshots zurückgibst:

  • Verwende für allgemeine Desktop-Aufgaben 1024x768 oder 1280x720; für Webanwendungen 1280x800 oder 1366x768.
  • Vermeide Auflösungen über 1920x1080, um Performance-Probleme zu verhindern.
  • Kodiere Screenshots als base64-PNG oder -JPEG und erwäge, große Screenshots zu komprimieren, um die Performance zu verbessern.
  • Füge relevante Metadaten wie Zeitstempel oder Anzeigezustand hinzu.
  • Wenn du höhere Auflösungen verwendest, stelle sicher, dass die Koordinaten korrekt skaliert werden.

Screenshot-Verlauf verwalten

Lange Agent-Schleifen sammeln schnell Screenshots an (jeweils ungefähr 1.000–1.800 Eingabe-Token). Die Anfragelimits der API gelten ebenfalls.

Sobald eine einzelne Anfrage mehr als 20 Bilder enthält, gilt für jedes Bild darin ein strengeres Limit pro Seite. Eine Schleife, die ihren Screenshot-Verlauf behält, kann diese Anzahl erreichen. Skaliere entweder jeden Screenshot so, dass er unter diesem Limit bleibt, oder entferne ältere Screenshots, um höchstens 20 in der Anfrage zu behalten.

Um Prompt-Caching wirksam zu halten und gleichzeitig den Kontext zu begrenzen:

  • Setze einen cache_control-Breakpoint nach dem System-Prompt und den Tool-Definitionen und bis zu drei weitere auf den letzten tool_result-Block jedes der jüngsten Turns, und verschiebe sie mit jedem Turn weiter. Innerhalb einer Batch-Aktion wirken Markierungen auf mehreren Blöcken als ein einziger Breakpoint, aber jede zählt dennoch zum Limit von vier, verwende also höchstens eine pro Turn.
  • Entferne alte Screenshots in Batches, nicht einen pro Turn. Wenn du jeden Turn einen Screenshot weglässt, ändert sich das Präfix jeden Turn und der Cache wird ungültig. Ein sinnvoller Standard ist, die letzten drei Screenshots zu behalten und alle 25 Turns zu bereinigen, sodass das Präfix zwischen den Bereinigungen byte-identisch bleibt; wenn deine Screenshots das strengere Limit überschreiten, wähle ein Intervall, das jede Anfrage bei höchstens 20 Bildern hält.
  • Vermeide bei Claude Fable 5.2, Claude Mythos 5.2, Claude Fable 5.1 und Claude Mythos 5.1 das Bereinigen auf dem Client. Dasselbe gilt für Claude Opus 5.5, Claude Sonnet 5.5 und Claude Haiku 5.5. Auf diesen Modellen macht das Entfernen eines früheren Screenshots aus einer Anfrage jeden späteren Thinking-Block ungültig, der bereits im Verlauf steht, und zwar im Verlauf dieser und jeder späteren Anfrage.
    • Stattdessen: Skaliere Screenshots so, dass sie unter dem strengeren Limit bleiben. Tool-Result-Clearing spart Token, aber gelöschte Screenshots zählen weiterhin zu den Anfragelimits, verwende also On-Demand-Komprimierung, bevor eine Schleife sie erreicht.
    • Wenn du bereinigen musst: Lass prefix_mismatch_behavior: "drop_block" ab diesem Zeitpunkt gesetzt. Nach jeder Bereinigung lässt die API die ungültig gewordenen Thinking-Blöcke weg, sowohl bei dieser Anfrage als auch bei jeder späteren. Claude fährt also ohne das Nachdenken fort, das es nach dem entfernten Screenshot erzeugt hat.
    • Wenn du bei Claude Sonnet 5.5 oder Claude Haiku 5.5 bereinigen musst: prefix_mismatch_behavior funktioniert nur mit thinking: {"type": "adaptive"}. Bei jeder anderen Nachdenken-Einstellung auf diesen Modellen halte den Verlauf rein anhängend (append-only) oder entferne jeden thinking- und redacted_thinking-Block nach dem entfernten Screenshot.

Klickprobleme diagnostizieren

Wenn Klicks ihr Ziel verfehlen, liegt die Ursache meist in einem der folgenden Punkte:

SymptomWahrscheinliche UrsacheVersuche
Klicks sind durchgehend in eine Richtung versetztClaudes Koordinaten, die sich im Pixelraum der von dir zurückgegebenen Screenshots befinden, werden ohne Skalierung auf ein Display anderer Größe angewendetSkaliere jede Koordinate vor dem Klicken mit dem Verhältnis deiner Bildschirmgröße zu deiner Screenshot-Größe (siehe Screenshots an die Bildlimits anpassen); berücksichtige auf macOS-Retina-Displays das Gerätepixelverhältnis von 2
Klicks landen im richtigen Bereich, verfehlen aber das ZielDas Ziel ist sehr klein, Details gingen beim Herunterskalieren einer 4K+-Quelle verloren oder das Seitenverhältnis wurde verzerrtLass das zoom-Mitglied aktiviert und implementiere es, damit Claude den Bereich in voller Auflösung untersuchen kann; erfasse mit niedrigerem DPI oder schneide auf den relevanten Bereich zu; behalte beim Skalieren das Seitenverhältnis bei
Claude klickt auf ein völlig falsches ElementMehrdeutige Anweisung oder visuell ähnliche Elemente in der NäheVerwende positionsbezogene Prompts („der blaue Submit-Button unten rechts“); teile die Interaktion in kleinere Schritte auf
Die Genauigkeit ist durchgehend schlechtAuflösung zu niedrigVersuche 1280x720 als Ausgangswert

Best Practices für die Implementierung befolgen


Migration von computer_20251124

Eine computer_20251124-Integration funktioniert ohne Änderungen mit den Modellen, die für diese Version unter Frühere Tool-Versionen aufgeführt sind. Aktualisiere die Integration, bevor du sie auf ein Modell umstellst, das computer_20251124 nicht akzeptiert, etwa Claude Opus 5.5 in der Claude API.

Nimm für das Upgrade die folgenden Änderungen gemeinsam vor:

  1. Entferne den Beta-Header. Entferne anthropic-beta: computer-use-2025-11-24 aus deinen Anfragen. Entferne beim SDK betas und rufe die Messages API über den Standard-Client statt über den Beta-Namespace auf.
  2. Ändere den tools-Eintrag. Setze type auf computer_toolset_20260801 und lösche name, display_width_px, display_height_px, display_number und enable_zoom. Das Toolset lehnt jedes dieser Felder ab.
  3. Entscheide, ob Zoom aktiviert bleiben soll. Zoom ist im Toolset standardmäßig aktiviert, während enable_zoom standardmäßig false ist. Wenn deine Umgebung Zoom nicht implementiert, füge "configs": {"zoom": {"enabled": false}} hinzu, um das bisherige Verhalten beizubehalten; andernfalls implementiere es (siehe Verfügbare Aktionen).
  4. Verarbeite jeden Block in einem Turn. Aktualisiere deine Agent-Schleife so, dass sie über jeden tool_use-Block in einer Antwort iteriert, statt nur den ersten zu lesen, und anhand des name des Blocks zusammen mit toolset_name statt anhand von input.action verteilt. Member-Eingaben enthalten kein action-Feld mehr; die übrigen Felder sind unverändert.
  5. Führe Blöcke der Reihe nach aus und verwende den Abbruchtext. Führe die Blöcke sequenziell aus, stoppe beim ersten Fehler und beantworte die übrigen Blöcke mit Not executed: an earlier computer action in this turn failed., wie in Batch-Aktionen beschrieben. Wenn deine Schleife noch keine Batches ausführen kann, erklärt Tool-Parameter, wie du Claude auf eine Aktion pro Turn beschränkst.
  6. Gib toolset_name in Ergebnissen zurück. Füge "toolset_name": "computer" zu jedem tool_result hinzu, das einen Member-Aufruf beantwortet. Ergebnisse dürfen nur text- und image-Inhalte enthalten.
  7. Unterstütze repeat bei key. Das key-Mitglied akzeptiert eine optionale repeat-Anzahl von 1 bis 100. Ein Handler, der unbekannte Felder ignoriert, würde die Taste nur einmal drücken, sorge also dafür, dass dein key-Handler repeat berücksichtigt.
  8. Skaliere Screenshots selbst. Das Toolset lehnt einen Screenshot oder ein Zoom-Bild, das die Bildlimits des Modells überschreitet, ab, statt es herunterzuskalieren. Skaliere vor dem Zurückgeben des Bildes und rechne die Koordinaten weiterhin um, wie in Screenshots an die Bildlimits anpassen beschrieben.
  9. Entferne nicht unterstützte Optionen. Verschiebe ein etwaiges defer_loading aus dem Eintrag in configs, mit demselben Wert für jedes aktivierte Mitglied. Die anderen Optionen, die bei Toolset-Einträgen nicht unterstützt werden, sind unter Client-Toolsets aufgeführt.

Dies ist der tools-Eintrag vor der Änderung, gesendet mit dem Header anthropic-beta: computer-use-2025-11-24:

{
  "type": "computer_20251124",
  "name": "computer",
  "display_width_px": 1024,
  "display_height_px": 768,
  "display_number": 1
}

Dies ist der tools-Eintrag nach der Änderung, gesendet ohne Beta-Header. Das configs-Objekt hält Zoom deaktiviert, passend zum früheren Eintrag, der enable_zoom nicht setzt; lass configs ganz weg, um den Standard zu übernehmen und Claude zoomen zu lassen:

{
  "type": "computer_toolset_20260801",
  "configs": {
    "zoom": { "enabled": false }
  }
}

Das folgende Paar zeigt einen tool_use-Block vor und nach der Änderung. Der Aktionsname wandert von input.action nach name, und der Block erhält toolset_name:

{
  "type": "tool_use",
  "id": "toolu_01A9r5kQm2LxWc7vT3nZ4bJs",
  "name": "computer",
  "input": { "action": "left_click", "coordinate": [500, 300] }
}
{
  "type": "tool_use",
  "id": "toolu_01A9r5kQm2LxWc7vT3nZ4bJs",
  "name": "left_click",
  "toolset_name": "computer",
  "input": { "coordinate": [500, 300] }
}

Frühere Tool-Versionen

Zwei frühere Versionen des Computer-Use-Tools sind als Beta verfügbar. Jede erfordert bei jeder Anfrage ihren „beta header“ (Beta-Header), und ihre Parameter sind in der Beta-Referenz der Messages APIVorschau mit Links zur API-Referenz verfügbar – drücke Tab, bis der Fokus in die Karte wechselt, und Escape, um zurückzukehren. dokumentiert. Übergib den Header mit dem SDK über betas und verwende den Beta-Namespace; nur das Computer-Use-Tool benötigt den Header, nicht die Bash- oder Texteditor-Tools in derselben Anfrage.

Tool-VersionBeta-HeaderVerwenden mitParameter
computer_20251124computer-use-2025-11-24Claude Fable 5.1, Claude Mythos 5.1, Claude Fable 5, Claude Mythos 5, Claude Opus 5, Claude Sonnet 5, Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 4.6 und Claude Opus 4.5API-ReferenzVorschau mit Links zur API-Referenz verfügbar – drücke Tab, bis der Fokus in die Karte wechselt, und Escape, um zurückzukehren.
computer_20250124computer-use-2025-01-24Claude Sonnet 4.5 (abgekündigt), Claude Haiku 4.5, Claude Opus 4.1 (eingestellt, außer auf Claude Models on Google Cloud (Google managed) und Bedrock), Claude Sonnet 4 (eingestellt, außer auf Claude Models on Google Cloud (Google managed) und Bedrock) und Claude Opus 4 (eingestellt, außer auf Claude Models on Google Cloud (Google managed))API-ReferenzVorschau mit Links zur API-Referenz verfügbar – drücke Tab, bis der Fokus in die Karte wechselt, und Escape, um zurückzukehren.

Auf Amazon Bedrock akzeptieren Claude Fable 5.2, Claude Mythos 5.2, Claude Opus 5.5, Claude Sonnet 5.5 und Claude Haiku 5.5 außerdem das Tool computer_20251124 mit dem Beta-Header computer-use-2025-11-24. Sende computer-use-2025-11-24 bei der InvokeModel API von Amazon Bedrock im Array anthropic_beta des Anfragekörpers statt in einem Header. Zu dieser API siehe Claude auf Amazon Bedrock (bedrock-runtime).


Einschränkungen

  1. Latency (Latenz): Die Latenz von Computer Use bei Mensch-KI-Interaktionen kann im Vergleich zu regulären, von Menschen gesteuerten Computeraktionen zu langsam sein. Konzentriere dich auf Anwendungsfälle, bei denen Geschwindigkeit nicht entscheidend ist (zum Beispiel Informationsbeschaffung im Hintergrund, automatisierte Softwaretests), in vertrauenswürdigen Umgebungen.
  2. Genauigkeit und Zuverlässigkeit von Computer Vision: Claude kann Fehler machen oder halluzinieren, wenn es beim Generieren von Aktionen bestimmte Koordinaten ausgibt. Claudes Ausgabe des zusammengefassten Nachdenkens kann dir helfen, das Reasoning des Modells zu verstehen und mögliche Probleme zu erkennen; setze display: "summarized" in der Thinking-Konfiguration, da die Modelle, die das Toolset unterstützen, den Thinking-Text standardmäßig weglassen.
  3. Genauigkeit und Zuverlässigkeit der Tool-Auswahl: Claude kann Fehler machen oder halluzinieren, wenn es beim Generieren von Aktionen Tools auswählt, oder unerwartete Aktionen ausführen, um Probleme zu lösen. Zudem kann die Zuverlässigkeit bei der Interaktion mit Nischenanwendungen oder mehreren Anwendungen gleichzeitig geringer sein. Formuliere Prompts sorgfältig, wenn du komplexe Aufgaben anforderst.
  4. Zuverlässigkeit beim Scrollen: Die Scroll-Aktion unterstützt die Richtungssteuerung (hoch, runter, links, rechts) und einen festgelegten Betrag. In Anwendungen, in denen Scrollen keine Wirkung zeigt, können Tastaturalternativen wie Bild ab helfen.
  5. Interaktion mit Tabellenkalkulationen: Verwende die feingranularen Maussteuerungsaktionen (left_mouse_down, left_mouse_up) und Kombinationen mit Modifikatortasten, um einzelne Zellen auszuwählen. Komplexe Tabellenkalkulationsoperationen können dennoch mehrere Versuche erfordern.
  6. Kontoerstellung und Inhaltsgenerierung auf sozialen und Kommunikationsplattformen: Obwohl Claude Websites besucht, ist seine Fähigkeit eingeschränkt, Konten zu erstellen, Inhalte zu generieren und zu teilen oder sich anderweitig auf Social-Media-Websites und -Plattformen als Mensch auszugeben.
  7. Schwachstellen: Jailbreaks und Prompt Injection können Computer Use wie jedes Frontier-KI-System beeinträchtigen, auch über in Webseiten oder Bilder eingebettete Anweisungen; wende die Vorsichtsmaßnahmen aus dem Abschnitt Sicherheitsaspekte an.
  8. Unangemessene oder illegale Handlungen: Gemäß den Nutzungsbedingungen von Anthropic darfst du Computer Use nicht einsetzen, um gegen Gesetze oder die Richtlinie zur zulässigen Nutzung zu verstoßen.

Überprüfe und verifiziere Claudes Computer-Use-Aktionen und -Protokolle immer sorgfältig. Verwende Claude nicht ohne menschliche Aufsicht für Aufgaben, die perfekte Präzision oder sensible Benutzerinformationen erfordern.

Datenaufbewahrung

Computer Use ist ein clientseitiges Tool. Alle Screenshots, Mausaktionen, Tastatureingaben und alle an einer Sitzung beteiligten Dateien werden in deiner Umgebung erfasst und gespeichert, nicht von Anthropic. Anthropic verarbeitet die Screenshot-Bilder und Aktionsanfragen in Echtzeit als Teil des API-Aufrufs. Die Aufbewahrung dieser API-Anfragen richtet sich nach API und Datenaufbewahrung.

Da deine Anwendung steuert, wo und wie Computer-Use-Daten gespeichert werden, ist Computer Use ZDR-berechtigt.

Preise

„Computer use“ (Computernutzung) folgt der standardmäßigen Preisgestaltung für Tool-Nutzung. Bei der Verwendung des Computer-Use-Tools gilt:

Overhead der Toolset-Definition: Die Deklaration von computer_toolset_20260801 mit seinen Standardmitgliedern fügt einer Anfrage etwa 4.500 Input-Token hinzu (etwa 4.590 bei Claude Sonnet 5 und etwa 4.520 bei den anderen unterstützten Modellen). Dies umfasst die Definitionen der Mitglieds-Tools und den System-Prompt für die Tool-Nutzung. Das Deaktivieren von zoom mit configs entfernt etwa 410 dieser Token. Die genaue Anzahl für eine Anfrage wird im usage der Antwort angegeben, und du kannst sie vorab mit dem Token-Counting-Endpunkt abschätzen.

Frühere Tool-Versionen: Die folgenden Zahlen gelten für die Tool-Versionen computer_20251124 und computer_20250124, nicht für computer_toolset_20260801:

  • System-Prompt-Overhead: 466–499 Token, die dem System-Prompt hinzugefügt werden
  • Tool-Definition: etwa 735 Input-Token pro Tool-Definition (gemessen mit computer_20250124)

Zusätzlicher Token-Verbrauch:

  • Screenshot- und Zoom-Bilder, die in Tool-Ergebnissen zurückgegeben werden, abgerechnet als Bild-Input (siehe Vision-Preisgestaltung)
  • Ergebnisse der Tool-Ausführung, die an Claude zurückgegeben werden

Nächste Schritte

Starte mit dem Treiber eines Partners oder schreibe deinen eigenen in Python oder TypeScript. Das SDK führt die Schleife und den Genehmigungs-Callback aus, den du übergibst.

Behebe die häufigsten Fehler bei der Tool-Nutzung mit Diagnosetabellen von Symptom zu Lösung.

Starte mit der vollständigen Docker-basierten Implementierung.

Verbinde Claude mit externen Tools und APIs. Erfahre, wo Tools ausgeführt werden, wann Claude sie aufruft und welches Tool zu deiner Aufgabe passt.

Durch Benchmarks gestützte Empfehlungen zu Auflösung, Nachdenk-Aufwand und Kontextverwaltung.

Lass Claude in deiner eigenen Browser-Umgebung navigieren, Webseiten lesen und mit ihnen interagieren, für Aufgaben, die im Browser bleiben.

Verfügbarkeit

Computer-Use-Tool
APIs
  • Messages API
  • Managed Agents Nicht unterstützt
Modelle
  • Claude Fable 5.2, Fable 5.1, Fable 5
  • Claude Mythos 5.2, Mythos 5.1, Mythos 5, Mythos Preview
  • Claude Opus 5.5, Opus 5, Opus 4.8
  • Claude Opus 4.7, Opus 4.6, Opus 4.5 Beta erfordert
  • Claude Sonnet 5.5, Sonnet 5
  • Claude Sonnet 4.6 Beta erfordert
  • Claude Sonnet 4.5 Beta erfordert
  • Claude Haiku 5.5
  • Claude Haiku 4.5 Beta erfordert

Zutreffende Endpunkte

  • /v1/messages mit Toolset oder Tool computer
Zero Data RetentionBerechtigt

Ausgenommen: Abgedeckte Modelle

Clientseitiges Tool, bei dem Screenshots und Dateien in deiner Umgebung erfasst und gespeichert werden, nicht von Anthropic. Mehr erfahren

HIPAABerechtigt

War diese Seite hilfreich?