Et si vous pouviez dire a une IA “ouvre Firefox, navigue vers un site, remplis le formulaire et enregistre le resultat” — et qu’elle le faisait vraiment ? Pas avec un script Selenium fragile. Pas avec une integration API sur mesure. Juste… en regardant l’ecran et en utilisant une souris et un clavier comme un humain.

C’est exactement ce que fait l’outil computer use de Claude.

Qu’est-ce que le Computer Use ?

Computer use est une fonctionnalite API en beta qui permet a Claude d’interagir avec des environnements de bureau via :

Capture d’ecran — Claude voit ce qui est affiche
Controle de la souris — clic, glisser-deposer, defilement
Saisie clavier — taper du texte, appuyer sur des raccourcis
Automatisation du bureau — interagir avec n’importe quelle application

Le mot cle est n’importe quelle. Contrairement a l’automatisation traditionnelle (Selenium pour les navigateurs, AppleScript pour macOS), Claude n’a pas besoin d’API speciales ni de selecteurs d’elements. Il regarde les pixels a l’ecran et decide ou cliquer. Exactement comme vous.

Comment ca fonctionne (la boucle agent)

Le computer use suit un cycle simple :

Vous envoyez une tache a Claude — “Enregistre une image de chat sur mon bureau”
Claude demande une action — “Prends une capture d’ecran”
Votre application l’execute — capture l’ecran, renvoie l’image
Claude analyse et demande l’action suivante — “Clique aux coordonnees (500, 300)”
On repete jusqu’a ce que la tache soit terminee

Ce cycle s’appelle la boucle agent (agent loop). Claude continue de demander des actions (capture d’ecran, clic, saisie, defilement) et votre application continue de les executer, jusqu’a ce que Claude determine que la tache est accomplie.

Voici l’appel API minimal pour demarrer :

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": "Enregistre une image de chat sur mon bureau."
    }],
    betas=["computer-use-2025-11-24"],
)

L’en-tete beta "computer-use-2025-11-24" est obligatoire. Les trois outils (computer, editeur de texte, bash) fonctionnent ensemble pour donner a Claude un controle complet sur l’environnement.

Actions disponibles

L’outil computer use prend en charge un ensemble riche d’interactions :

Actions de base

screenshot — capturer l’affichage actuel
left_click — cliquer aux coordonnees [x, y]
type — saisir une chaine de texte
key — appuyer sur une touche ou combinaison (ex : ctrl+s, alt+tab)
mouse_move — deplacer le curseur

Actions avancees (modeles Claude 4.x)

scroll — defiler dans n’importe quelle direction avec controle de la quantite
left_click_drag — cliquer-glisser entre deux coordonnees
right_click, middle_click — boutons supplementaires de la souris
double_click, triple_click — multi-clics
hold_key — maintenir une touche enfoncee pendant une duree
wait — pause entre les actions

Derniere nouveaute : le Zoom

Disponible sur Claude Opus 4.6, Sonnet 4.6 et Opus 4.5 :

zoom — inspecter une region specifique de l’ecran en pleine resolution

Particulierement utile quand Claude doit lire du texte petit ou identifier des details fins dans l’interface.

L’environnement de calcul

Claude ne se connecte pas directement a votre ordinateur. Vous devez fournir un environnement isole (sandbox) — typiquement un conteneur Docker executant :

Affichage virtuel — Xvfb (X Virtual Framebuffer) rend le bureau
Environnement de bureau — un gestionnaire de fenetres leger comme Mutter
Applications — Firefox, LibreOffice, gestionnaire de fichiers, etc.
Implementations des outils — code qui traduit les requetes de Claude en operations reelles de souris/clavier

Anthropic fournit une implementation de reference avec tout cela pre-configure dans Docker. C’est le moyen le plus rapide de demarrer.

Construire la boucle agent

Voici une boucle agent simplifiee qui gere les echanges :

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})

        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  # Tache terminee

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

La fonction execute_tool est l’endroit ou vous connectez la capture d’ecran reelle, les clics de souris et la saisie clavier a votre environnement de calcul.

Mise a l’echelle des coordonnees : le piege

L’API contraint les images a un maximum de 1568px sur le plus long cote. Si votre ecran est plus grand (disons 1512x982), les captures d’ecran sont sous-echantillonnees — mais Claude renvoie des coordonnees basees sur l’image plus petite.

Vous devez remettre les coordonnees a l’echelle :

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)

# Quand Claude dit "clique a (450, 300)", remettez a l'echelle :
def execute_click(x, y):
    screen_x = x / scale
    screen_y = y / scale
    perform_click(screen_x, screen_y)

Ignorer cette etape signifie que les clics de Claude rateront leurs cibles. C’est le bug d’implementation le plus courant.

Conseils de prompting pour de meilleurs resultats

Le computer use fonctionne mieux avec des prompts clairs et structures :

