Comment construire un agent informatique avec Qwen 3.7 Plus

Qwen 3.7 Plus obtient un score de 79,0 sur ScreenSpot Pro, un banc d’essai centré sur l’analyse de captures d’écran et la restitution de coordonnées de pixels cliquables. Cette capacité permet de transformer un modèle de chat en agent d’utilisation informatique : un programme qui observe une interface, choisit une action, puis l’exécute. Dans ce guide, vous allez construire une boucle d’agent fonctionnelle en Python.

Essayez Apidog aujourd’hui

Nous allons implémenter les éléments essentiels : la boucle de l’agent, le prompt qui force des actions fiables, un exemple exécutable avec Playwright, puis les garde-fous de coût et de sécurité à appliquer avant toute utilisation réelle. Pour le contexte du modèle, consultez l’aperçu de Qwen 3.7 Plus. Pour le format de requête brut, le guide de l’API Qwen 3.7 Plus détaille les payloads multimodaux. Vous pouvez tester les appels de l’agent dans Apidog au fur et à mesure.

TL;DR

Un agent d’utilisation informatique répète une boucle simple :

1. Capturer l’écran.
2. Envoyer la capture à Qwen 3.7 Plus avec un objectif.
3. Recevoir une action structurée, par exemple click(x, y).
4. Exécuter l’action avec un pilote comme Playwright.
5. Recommencer jusqu’à ce que l’objectif soit atteint.

Qwen 3.7 Plus est adapté à ce cas d’usage grâce à son ancrage GUI et à son coût multimodal relativement faible. Les difficultés principales ne sont pas le modèle, mais l’implémentation : limiter la boucle, gérer les coordonnées, réduire le coût des tokens et sandboxer les actions pour éviter qu’un mauvais clic cause des dégâts.

Ce qu’un agent d’utilisation informatique fait réellement

Un agent de ce type n’a pas besoin d’être complexe. Il exécute quatre étapes en boucle :

1. Percevoir : capturer l’écran ou la page courante.
2. Décider : envoyer la capture et l’objectif au modèle.
3. Agir : exécuter l’action retournée : clic, saisie, scroll.
4. Vérifier : reprendre une capture et déterminer si l’objectif est atteint.

Le modèle ne fait que l’étape “décider”. Le reste est de l’automatisation contrôlée par votre code.

<video src="https://assets.apidog.com/blog-next/2026/06/V1tXD8Bnm5DAtobB.mp4" poster="https://img.spacergif.org/v1/1920x1080/0a/spacer.png" width="1920" height="1080" loop="" autoplay="" muted="" playsinline="" preload="metadata"></video>

Pourquoi Qwen 3.7 Plus convient

Qwen 3.7 Plus est pertinent pour construire ce type d’agent pour trois raisons :

• Ancrage GUI : il peut retourner des coordonnées utilisables au lieu de simples descriptions.
• Workflows hybrides GUI + CLI : le même agent peut cliquer sur une interface et exécuter des commandes si votre système l’autorise.
• Coût multimodal : à 0,40 $ par million de tokens d’entrée, il reste utilisable pour une boucle qui envoie plusieurs captures d’écran.

Pour comparer ce modèle avec le modèle textuel phare, consultez la comparaison Qwen 3.7 Plus vs Max.

Étape 1 : forcer une action JSON exploitable

Le point clé consiste à contraindre le modèle à un vocabulaire d’actions limité. Évitez le texte libre : il est difficile à exécuter de manière fiable. Utilisez plutôt un schéma JSON strict.

import os
import json
import base64
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DASHSCOPE_API_KEY"],
    base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
)

SYSTEM = """Vous êtes un agent GUI. Vous voyez une capture d'écran et un objectif.
Répondez avec UNE action JSON et rien d'autre :
{"action": "click", "x": 0, "y": 0}
{"action": "type", "text": ""}
{"action": "scroll", "dy": 0}
{"action": "done", "reason": ""}
Les coordonnées sont des pixels de la capture d'écran qui vous a été donnée."""

Ensuite, envoyez l’objectif et la capture d’écran au modèle :

def next_action(goal, png_bytes):
    b64 = base64.b64encode(png_bytes).decode()

    resp = client.chat.completions.create(
        model="qwen3.7-plus",
        messages=[
            {
                "role": "system",
                "content": SYSTEM,
            },
            {
                "role": "user",
                "content": [
                    {
                        "type": "text",
                        "text": f"Objectif : {goal}",
                    },
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:image/png;base64,{b64}",
                        },
                    },
                ],
            },
        ],
    )

    return json.loads(resp.choices[0].message.content)

Avant de déployer, confirmez l’identifiant exact du modèle dans la documentation de Model Studio, car les noms de modèles peuvent changer.

Étape 2 : piloter le navigateur avec Playwright

Playwright permet de contrôler un vrai navigateur. Pour éviter les erreurs de coordonnées, utilisez la même taille pour la fenêtre d’affichage et la capture d’écran. Ainsi, un point (x, y) retourné par le modèle correspond directement à un pixel de la page.

from playwright.sync_api import sync_playwright

goal = "Ouvrir la page de tarification et trouver le plan le moins cher"

with sync_playwright() as p:
    browser = p.chromium.launch(headless=False)

    page = browser.new_page(
        viewport={
            "width": 1280,
            "height": 800,
        }
    )

    page.goto("https://example.com")

    for step in range(15):  # limite stricte sur les étapes
        shot = page.screenshot()  # PNG 1280x800
        action = next_action(goal, shot)

        print(step, action)

        if action["action"] == "done":
            break

        if action["action"] == "click":
            page.mouse.click(action["x"], action["y"])

        elif action["action"] == "type":
            page.keyboard.type(action["text"])

        elif action["action"] == "scroll":
            page.mouse.wheel(0, action["dy"])

        page.wait_for_timeout(800)  # laisser l'interface se stabiliser

    browser.close()

