E se potessi dire a un’AI di “aprire Firefox, navigare su un sito web, compilare il modulo e salvare il risultato” — e lo facesse davvero? Non tramite un fragile script Selenium. Non tramite un’integrazione API personalizzata. Solo… guardando lo schermo e usando mouse e tastiera come farebbe un essere umano.

È esattamente quello che fa il computer use tool di Claude.

Cos’è Computer Use?

Computer use è una funzione API in beta che permette a Claude di interagire con ambienti desktop tramite:

Cattura screenshot — Claude vede cosa c’è sullo schermo
Controllo del mouse — click, trascinamento, scorrimento
Input da tastiera — digitare testo, premere scorciatoie
Automazione desktop — interagire con qualsiasi applicazione

La parola chiave è qualsiasi. A differenza dell’automazione tradizionale (Selenium per browser, AppleScript per macOS), Claude non ha bisogno di API speciali o selettori di elementi. Guarda i pixel sullo schermo e decide dove cliccare. Proprio come fai tu.

Come Funziona (L’Agent Loop)

Computer use segue un ciclo semplice:

Invii a Claude un compito — “Salva un’immagine di un gatto sul desktop”
Claude richiede un’azione dello strumento — “Cattura uno screenshot”
La tua app lo esegue — cattura lo schermo, restituisce l’immagine
Claude analizza e richiede l’azione successiva — “Clicca alle coordinate (500, 300)”
Ripeti finché il compito non è completato

Questo ciclo si chiama agent loop. Claude continua a richiedere azioni (screenshot, click, digitazione, scorrimento) e la tua applicazione continua a eseguirle, finché Claude determina che il compito è completo.

Ecco la chiamata API minimale per iniziare:

import anthropic

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-opus-4-6",
    max_tokens=1024,
    tools=[
        {
            "type": "computer_20251124",
            "name": "computer",
            "display_width_px": 1024,
            "display_height_px": 768,
            "display_number": 1,
        },
        {"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."
    }],
    betas=["computer-use-2025-11-24"],
)

L’header beta "computer-use-2025-11-24" è obbligatorio. I tre strumenti (computer, editor di testo, bash) lavorano insieme per dare a Claude il pieno controllo sull’ambiente.

Azioni Disponibili

Il computer use tool supporta un ricco set di interazioni:

Azioni Base

screenshot — cattura il display corrente
left_click — clicca alle coordinate [x, y]
type — digita una stringa di testo
key — premi un tasto o una combinazione (es. ctrl+s, alt+tab)
mouse_move — sposta il cursore

Azioni Avanzate (Modelli Claude 4.x)

scroll — scorrimento in qualsiasi direzione con controllo della quantità
left_click_drag — clicca e trascina tra coordinate
right_click, middle_click — pulsanti del mouse aggiuntivi
double_click, triple_click — click multipli
hold_key — tieni premuto un tasto per una durata
wait — pausa tra le azioni

Ultima Aggiunta: Zoom

Disponibile su Claude Opus 4.6, Sonnet 4.6 e Opus 4.5:

zoom — esamina una specifica area dello schermo a piena risoluzione

Particolarmente utile quando Claude deve leggere testo piccolo o identificare dettagli UI sottili.

L’Ambiente di Calcolo

Claude non si connette direttamente al tuo computer. Devi fornire un ambiente sandbox — tipicamente un container Docker che esegue:

Display virtuale — Xvfb (X Virtual Framebuffer) renderizza il desktop
Ambiente desktop — un window manager leggero come Mutter
Applicazioni — Firefox, LibreOffice, file manager, ecc.
Implementazioni degli strumenti — codice che traduce le richieste di Claude in operazioni reali di mouse/tastiera

Anthropic fornisce una implementazione di riferimento con tutto questo preconfigurato in Docker. È il modo più rapido per iniziare.

Costruire l’Agent Loop

Ecco un agent loop semplificato che gestisce lo scambio:

async def agent_loop(task: str, max_iterations: int = 10):
    client = anthropic.Anthropic()
    messages = [{"role": "user", "content": task}]

    tools = [
        {
            "type": "computer_20251124",
            "name": "computer",
            "display_width_px": 1024,
            "display_height_px": 768,
        },
        {"type": "text_editor_20250728", "name": "str_replace_based_edit_tool"},
        {"type": "bash_20250124", "name": "bash"},
    ]

    for _ in range(max_iterations):
        response = client.beta.messages.create(
            model="claude-opus-4-6",
            max_tokens=4096,
            messages=messages,
            tools=tools,
            betas=["computer-use-2025-11-24"],
        )

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

        # Extract tool calls
        tool_results = []
        for block in response.content:
            if block.type == "tool_use":
                result = execute_tool(block.name, block.input)
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": result,
                })

        if not tool_results:
            return messages  # Task complete

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

La funzione execute_tool è dove colleghi la cattura effettiva dello schermo, i click del mouse e l’input da tastiera al tuo ambiente di calcolo.

Scalatura delle Coordinate: L’Insidia

L’API limita le immagini a un massimo di 1568px sul lato più lungo. Se il tuo display è più grande (diciamo 1512x982), gli screenshot vengono ridimensionati — ma Claude restituisce coordinate basate sull’immagine più piccola.

Devi scalare le coordinate verso l’alto:

import math

def get_scale_factor(width, height):
    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)