Soyez precis. “Ouvre Firefox, va sur example.com et clique sur le bouton Connexion” fonctionne mieux que “connecte-toi au site”.
Demandez a Claude de verifier. Ajoutez ceci a votre prompt : “Apres chaque etape, prends une capture d’ecran et evalue si tu as obtenu le bon resultat. Ne passe a la suite que lorsque c’est confirme.”
Utilisez les raccourcis clavier. Les menus deroulants et barres de defilement peuvent etre difficiles a cliquer. Demandez a Claude d’utiliser Tab, Entree et les fleches a la place.
Fournissez des exemples. Pour les taches repetitives, incluez des captures d’ecran d’exemple et les appels d’outils attendus dans votre prompt.
Utilisez des balises XML pour les identifiants. Si Claude doit se connecter, passez les identifiants dans des balises <robot_credentials>. Mais soyez prudent — les risques d’injection de prompt sont plus eleves quand Claude interagit avec du contenu non fiable.

Securite : prenez-la au serieux

Le computer use presente des risques de securite uniques :

Injection de prompt via le contenu a l’ecran. Claude lit tout ce qui est affiche. Une page web malveillante pourrait afficher des instructions qui annulent votre prompt.
Actions autonomes. Claude pourrait cliquer sur des liens, accepter des dialogues ou naviguer loin de l’endroit prevu.
Exposition des identifiants. Si Claude peut voir des mots de passe ou tokens a l’ecran, ils font partie de la conversation.

Anthropic a integre des classifieurs qui signalent les injections de prompt potentielles dans les captures d’ecran. Mais la meilleure defense est l’isolation :

Executez dans une VM dediee ou un conteneur Docker avec des privileges minimaux
Ne donnez pas acces aux comptes sensibles sans supervision
Limitez l’acces internet a une liste blanche de domaines
Exigez une confirmation humaine pour les actions consequentes (achats, creation de compte, etc.)

Quoi construire avec

Le computer use est ideal pour les taches ou la vitesse n’est pas critique mais l’automatisation est precieuse :

Tests automatises — testez n’importe quelle application de bureau, pas seulement les applis web
Collecte de donnees — naviguez sur des sites web et extrayez des informations
Integration de systemes legacy — automatisez des flux de travail dans des applis qui n’ont pas d’API
Remplissage de formulaires — remplissez des formulaires web sur plusieurs sites
Workflows de recherche — cherchez, lisez et compilez des informations depuis le web
QA et monitoring — verifiez que les interfaces se rendent correctement

Pour les workflows de recherche et de collecte de donnees, des outils comme Save completent bien le computer use — une fois que Claude a navigue vers une page, la convertir en Markdown propre vous donne du contenu structure et pret pour l’IA au lieu de captures d’ecran brutes.

Limitations actuelles

Gardez en tete ces limitations de la beta :

Latence. Chaque action necessite un appel API, une capture d’ecran et une reponse. C’est plus lent qu’un humain qui clique.
Precision visuelle. Claude peut mal lire du texte petit ou mal identifier des elements d’interface. La nouvelle action zoom aide, mais ce n’est pas parfait.
Defilement. Nettement ameliore dans les versions recentes, mais les interactions de defilement complexes peuvent encore etre peu fiables.
Tableurs. La selection de cellules est delicate. Utilisez la navigation au clavier quand c’est possible.
Pas de creation de compte sur les reseaux sociaux. Claude ne creera intentionnellement pas de comptes et n’imitera pas des humains sur les reseaux sociaux.

Tarification

Le computer use suit la tarification standard de l’utilisation d’outils :

Surcharge du prompt systeme : 466-499 tokens
Definition de l’outil : 735 tokens par outil (pour Claude 4.x)
Captures d’ecran : facturees comme tokens de vision (varie selon la resolution)
Chaque appel API dans la boucle agent est une requete facturable separee

Pour une tache typique en 10 etapes, prevoyez d’utiliser 15 000 a 50 000 tokens selon la taille des captures d’ecran et la complexite des reponses.

Pour demarrer

Essayez l’implementation de reference. Clonez anthropic-quickstarts, lancez le conteneur Docker et experimentez.
Commencez avec des taches simples. “Ouvre un editeur de texte, tape Hello World, enregistre le fichier.” Faites fonctionner la boucle agent avant de tenter des workflows complexes.
Ajoutez des garde-fous. Definissez des limites d’iterations. Validez les coordonnees. Enregistrez chaque action. Ajoutez une confirmation humaine pour tout ce qui est irreversible.
Optimisez vos prompts. Meilleures sont vos instructions, moins Claude a besoin d’iterations — et plus vos couts en tokens sont bas.

Le computer use represente un changement fondamental dans ce qui est possible avec les API d’IA. Au lieu de construire des integrations sur mesure pour chaque application, vous pouvez donner a Claude la meme interface que les humains utilisent — un ecran, une souris et un clavier — et le laisser se debrouiller.

L’avenir de l’automatisation, ce n’est pas plus d’API. C’est l’IA qui sait utiliser les interfaces que nous avons deja.