Architecture : screenshots, actions, boucle d'interaction

La boucle perception-action

L’architecture de Computer Use repose sur un cycle fondamental : observer → décider → agir → observer. Comprendre cette boucle est essentiel pour construire des automatisations fiables.

Contrairement à un script Selenium qui exécute des commandes séquentielles aveuglement, Computer Use réévalue la situation à chaque étape. Si une popup apparaît, si la page charge lentement, ou si l’interface a changé, l’IA s’adapte.

Les trois composants

1. La capture de screenshots

Le point de départ de chaque itération est une image de l’état actuel de l’écran. Cette capture peut provenir de :

• Un navigateur headless (Chromium, Playwright) — le plus courant pour le web
• Un bureau virtuel (VNC, RDP) — pour les applications desktop
• Un conteneur Docker avec un environnement graphique complet

Le screenshot est envoyé au modèle sous forme d’image encodée en base64. La résolution compte : trop basse et l’IA ne distingue pas les éléments, trop haute et le coût en tokens explose.

import base64
from playwright.sync_api import sync_playwright

def capture_screenshot(page) -> str:
    """Capture un screenshot et retourne le base64."""
    screenshot_bytes = page.screenshot()
    return base64.b64encode(screenshot_bytes).decode("utf-8")

2. L’analyse et la décision

Le modèle reçoit le screenshot accompagné d’instructions (le system prompt et la tâche demandée). Il analyse l’image et décide de la prochaine action. Cette décision prend en compte :

• Ce qu’il voit : boutons, champs de texte, menus, messages d’erreur
• Ce qu’il doit faire : la tâche définie par l’utilisateur
• L’historique : les actions précédentes et leurs résultats

Le modèle retourne une action structurée, par exemple :

# Réponse typique du modèle
{
    "type": "computer_20241022",
    "action": "click",
    "coordinate": [450, 320]
}

3. L’exécution des actions

Les actions supportées par Computer Use sont :

Le flux complet

Voici le cycle complet d’une interaction Computer Use :

import anthropic

client = anthropic.Anthropic()

def computer_use_loop(task: str, page):
    """Boucle principale Computer Use."""
    messages = []
    
    while True:
        # 1. Capturer le screenshot
        screenshot_b64 = capture_screenshot(page)
        
        # 2. Envoyer au modèle avec l'image
        messages.append({
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": "image/png",
                        "data": screenshot_b64,
                    }
                },
                {"type": "text", "text": task}
            ]
        })
        
        # 3. Obtenir la décision du modèle
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=1024,
            messages=messages,
            tools=[{
                "type": "computer_20241022",
                "name": "computer",
                "display_width_px": 1280,
                "display_height_px": 720,
            }]
        )
        
        # 4. Exécuter l'action ou terminer
        if response.stop_reason == "end_turn":
            break
        
        for block in response.content:
            if block.type == "tool_use":
                execute_action(page, block.input)
        
        # La boucle continue avec un nouveau screenshot

Latence et coûts

Chaque itération de la boucle implique :

• Un envoi d’image (~1500 tokens pour un screenshot 1280x720)
• Un appel API (~0.5-2 secondes de latence)
• L’exécution de l’action (~100-500ms)

Pour une tâche simple (remplir un formulaire de 5 champs), comptez 5 à 10 itérations, soit environ 10 à 30 secondes au total. C’est plus lent qu’un script Selenium, mais beaucoup plus résilient.

Points clés à retenir

• La boucle screenshot → analyse → action est le cœur de Computer Use
• Chaque itération est indépendante : le modèle réévalue la situation à chaque screenshot
• Les actions disponibles sont simples (clic, frappe, scroll, touche) mais combinées, elles couvrent tous les cas
• La latence est de l’ordre de 2 à 5 secondes par action, ce qui est acceptable pour l’automatisation