Architecture : screenshots, actions, boucle d'interaction

Leçon réécrite le 3 novembre 2026 d’après le guide Computer use et les Computer use integration recipes d’OpenAI : ce cours du catalogue OpenAI utilisait jusqu’ici l’API d’Anthropic (import anthropic, outil computer_20241022). Il suit désormais l’outil computer de la Responses API d’OpenAI, avec ses actions groupées dans un computer_call et ses captures renvoyées en computer_call_output. Les durées et volumes de tokens chiffrés de l’ancienne version, sans source, sont retirés. Sources : Computer use · Integration recipes.

La boucle perception-action

Toute l’architecture de Computer Use tient dans un cycle unique : observer → décider → agir → observer. Tant que ce cycle n’est pas clair dans votre esprit, vos automatisations resteront capricieuses ; une fois qu’il l’est, le reste n’est que plomberie.

La différence avec un script Selenium tient à la position du savoir. Selenium exécute aveuglément une séquence décidée à l’avance : clique ici, puis là, puis tape ceci. Computer Use ne choisit l’étape suivante qu’après avoir regardé le résultat de la précédente. Une popup qui surgit, une page qui met plus de temps à s’afficher, un libellé de bouton modifié pendant la nuit : dans les trois cas, le modèle voit la situation réelle et ajuste, là où le script poursuit sa récitation dans le vide.

Avec l’outil computer d’OpenAI, l’échange se fait en trois temps : vous envoyez la tâche, vous exécutez les actions que le modèle renvoie, puis vous lui retournez une capture de l’écran. C’est votre application qui tient la souris et le clavier ; le modèle ne fait que décider.

Le point de départ : la capture

Chaque tour s’appuie sur une image de l’état courant de l’écran. Cette capture provient d’un navigateur piloté par Playwright — le cas le plus fréquent sur le web —, d’un bureau virtuel quand vous automatisez une application desktop, ou d’un conteneur Docker qui isole l’agent. OpenAI recommande dans tous les cas un navigateur ou une machine virtuelle isolés.

import base64

def capturer_ecran(page) -> str:
    """Capture l'écran avec Playwright et retourne l'image PNG en base64."""
    return base64.b64encode(page.screenshot()).decode("utf-8")

La capture repart vers le modèle sous forme d’URL de données PNG. Elle compte comme une entrée image, donc dans la facture de chaque tour : la taille de la fenêtre que vous capturez est un vrai paramètre de conception.

L’analyse et la décision

Le modèle reçoit la tâche, l’historique de la conversation et la dernière capture. Sa réponse n’est pas une phrase mais un élément computer_call, qui porte une liste ordonnée d’actions à exécuter. Voici l’exemple de la documentation d’OpenAI, qui sélectionne un champ de recherche puis y tape un mot :

{
  "type": "computer_call",
  "call_id": "call_002",
  "actions": [
    { "type": "click", "button": "left", "x": 405, "y": 157 },
    { "type": "type", "text": "penguin" }
  ],
  "status": "completed"
}

Deux détails comptent. Le premier appel peut ne contenir qu’une action screenshot : le modèle demande alors à voir l’écran avant d’agir, et vous lui renvoyez une capture sans rien modifier. Et status: "completed" signifie que le modèle a fini de générer l’appel, pas que les actions ont été faites : leur exécution vous revient.

Le répertoire d’actions

Le vocabulaire dont dispose le modèle est volontairement réduit ; combinées, ces primitives couvrent l’essentiel de ce qu’un humain fait avec une souris et un clavier.

Le flux complet

Assemblés, ces éléments donnent la boucle suivante, calquée sur celle de la documentation d’OpenAI. Tant que la réponse contient un computer_call, on exécute ses actions, on capture l’écran et on renvoie la capture dans un computer_call_output qui reprend le même call_id ; previous_response_id relie chaque tour au précédent.

from openai import OpenAI

client = OpenAI()

def boucle_computer_use(page, tache: str):
    """Boucle Computer Use avec l'outil computer de la Responses API."""
    response = client.responses.create(
        model="gpt-6.1-sol",
        tools=[{"type": "computer"}],
        input=tache,
    )

    while True:
        appel = next(
            (item for item in response.output if item.type == "computer_call"),
            None,
        )
        if appel is None:
            return response.output_text  # plus d'action demandée : la tâche est finie

        executer_actions(page, appel.actions)  # votre gestionnaire d'actions (leçon 4)
        capture = capturer_ecran(page)

        response = client.responses.create(
            model="gpt-6.1-sol",
            tools=[{"type": "computer"}],
            previous_response_id=response.id,
            input=[{
                "type": "computer_call_output",
                "call_id": appel.call_id,
                "output": {
                    "type": "computer_screenshot",
                    "image_url": f"data:image/png;base64,{capture}",
                    "detail": "original",
                },
            }],
        )

Cette boucle n’a pas encore de garde-fou : en production, bornez le nombre de tours, la durée et le coût, arrêtez-vous quand un appel porte des vérifications de sécurité en attente (pending_safety_checks), et vérifiez le résultat réel plutôt que de vous fier au seul message final du modèle — ce sont les consignes de sécurité d’OpenAI, développées à la leçon 12.

Ce que coûte un tour de boucle

Chaque requête à la Responses API facture ses tokens d’entrée et de sortie, et chaque capture compte comme une entrée image ; un environnement hébergé peut être facturé à part. Le coût d’une tâche dépend donc du nombre de tours, de la taille des captures et du modèle — et il croît plus vite que le nombre de tours, car même avec previous_response_id, tous les tokens d’entrée des réponses précédentes de la chaîne sont refacturés en entrée à chaque requête. OpenAI fournit un calculateur du coût des images et expose l’usage de chaque requête : mesurez sur vos propres parcours avant de budgéter. Un script Selenium fera toujours la même chose plus vite et pour moins cher — mais il faudra le réécrire à la prochaine refonte du formulaire, ce que l’agent n’exige pas.

Points clés à retenir

• La boucle tâche → actions → capture est le cœur de Computer Use ; c’est votre application qui exécute les actions
• Avec OpenAI, l’outil se déclare par tools=[{"type": "computer"}] dans la Responses API
• Un computer_call porte une liste ordonnée d’actions (click, type, scroll, keypress…) à exécuter dans l’ordre
• La capture revient au modèle dans un computer_call_output de même call_id, chaîné par previous_response_id
• Chaque tour coûte des tokens et une image : bornez les tours et mesurez avant de budgéter