Qwen 3.7 Plus: KI-Agent für PC-Automatisierung erstellen

Qwen 3.7 Plus erreicht 79,0 Punkte bei ScreenSpot Pro, einem Benchmark, bei dem ein Modell anhand eines Screenshots die exakten Pixelkoordinaten für Klicks zurückgeben muss. Damit wird aus einem Chat-Modell ein Computer-Nutzungs-Agent: Software, die einen Bildschirm sieht, die nächste Aktion entscheidet und diese ausführt. In diesem Leitfaden bauen Sie eine lauffähige Agenten-Schleife in Python.

Teste Apidog noch heute

Sie implementieren Schritt für Schritt: den Entscheidungs-Prompt, strukturierte Aktionen, eine Browser-Automatisierung mit Playwright, Kostenkontrolle und Sicherheitsgrenzen. Wenn Sie zuerst den Modellhintergrund einordnen möchten, lesen Sie die Qwen 3.7 Plus Übersicht. Das rohe Anfrageformat für multimodale Payloads behandelt der Qwen 3.7 Plus API-Leitfaden. Die Modellaufrufe können Sie unterwegs in Apidog testen.

TL;DR

Ein Computer-Nutzungs-Agent läuft in einer wiederholbaren Schleife:

1. Screenshot aufnehmen.
2. Screenshot plus Ziel an Qwen 3.7 Plus senden.
3. Strukturierte Aktion wie click(x, y), type(text) oder scroll(dy) erhalten.
4. Aktion mit Playwright oder einem anderen Treiber ausführen.
5. Neuen Screenshot prüfen und fortfahren, bis done erreicht ist.

Qwen 3.7 Plus eignet sich dafür, weil es GUI-Elemente gut verankert, hybride GUI-/CLI-Workflows unterstützt und multimodale Aufrufe vergleichsweise günstig sind. Die eigentliche Engineering-Arbeit liegt aber in Begrenzungen: Schrittlimit, Koordinatenskalierung, Token-Kosten und Sandboxing.

Was ein Computer-Nutzungs-Agent tatsächlich tut

Ein Agent besteht nicht aus Magie, sondern aus vier wiederholten Schritten:

1. Wahrnehmen: Screenshot des aktuellen Browserfensters oder Desktops erfassen.
2. Entscheiden: Screenshot und Ziel an das Modell senden.
3. Handeln: Zurückgegebene Aktion ausführen, z. B. klicken, tippen oder scrollen.
4. Prüfen: Neuen Screenshot aufnehmen und entscheiden, ob das Ziel erreicht ist.

Das Modell übernimmt nur den Schritt Entscheiden. Aufnahme, Ausführung, Validierung, Logging und Sicherheitsregeln implementieren Sie selbst.

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


                    <svg xmlns="http://www.w3.org/2000/svg">
                        <path d="M23.14 10.608 2.253.164A1.559 1.559 0 0 0 0 1.557v20.887a1.558 1.558 0 0 0 2.253 1.392L23.14 13.393a1.557 1.557 0 0 0 0-2.785Z"></path>
                    </svg>





                        <svg xmlns="http://www.w3.org/2000/svg">
                            <path d="M23.14 10.608 2.253.164A1.559 1.559 0 0 0 0 1.557v20.887a1.558 1.558 0 0 0 2.253 1.392L23.14 13.393a1.557 1.557 0 0 0 0-2.785Z"></path>
                        </svg>


                        <svg xmlns="http://www.w3.org/2000/svg">
                            <rect width="7" height="22" rx="1.5" ry="1.5"></rect>
                            <rect width="7" height="22" rx="1.5" ry="1.5"></rect>
                        </svg>

                    <span>0:00</span>

                        /<span>1:26</span>


                    1×

                        <svg xmlns="http://www.w3.org/2000/svg">
                            <path d="M15.189 2.021a9.728 9.728 0 0 0-7.924 4.85.249.249 0 0 1-.221.133H5.25a3 3 0 0 0-3 3v2a3 3 0 0 0 3 3h1.794a.249.249 0 0 1 .221.133 9.73 9.73 0 0 0 7.924 4.85h.06a1 1 0 0 0 1-1V3.02a1 1 0 0 0-1.06-.998Z"></path>
                        </svg>


                        <svg xmlns="http://www.w3.org/2000/svg">
                            <path d="M16.177 4.3a.248.248 0 0 0 .073-.176v-1.1a1 1 0 0 0-1.061-1 9.728 9.728 0 0 0-7.924 4.85.249.249 0 0 1-.221.133H5.25a3 3 0 0 0-3 3v2a3 3 0 0 0 3 3h.114a.251.251 0 0 0 .177-.073ZM23.707 1.706A1 1 0 0 0 22.293.292l-22 22a1 1 0 0 0 0 1.414l.009.009a1 1 0 0 0 1.405-.009l6.63-6.631A.251.251 0 0 1 8.515 17a.245.245 0 0 1 .177.075 10.081 10.081 0 0 0 6.5 2.92 1 1 0 0 0 1.061-1V9.266a.247.247 0 0 1 .073-.176Z"></path>
                        </svg>