Cette boucle suffit pour obtenir un agent minimal :

• il observe la page ;
• il demande l’action suivante au modèle ;
• il exécute l’action ;
• il recommence jusqu’à done ou jusqu’à la limite d’étapes.

Le même principe fonctionne pour des applications de bureau si vous remplacez Playwright par une bibliothèque d’automatisation desktop et que vous capturez la fenêtre de l’OS.

Étape 3 : gérer les coûts et la fiabilité

Les captures d’écran sont la partie la plus coûteuse. Chaque image est convertie en tokens. Une capture large peut représenter plusieurs milliers de tokens, et une boucle de 15 étapes multiplie rapidement le coût.

Appliquez ces règles dès le départ :

• Réduisez la taille des images : envoyez la plus petite capture lisible par le modèle.
• Recadrez si possible : si seule une zone de l’interface est utile, envoyez uniquement cette zone.
• Limitez le nombre d’étapes : ne laissez jamais une boucle agentique tourner indéfiniment.
• Vérifiez après chaque action : chaque clic ou saisie doit être validé par la capture suivante.
• Journalisez les actions : stockez l’action, la capture et la réponse brute du modèle.

Pour approfondir, consultez le guide sur la réduction des coûts de tokens d’agent et les notes sur les modèles de câblage et pièges des workflows agentiques.

Étape 4 : gérer les échecs courants

Trois problèmes apparaissent souvent dans ce type de boucle.

1. Le modèle renvoie du texte libre au lieu de JSON

Ajoutez une étape de validation et de réparation :

def parse_action(raw):
    try:
        return json.loads(raw)
    except json.JSONDecodeError:
        raise ValueError(f"Réponse non JSON : {raw}")

En production, vous pouvez relancer une fois avec un rappel court : “Répondez uniquement avec une action JSON valide.”

2. Le clic rate sa cible

Ne répétez pas aveuglément les mêmes coordonnées. Si la capture suivante montre que rien n’a changé, demandez une nouvelle action au modèle avec l’état actuel.

3. La boucle tourne sans progrès

Gardez un historique court des actions :

recent_actions = []

# après chaque action
recent_actions.append(action)

if len(recent_actions) > 5:
    recent_actions.pop(0)

Si les actions se répètent, arrêtez la boucle et affichez la dernière capture à un humain. La limite d’étapes reste le filet de sécurité principal.

Sécurité

Un agent d’utilisation informatique clique réellement sur des éléments. Avant de le connecter à un environnement sensible :

• exécutez-le dans un sandbox ou un profil de navigateur jetable ;
• évitez votre session de production connectée ;
• exigez une confirmation humaine pour supprimer, envoyer, payer ou publier ;
• journalisez chaque action avec sa capture d’écran ;
• limitez les domaines, pages ou applications accessibles ;
• désactivez les permissions inutiles.

Tester les appels de l’agent avec Apidog

La plupart des bugs d’agent viennent d’une question simple : le modèle a-t-il renvoyé une action valide ?

Avant de brancher Playwright, testez uniquement l’étape de décision. Avec Apidog, vous pouvez envoyer une capture d’écran à Qwen 3.7 Plus, inspecter le JSON brut et ajuster le prompt système jusqu’à obtenir un schéma stable.

Vous pouvez aussi stocker votre clé Model Studio par environnement et simuler le point de terminaison pour construire la boucle sans consommer des tokens à chaque test. Lorsque la boucle complète enchaîne plusieurs appels, le débogueur d’agent IA d’Apidog aide à repérer l’étape qui a déraillé.

Pour générer du code UI à partir d’un design au lieu de piloter une interface existante, consultez le guide complémentaire sur la capture d’écran vers le code avec Qwen 3.7 Plus.

Téléchargez Apidog pour tester et déboguer les appels de modèle derrière votre agent.

FAQ

Qu’est-ce qu’un agent d’utilisation informatique ?

C’est un logiciel qui observe un écran via des captures d’écran, demande à un modèle quelle action exécuter, puis applique cette action via un pilote d’automatisation. Il boucle jusqu’à atteindre un objectif ou une limite définie.

Qwen 3.7 Plus peut-il contrôler mon bureau ?

Le modèle ne contrôle rien directement. Il retourne des actions. Votre code les exécute avec Playwright pour un navigateur ou avec une bibliothèque d’automatisation desktop pour des applications natives.

Combien coûte chaque étape ?

Le coût vient surtout de la capture d’écran. Une image peut représenter plusieurs milliers de tokens d’entrée. La réduction d’échelle, le recadrage et la limite d’étapes sont les principaux leviers de maîtrise du coût.

Est-ce fiable pour la production ?

Oui pour des tâches bornées, bien définies et vérifiées après chaque étape. Pour des systèmes critiques ou des actions destructrices, gardez un humain dans la boucle et isolez l’environnement.

Dois-je mettre à l’échelle les coordonnées ?

Non si la résolution de la capture correspond exactement à la fenêtre d’affichage. Si elles diffèrent, appliquez un facteur d’échelle entre les dimensions de l’image envoyée au modèle et celles de l’interface réelle.

Le mot de la fin

Un agent d’utilisation informatique est une boucle courte autour d’un modèle multimodal capable de lire une interface. Qwen 3.7 Plus fournit la base pour décider d’actions GUI exploitables. Construisez la boucle, imposez un schéma JSON, limitez les étapes, isolez l’environnement et vérifiez chaque action. Ensuite, testez l’étape de décision dans Apidog avant de laisser l’agent commencer à cliquer.