VIRTUAL DESKTOP ENVIRONMENTS FÜR GUI AGENTS

ScreenEnv ist eine leistungsstarke Python-Bibliothek, die es ermöglicht, isolierte Ubuntu-Desktopumgebungen in Docker-Containern zu erstellen. Diese Umgebung ist besonders nützlich für die Automatisierung von Desktopaufgaben, das Testen von GUI-Anwendungen und den Aufbau von KI-Agenten, die mit Software interagieren können. Mit der Unterstützung des Model Context Protocol (MCP) wird die Bereitstellung von Desktop-Agenten, die sehen, klicken und mit echten Anwendungen interagieren können, erheblich vereinfacht.

Was ist ScreenEnv?

Stellen Sie sich vor, Sie müssen Desktopaufgaben automatisieren oder GUI-Anwendungen testen. Früher erforderte dies komplexe VM-Setups und anfällige Automatisierungsframeworks. ScreenEnv ändert dies, indem es eine sandboxed Desktopumgebung bereitstellt, die in einem Docker-Container läuft. Dies bedeutet, dass Ihr Code die vollständige Kontrolle über eine virtuelle Desktop-Sitzung hat – nicht nur über das Klicken von Schaltflächen und das Eingeben von Text, sondern auch über das Verwalten der gesamten Desktop-Erfahrung, einschließlich des Startens von Anwendungen, der Organisation von Fenstern, der Handhabung von Dateien, der Ausführung von Terminalbefehlen und der Aufzeichnung der gesamten Sitzung.

Warum ScreenEnv?

• 🖥️ Vollständige Desktopkontrolle: Umfassende Maus- und Tastaturautomatisierung, Fensterverwaltung, Anwendungsstart, Dateioperationen, Terminalzugriff und Bildschirmaufzeichnung.
• 🤖 Duale Integrationsmodi: Unterstützung sowohl des Model Context Protocol (MCP) für KI-Systeme als auch der direkten Sandbox-API – Anpassung an jede Agenten- oder Backend-Logik.
• 🐳 Docker-Nativ: Kein komplexes VM-Setup – nur Docker. Die Umgebung ist isoliert, reproduzierbar und kann in weniger als 10 Sekunden überall bereitgestellt werden. Unterstützung für AMD64- und ARM64-Architekturen.

Einzeilige Einrichtung

from screenenv import Sandbox
sandbox = Sandbox()  # Das ist alles!

Zwei Integrationsansätze

ScreenEnv bietet zwei komplementäre Möglichkeiten zur Integration mit Ihren Agenten und Backend-Systemen, sodass Sie den Ansatz wählen können, der am besten zu Ihrer Architektur passt:

Option 1: Direkte Sandbox-API

Ideal für benutzerdefinierte Agenten-Frameworks oder bestehende Backends, wenn Sie eine feinkörnige Kontrolle benötigen:

from screenenv import Sandbox
# Direkte programmatische Kontrolle
sandbox = Sandbox(headless=False)
sandbox.launch("xfce4-terminal")
sandbox.write("echo 'Benutzerdefinierte Agentenlogik'")
screenshot = sandbox.screenshot()
image = Image.open(BytesIO(screenshot_bytes))
...
sandbox.close()  # Wenn close() nicht aufgerufen wird, müssen Sie möglicherweise den Container selbst herunterfahren.

Option 2: MCP-Serverintegration

Ideal für KI-Systeme, die das Model Context Protocol unterstützen:

from screenenv import MCPRemoteServer
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client
# MCP-Server für KI-Integration starten
server = MCPRemoteServer(headless=False)
print(f"MCP Server URL: {server.server_url}")
# KI-Agenten können jetzt die Desktopumgebung steuern
async def mcp_session():
    async with streamablehttp_client(server.server_url) as streams:
        async with ClientSession(*streams) as session:
            await session.initialize()
            print(await session.list_tools())
            response = await session.call_tool("screenshot", {})
            image_bytes = base64.b64decode(response.content[0].data)
            image = Image.open(BytesIO(image_bytes))
server.close()  # Wenn close() nicht aufgerufen wird, müssen Sie möglicherweise den Container selbst herunterfahren.

Dieser duale Ansatz bedeutet, dass ScreenEnv sich an Ihre bestehende Infrastruktur anpasst, anstatt Sie zu zwingen, Ihre Agentenarchitektur zu ändern.

Erstellen eines Desktop-Agenten mit ScreenEnv und SmolAgents