Warum Qwen 3.7 Plus für GUI-Agenten passt

Qwen 3.7 Plus ist für diese Agenten-Schleife aus drei Gründen praktisch:

• GUI-Verankerung: Das Modell kann aus einem Screenshot konkrete Koordinaten ableiten, statt nur Elemente zu beschreiben.
• Hybride Workflows: Ein Agent kann GUI-Aktionen mit CLI- oder Tool-Aufrufen kombinieren.
• Kostenprofil: Bei 0,40 $ pro Million Eingabe-Tokens sind wiederholte Vision-Aufrufe wirtschaftlicher als bei vielen teureren Modellen.

Eine Einordnung gegenüber dem reinen Text-Flaggschiff finden Sie im Qwen 3.7 Plus vs Max Vergleich.

Entscheidungsschritt: JSON statt Prosa erzwingen

Der wichtigste Prompting-Grundsatz: Lassen Sie das Modell nicht frei antworten. Begrenzen Sie es auf ein kleines Aktionsvokabular und verlangen Sie genau ein JSON-Objekt.

Installieren Sie zuerst die Abhängigkeit:

pip install openai playwright
playwright install chromium

Dann implementieren Sie den Modellaufruf:

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 = """You are a GUI agent. You see a screenshot and a goal.
Reply with ONE JSON action and nothing else:
{"action": "click", "x": <int>, "y": <int>}
{"action": "type", "text": "<string>"}
{"action": "scroll", "dy": <int>}
{"action": "done", "reason": "<string>"}
Coordinates are pixels in the screenshot you were given."""

Die Funktion next_action() kodiert den Screenshot als Base64, sendet ihn an Qwen 3.7 Plus und parst die Antwort als JSON:

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"Goal: {goal}"},
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:image/png;base64,{b64}"
                        },
                    },
                ],
            },
        ],
    )

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

Prüfen Sie die genaue Modell-ID vor dem Deployment in der Model Studio Dokumentation, da sich Modellbezeichner ändern können.

Vollständige Agenten-Schleife mit Playwright

Playwright steuert einen echten Browser. Dadurch kann der Agent reale Webseiten bedienen.

Wichtig: Setzen Sie den Browser-Viewport auf dieselbe Größe wie den Screenshot. Dann stimmen Modellkoordinaten und Klickkoordinaten direkt überein.

from playwright.sync_api import sync_playwright

goal = "Open the pricing page and find the cheapest plan"

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):                 # hartes Schrittlimit
        shot = page.screenshot()           # 1280x800 PNG
        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)         # UI reagieren lassen

    browser.close()

Damit haben Sie einen minimalen, aber echten GUI-Agenten:

• Screenshot aufnehmen
• Modellaktion holen
• Aktion ausführen
• UI-Zustand neu bewerten
• spätestens nach 15 Schritten stoppen

Dasselbe Muster funktioniert auch für Desktop-Anwendungen, wenn Sie Playwright durch einen Desktop-Automatisierungstreiber ersetzen und statt der Browserseite das Betriebssystemfenster als Screenshot erfassen.

Koordinaten richtig behandeln

Wenn Screenshot und Ausführungsfläche dieselbe Größe haben, können Sie direkt klicken:

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

Wenn sie unterschiedlich sind, skalieren Sie die Koordinaten:

def scale_point(x, y, screenshot_size, viewport_size):
    screenshot_w, screenshot_h = screenshot_size
    viewport_w, viewport_h = viewport_size

    return (
        int(x * viewport_w / screenshot_w),
        int(y * viewport_h / screenshot_h),
    )

Beispiel:

click_x, click_y = scale_point(
    action["x"],
    action["y"],
    screenshot_size=(1920, 1200),
    viewport_size=(1280, 800),
)

page.mouse.click(click_x, click_y)

In der Praxis ist es einfacher, Screenshotgröße und Viewportgröße identisch zu halten.

Kosten und Zuverlässigkeit kontrollieren

Screenshots sind der größte Kostentreiber. Jeder Screenshot wird in Tokens umgewandelt. Ein 1280 Pixel breites Bild kann einige tausend Tokens verbrauchen. Bei 15 Schritten pro Aufgabe entstehen schnell reale API-Kosten.

Praktische Maßnahmen:

• Bildgröße reduzieren: Senden Sie nur so viel Auflösung, wie das Modell benötigt.
• Relevante Bereiche zuschneiden: Wenn nur ein Panel wichtig ist, schicken Sie nicht den ganzen Bildschirm.
• Schrittlimit setzen: Jede Agenten-Schleife braucht ein hartes Maximum.
• Nach jeder Aktion prüfen: Ein Klick ist nur eine Hypothese. Der nächste Screenshot validiert sie.
• Wiederholungen erkennen: Wenn dieselbe Aktion mehrfach erscheint, stoppen Sie und eskalieren an einen Menschen.

Mehr Details finden Sie im Leitfaden zur Reduzierung der Agenten-Token-Kosten. Typische Fehler beim Verbinden von Tools behandelt der Artikel zu Agenten-Workflow-Verdrahtung.

Wenn der Agent steckenbleibt

Drei Fehler treten häufig auf.

1. Das Modell gibt Prosa statt JSON zurück

Fangen Sie JSON-Parsing-Fehler ab und versuchen Sie genau einmal eine Reparatur:

def safe_next_action(goal, png_bytes):
    try:
        return next_action(goal, png_bytes)
    except json.JSONDecodeError:
        repaired_goal = (
            goal
            + "\nReply only with one valid JSON object. No prose."
        )
        return next_action(repaired_goal, png_bytes)

Wenn auch der zweite Versuch fehlschlägt, stoppen Sie die Schleife.

2. Der Klick verfehlt das Ziel

Verlassen Sie sich nicht blind auf dieselben Koordinaten. Prüfen Sie nach jedem Klick, ob sich der Zustand geändert hat. Wenn nicht, senden Sie einen frischen Screenshot und lassen Sie neu entscheiden.

3. Die Schleife wiederholt sich

Speichern Sie die letzten Aktionen:

recent_actions = []

def is_repeating(action):
    recent_actions.append(action)
    if len(recent_actions) > 4:
        recent_actions.pop(0)

    return len(recent_actions) == 4 and all(
        a == recent_actions[0] for a in recent_actions
    )

In der Schleife:

if is_repeating(action):
    print("Agent wiederholt sich. Stoppe.")
    break

Sicherheit

Ein Computer-Nutzungs-Agent klickt wirklich. Behandeln Sie ihn wie automatisierte Software mit Seiteneffekten.

Mindestens erforderlich:

• In Sandbox, Testumgebung oder Einweg-Browserprofil ausführen.
• Nie in einer angemeldeten Produktionssitzung starten.
• Destruktive Aktionen wie Löschen, Senden oder Bezahlen durch Menschen bestätigen lassen.
• Jede Aktion zusammen mit Screenshot und Modellantwort protokollieren.
• Domains, URLs oder Anwendungen per Allowlist begrenzen.
• Secrets und API-Schlüssel nicht im sichtbaren Browserfenster anzeigen.

Ein einfaches Aktions-Logging:

import datetime

def log_action(step, action):
    timestamp = datetime.datetime.utcnow().isoformat()
    print(json.dumps({
        "timestamp": timestamp,
        "step": step,
        "action": action,
    }))

Modellaufrufe mit Apidog testen

Die zentrale Debugging-Frage lautet: Gibt das Modell eine gültige Aktion zurück?

Bevor Sie Playwright anschließen, testen Sie den Modellaufruf isoliert:

1. Beispiel-Screenshot vorbereiten.
2. Request an Qwen 3.7 Plus in Apidog anlegen.
3. System-Prompt und User-Payload eintragen.
4. Rohantwort prüfen.
5. Prompt anpassen, bis immer ein gültiges JSON-Aktionsobjekt zurückkommt.
6. Model-Studio-Schlüssel pro Umgebung speichern.
7. Endpunkt simulieren, um die Schleife ohne Tokenverbrauch zu entwickeln.

Wenn die vollständige Schleife mehrere Aufrufe verkettet, hilft Apidogs AI-Agent-Debugger, die Sequenz zu inspizieren und den fehlerhaften Schritt zu finden.

Wenn Sie aus einem Design UI-Code generieren möchten, statt eine bestehende UI zu steuern, lesen Sie den Begleitführer zu Screenshot-to-Code mit Qwen 3.7 Plus.

Laden Sie Apidog herunter, um die Modellaufrufe hinter Ihrem Agenten zu testen und zu debuggen.

FAQ

Was ist ein Computer-Nutzungs-Agent?

Software, die einen Bildschirm per Screenshot wahrnimmt, mit einem Modell die nächste Aktion bestimmt und diese über einen Automatisierungstreiber ausführt, bis ein Ziel erreicht ist.

Kann Qwen 3.7 Plus meinen Desktop steuern?

Nicht direkt. Das Modell gibt Aktionen zurück. Ihr Code führt diese Aktionen mit einem Treiber aus, z. B. Playwright für Browser oder einer Desktop-Automatisierungsbibliothek für native Apps.

Wie viel kostet jeder Schritt?

Der Screenshot ist der Hauptkostenfaktor. Ein einzelnes Bildschirmbild kann einige tausend Eingabe-Tokens verbrauchen. Deshalb sind Herunterskalieren, Zuschneiden und Schrittlimits die wichtigsten Kostenhebel.

Ist das zuverlässig genug für Produktion?

Für klar begrenzte Aufgaben mit Validierung nach jedem Schritt kann es geeignet sein. Für kritische oder destruktive Aktionen sollten Sie Menschenbestätigung, Sandboxing und Logging einsetzen.

Muss ich Koordinaten skalieren?

Nicht, wenn Screenshotauflösung und Viewport identisch sind. Wenn sie sich unterscheiden, skalieren Sie x und y anhand des Größenverhältnisses.

Fazit

Ein Computer-Nutzungs-Agent ist eine kurze, kontrollierte Schleife um ein multimodales Modell. Qwen 3.7 Plus liefert die GUI-Verankerung und das Kostenprofil, um solche Schleifen praktisch umzusetzen. Entscheidend ist die Infrastruktur: JSON-Schema erzwingen, Koordinaten sauber behandeln, Schleifen begrenzen, Aktionen sandboxen und jeden Schritt prüfen. Testen Sie den Entscheidungsschritt zuerst in Apidog, bevor der Agent echte Klicks ausführt.