scale = get_scale_factor(1512, 982)

# When Claude says "click at (450, 300)", scale it up:
def execute_click(x, y):
    screen_x = x / scale
    screen_y = y / scale
    perform_click(screen_x, screen_y)

Saltare questo passaggio significa che i click di Claude mancheranno i loro obiettivi. Questo è il singolo bug di implementazione più comune.

Suggerimenti per Prompt Migliori

Computer use funziona meglio con prompt chiari e strutturati:

Sii specifico. “Apri Firefox, vai su example.com e clicca il pulsante Login” funziona meglio di “accedi al sito.”
Chiedi a Claude di verificare. Aggiungi questo al tuo prompt: “Dopo ogni passaggio, cattura uno screenshot e valuta se hai ottenuto il risultato corretto. Prosegui solo quando confermato.”
Usa le scorciatoie da tastiera. I menu a tendina e le barre di scorrimento possono essere difficili da cliccare. Indica a Claude di usare Tab, Enter e i tasti freccia invece.
Fornisci esempi. Per compiti ripetibili, includi screenshot di esempio e chiamate agli strumenti attese nel tuo prompt.
Usa tag XML per le credenziali. Se Claude deve fare login, passa le credenziali in tag <robot_credentials>. Ma fai attenzione — i rischi di prompt injection sono più alti quando Claude interagisce con contenuti non attendibili.

Sicurezza: Prendila Sul Serio

Computer use ha rischi di sicurezza unici:

Prompt injection attraverso il contenuto dello schermo. Claude legge tutto quello che c’è sullo schermo. Una pagina web malevola potrebbe visualizzare istruzioni che sovrascrivono il tuo prompt.
Azioni autonome. Claude potrebbe cliccare link, accettare dialoghi o navigare lontano da dove intendevi.
Esposizione delle credenziali. Se Claude può vedere password o token sullo schermo, diventano parte della conversazione.

Anthropic ha classificatori integrati che segnalano potenziali prompt injection negli screenshot. Ma la migliore difesa è l’isolamento:

Esegui in una VM dedicata o container Docker con privilegi minimi
Non dare accesso ad account sensibili senza supervisione
Limita l’accesso internet a un allowlist di domini
Richiedi conferma umana per azioni conseguenti (acquisti, creazione account, ecc.)

Cosa Costruire Con Esso

Computer use è ideale per compiti dove la velocità non è critica ma l’automazione ha valore:

Test automatizzati — testa qualsiasi applicazione desktop, non solo le web app
Raccolta dati — naviga siti web ed estrai informazioni
Integrazione con sistemi legacy — automatizza flussi di lavoro in app senza API
Compilazione moduli — popola form web su più siti
Flussi di ricerca — cerca, leggi e compila informazioni dal web
QA e monitoraggio — verifica che le UI si rendano correttamente

Per flussi di ricerca e raccolta dati, strumenti come Save completano bene computer use — una volta che Claude naviga su una pagina, convertirla in Markdown pulito ti dà contenuto strutturato e pronto per l’AI invece di screenshot grezzi.

Limitazioni Attuali

Tieni presenti queste limitazioni della beta:

Latenza. Ogni azione richiede una chiamata API, la cattura dello screenshot e la risposta. È più lento di un essere umano che clicca in giro.
Accuratezza visiva. Claude può fraintendere il testo piccolo o identificare erroneamente gli elementi UI. La nuova azione zoom aiuta, ma non è perfetta.
Scorrimento. Migliorato significativamente nelle versioni recenti, ma le interazioni di scorrimento complesse possono ancora essere inaffidabili.
Fogli di calcolo. La selezione delle celle è complicata. Usa la navigazione da tastiera quando possibile.
Nessuna creazione di account su piattaforme social. Claude intenzionalmente non crea account o impersona esseri umani sui social media.

Prezzi

Computer use segue i prezzi standard dell’uso degli strumenti:

Overhead del system prompt: 466-499 token
Definizione degli strumenti: 735 token per strumento (per i modelli Claude 4.x)
Screenshot: fatturati come token vision (varia per risoluzione)
Ogni chiamata API nell’agent loop è una richiesta separata fatturabile

Per un tipico compito in 10 passaggi, aspettati di usare 15.000-50.000 token a seconda delle dimensioni degli screenshot e della complessità delle risposte.

Per Iniziare

Prova l’implementazione di riferimento. Clona anthropic-quickstarts, esegui il container Docker e sperimenta.
Inizia con compiti semplici. “Apri un editor di testo, digita Hello World, salva il file.” Fai funzionare l’agent loop prima di tentare flussi di lavoro complessi.
Aggiungi guardrail. Imposta limiti di iterazione. Valida le coordinate. Registra ogni azione. Aggiungi conferma umana per qualsiasi cosa irreversibile.
Ottimizza i tuoi prompt. Migliori sono le istruzioni, meno iterazioni Claude ha bisogno — e minori sono i costi dei token.

Computer use rappresenta un cambiamento fondamentale in quello che è possibile con le API AI. Invece di costruire integrazioni personalizzate per ogni applicazione, puoi dare a Claude la stessa interfaccia che usano gli esseri umani — uno schermo, un mouse e una tastiera — e lasciare che figuri il resto da solo.

Il futuro dell’automazione non sono più API. È l’AI che può usare le interfacce che già abbiamo.