ScreenEnv unterstützt nativ SmolAgents, was es einfach macht, Ihren eigenen benutzerdefinierten Desktop-Agenten für die Automatisierung zu erstellen. Hier sind die Schritte, um Ihren eigenen KI-gesteuerten Desktop-Agenten in nur wenigen Schritten zu erstellen:

1. Wählen Sie Ihr Modell

Wählen Sie das Backend VLM, das Ihren Agenten antreiben soll:

import os
from smolagents import OpenAIServerModel
model = OpenAIServerModel(model_id="gpt-4.1", api_key=os.getenv("OPENAI_API_KEY"),)
# Inferenzendpunkte
from smolagents import HfApiModel
model = HfApiModel(model_id="Qwen/Qwen2.5-VL-7B-Instruct", token=os.getenv("HF_TOKEN"), provider="nebius",)
# Transformer-Modelle
from smolagents import TransformersModel
model = TransformersModel(model_id="Qwen/Qwen2.5-VL-7B-Instruct", device_map="auto", torch_dtype="auto", trust_remote_code=True,)
# Andere Anbieter
from smolagents import LiteLLMModel
model = LiteLLMModel(model_id="anthropic/claude-sonnet-4-20250514")

2. Definieren Sie Ihren benutzerdefinierten Desktop-Agenten

Leiten Sie von DesktopAgentBase ab und implementieren Sie die Methode _setup_desktop_tools, um Ihren eigenen Aktionsraum zu erstellen!

from screenenv import DesktopAgentBase, Sandbox
from smolagents import Model, Tool, tool
from smolagents.monitoring import LogLevel
from typing import List
class CustomDesktopAgent(DesktopAgentBase):
    """Agent für Desktopautomatisierung"""
    def __init__(self, model: Model, data_dir: str, desktop: Sandbox, tools: List[Tool] | None = None, max_steps: int = 200, verbosity_level: LogLevel = LogLevel.INFO, planning_interval: int | None = None, use_v1_prompt: bool = False, **kwargs, ):
        super().__init__(model=model, data_dir=data_dir, desktop=desktop, tools=tools, max_steps=max_steps, verbosity_level=verbosity_level, planning_interval=planning_interval, use_v1_prompt=use_v1_prompt, **kwargs,)
    # OPTIONAL: Fügen Sie eine benutzerdefinierte Aufforderungsvorlage hinzu
    def _setup_desktop_tools(self) -> None:
        """Definieren Sie hier Ihre benutzerdefinierten Werkzeuge."""
        @tool
def click(x: int, y: int) -> str:
            """Klickt an den angegebenen Koordinaten."""
            self.desktop.left_click(x, y)
            return f"Geklickt bei ({x}, {y})"
        self.tools["click"] = click
        # Weitere Werkzeuge können hier hinzugefügt werden...

3. Führen Sie den Agenten bei einer Desktopaufgabe aus

from screenenv import Sandbox
# Definieren Sie Ihre Sandbox-Umgebung
sandbox = Sandbox(headless=False, resolution=(1920, 1080))
# Erstellen Sie Ihren Agenten
agent = CustomDesktopAgent(model=model, data_dir="data", desktop=sandbox,)
# Führen Sie eine Aufgabe aus
task = "Öffnen Sie LibreOffice, schreiben Sie einen Bericht von etwa 300 Wörtern über das Thema 'AI Agent Workflow in 2025' und speichern Sie das Dokument."
result = agent.run(task)
print(f"📄 Ergebnis: {result}")
sandbox.close()

Wenn Sie auf einen Zugriffsfehler in Docker stoßen, können Sie versuchen, den Agenten mit sudo -E python -m test.py auszuführen oder Ihren Benutzer zur Docker-Gruppe hinzuzufügen.

Jetzt starten!

Um ScreenEnv zu installieren, verwenden Sie den folgenden Befehl:

pip install screenenv

Probieren Sie die Beispiele aus:

git clone git@github.com:huggingface/screenenv.git
cd screenenv
python -m examples.desktop_agent

Verwenden Sie sudo -E python -m examples.desktop_agent, wenn Sie nicht in der Docker-Gruppe sind.

Was kommt als Nächstes?

ScreenEnv plant, über Linux hinaus zu expandieren und Android, macOS und Windows zu unterstützen, um echte plattformübergreifende GUI-Automatisierung zu ermöglichen. Diese Fortschritte ebnen den Weg für die Erstellung reproduzierbarer, sandboxed Umgebungen, die ideal für Benchmarking und Evaluierung sind.

Quellenliste:

• Quelle: SCREENENV: DEPLOY YOUR FULL STACK DESKTOP AGENT
• ScreenEnv GitHub Repository
• Building the Hugging Face MCP Server