Computernutzung

Mit „Computer Use“ können Sie Agents zur Browsersteuerung erstellen, die mit Aufgaben interagieren und diese automatisieren. Anhand von Screenshots kann das Modell einen Computerbildschirm „sehen“ und „agieren“, indem es bestimmte UI-Aktionen wie Mausklicks und Tastatureingaben generiert. Ähnlich wie beim Funktionsaufruf müssen Sie den clientseitigen Anwendungscode schreiben, um die Aktionen zur Computernutzung zu empfangen und auszuführen.

Mit „Computer Use“ können Sie Agents erstellen, die:

• Wiederholte Dateneingaben oder das Ausfüllen von Formularen auf Websites automatisieren
• Automatisierte Tests von Webanwendungen und User Flows durchführen
• Recherchen auf verschiedenen Websites durchführen (z.B. Produktinformationen, Preise und Rezensionen von E-Commerce-Websites abrufen, um eine Kaufentscheidung zu treffen)

Am einfachsten lässt sich die Funktion „Computer Use“ über die Referenzimplementierung oder die Browserbase-Demo-Umgebung testen.

So funktioniert die Computernutzung

Wenn Sie einen Browser-Steuerungs-Agent mit dem Modell „Computer Use“ erstellen möchten, implementieren Sie eine Agentschleife, die Folgendes ausführt:

1. Anfrage an das Modell senden

   • Fügen Sie Ihrer API-Anfrage das Tool „Computer Use“ und optional benutzerdefinierte Funktionen oder ausgeschlossene Funktionen hinzu.
   • Geben Sie die Nutzeranfrage als Prompt für das Modell „Computer Use“ ein.

2. Modellantwort erhalten

   • Das Modell „Computer Use“ analysiert die Nutzeranfrage und den Screenshot und generiert eine Antwort, die eine vorgeschlagene function_call enthält, die eine UI-Aktion darstellt (z.B. „Klicke auf die Koordinate (x,y)“ oder „Gib ‚Text‘ ein“. Eine Beschreibung aller UI-Aktionen, die vom Modell „Computer verwenden“ unterstützt werden, finden Sie unter Unterstützte Aktionen.
   • Die API-Antwort kann auch ein safety_decision von einem internen Sicherheitssystem enthalten, das die vorgeschlagene Aktion des Modells prüft. Dadurch wird die Aktion als Folgendes klassifiziert:
     safety_decision
     • Regulär / zulässig:Die Aktion gilt als sicher. Das kann auch dadurch dargestellt werden, dass kein safety_decision vorhanden ist.
     • Bestätigung erforderlich (require_confirmation): Das Modell ist dabei, eine potenziell riskante Aktion auszuführen, z.B. auf ein Cookie-Banner zu klicken.

3. Erhaltene Aktion ausführen

   • Ihr clientseitiger Code empfängt die function_call und alle zugehörigen safety_decision.
     • Regulär / zulässig:Wenn safety_decision „regulär / zulässig“ angibt (oder wenn kein safety_decision vorhanden ist), kann Ihr clientseitiger Code die angegebene function_call in Ihrer Zielumgebung (z.B. einem Webbrowser) ausführen.
     • Bestätigung erforderlich:Wenn safety_decision angibt, dass eine Bestätigung erforderlich ist, muss Ihre Anwendung den Endnutzer vor der Ausführung von function_call zur Bestätigung auffordern. Wenn der Nutzer bestätigt, fahre mit der Ausführung der Aktion fort. Wenn der Nutzer die Ausführung ablehnt, führen Sie die Aktion nicht aus.

4. Neuen Umgebungsstatus erfassen

   • Wenn die Aktion ausgeführt wurde, erstellt Ihr Client einen neuen Screenshot der Benutzeroberfläche und der aktuellen URL, die als Teil eines function_response an das Modell für die Computernutzung zurückgesendet werden.
   • Wenn eine Aktion vom Sicherheitssystem blockiert oder die Bestätigung durch den Nutzer verweigert wurde, kann Ihre Anwendung eine andere Art von Feedback an das Modell senden oder die Interaktion beenden.

Dieser Prozess wird ab Schritt 2 wiederholt. Das Modell verwendet den neuen Screenshot und das laufende Ziel, um die nächste Aktion vorzuschlagen. Die Schleife wird fortgesetzt, bis die Aufgabe abgeschlossen ist, ein Fehler auftritt oder der Prozess beendet wird (z.B. aufgrund einer Sicherheitsantwort vom Typ „Block“ oder einer Nutzerentscheidung).

Implementierung von „Computer Use“

Bevor Sie das Tool zur Computernutzung verwenden können, müssen Sie Folgendes einrichten:

• Sichere Ausführungsumgebung:Aus Sicherheitsgründen sollten Sie Ihren Computer Use-Agent in einer sicheren und kontrollierten Umgebung ausführen, z.B. in einer Sandbox-VM, einem Container oder einem dedizierten Browserprofil mit eingeschränkten Berechtigungen.
• Clientseitiger Aktionshandler:Sie müssen clientseitige Logik implementieren, um die vom Modell generierten Aktionen auszuführen und nach jeder Aktion Screenshots der Umgebung zu erstellen.

In den Beispielen in diesem Abschnitt wird ein Browser als Ausführungsumgebung und Playwright als clientseitiger Aktions-Handler verwendet. Damit Sie diese Beispiele ausführen können, müssen Sie die erforderlichen Abhängigkeiten installieren und eine Playwright-Browserinstanz initialisieren.

    pip install google-genai playwright
    playwright install chromium
    

    from playwright.sync_api import sync_playwright

    # 1. Configure screen dimensions for the target environment
    SCREEN_WIDTH = 1440
    SCREEN_HEIGHT = 900

    # 2. Start the Playwright browser
    # In production, utilize a sandboxed environment.
    playwright = sync_playwright().start()
    # Set headless=False to see the actions performed on your screen
    browser = playwright.chromium.launch(headless=False)

    # 3. Create a context and page with the specified dimensions
    context = browser.new_context(
        viewport={"width": SCREEN_WIDTH, "height": SCREEN_HEIGHT}
    )
    page = context.new_page()

    # 4. Navigate to an initial page to start the task
    page.goto("https://www.google.com")

    # The 'page', 'SCREEN_WIDTH', and 'SCREEN_HEIGHT' variables
    # will be used in the steps below.
    

Beispielcode für die Erweiterung auf eine Android-Umgebung finden Sie im Abschnitt Benutzerdefinierte Funktionen verwenden.

1. Anfrage an das Modell senden

Fügen Sie Ihrer API-Anfrage das Tool „Computer Use“ hinzu und senden Sie einen Prompt an das Modell, der das Ziel des Nutzers enthält. Sie müssen eines der unterstützten Modelle für die Computernutzung verwenden, da sonst ein Fehler auftritt:

• gemini-2.5-computer-use-preview-10-2025
• gemini-3-pro-preview
• gemini-3-flash-preview

Optional können Sie auch die folgenden Parameter hinzufügen:

• Ausgeschlossene Aktionen:Wenn es Aktionen aus der Liste der unterstützten UI-Aktionen gibt, die das Modell nicht ausführen soll, geben Sie diese Aktionen als excluded_predefined_functions an.
• Benutzerdefinierte Funktionen:Zusätzlich zum Tool „Computer Use“ können Sie benutzerdefinierte Funktionen einfügen.

Die Anzeigegröße muss bei einer Anfrage nicht angegeben werden. Das Modell sagt Pixelkoordinaten voraus, die auf die Höhe und Breite des Bildschirms skaliert werden.

from google import genai
from google.genai import types
from google.genai.types import Content, Part

client = genai.Client()

# Specify predefined functions to exclude (optional)
excluded_functions = ["drag_and_drop"]

generate_content_config = genai.types.GenerateContentConfig(
    tools=[
        # 1. Computer Use tool with browser environment
        types.Tool(
            computer_use=types.ComputerUse(
                environment=types.Environment.ENVIRONMENT_BROWSER,
                # Optional: Exclude specific predefined functions
                excluded_predefined_functions=excluded_functions
                )
              ),
        # 2. Optional: Custom user-defined functions
        #types.Tool(
          # function_declarations=custom_functions
          #   )
          ],
  )

# Create the content with user message
contents=[
    Content(
        role="user",
        parts=[
            Part(text="Search for highly rated smart fridges with touchscreen, 2 doors, around 25 cu ft, priced below 4000 dollars on Google Shopping. Create a bulleted list of the 3 cheapest options in the format of name, description, price in an easy-to-read layout."),
        ],
    )
]

# Generate content with the configured settings
response = client.models.generate_content(
    model='gemini-2.5-computer-use-preview-10-2025',
    contents=contents,
    config=generate_content_config,
)

# Print the response output
print(response)

Ein Beispiel mit benutzerdefinierten Funktionen finden Sie unter Benutzerdefinierte benutzerdefinierte Funktionen verwenden.

2. Antwort des Modells erhalten

Wenn das Tool „Computer verwenden“ aktiviert ist, antwortet das Modell mit einem oder mehreren FunctionCalls, wenn es feststellt, dass UI-Aktionen erforderlich sind, um die Aufgabe zu erledigen. Die Funktion „Computer Use“ unterstützt parallele Funktionsaufrufe. Das bedeutet, dass das Modell in einem einzigen Zug mehrere Aktionen zurückgeben kann.

Hier ist ein Beispiel für eine Modellantwort.

{
  "content": {
    "parts": [
      {
        "text": "I will type the search query into the search bar. The search bar is in the center of the page."
      },
      {
        "function_call": {
          "name": "type_text_at",
          "args": {
            "x": 371,
            "y": 470,
            "text": "highly rated smart fridges with touchscreen, 2 doors, around 25 cu ft, priced below 4000 dollars on Google Shopping",
            "press_enter": true
          }
        }
      }
    ]
  }
}

3. Erhaltene Aktionen ausführen

Ihr Anwendungscode muss die Modellantwort parsen, die Aktionen ausführen und die Ergebnisse erfassen.

Im folgenden Beispielcode werden Funktionsaufrufe aus der Antwort des Modells „Computer Use“ extrahiert und in Aktionen übersetzt, die mit Playwright ausgeführt werden können. Das Modell gibt normalisierte Koordinaten (0–999) unabhängig von den Abmessungen des Eingabebilds aus. Ein Teil des Übersetzungsschritts besteht also darin, diese normalisierten Koordinaten wieder in tatsächliche Pixelwerte zu konvertieren.

Die empfohlene Bildschirmgröße für die Verwendung mit dem Modell „Computer Use“ ist (1440, 900). Das Modell funktioniert mit jeder Auflösung, die Qualität der Ergebnisse kann jedoch beeinträchtigt werden.

Dieses Beispiel enthält nur die Implementierung für die drei häufigsten UI-Aktionen: open_web_browser, click_at und type_text_at. Für Produktionsanwendungsfälle müssen Sie alle anderen UI-Aktionen aus der Liste Unterstützte Aktionen implementieren, sofern Sie sie nicht explizit als excluded_predefined_functions hinzufügen.

from typing import Any, List, Tuple
import time

def denormalize_x(x: int, screen_width: int) -> int:
    """Convert normalized x coordinate (0-1000) to actual pixel coordinate."""
    return int(x / 1000 * screen_width)

def denormalize_y(y: int, screen_height: int) -> int:
    """Convert normalized y coordinate (0-1000) to actual pixel coordinate."""
    return int(y / 1000 * screen_height)

def execute_function_calls(candidate, page, screen_width, screen_height):
    results = []
    function_calls = []
    for part in candidate.content.parts:
        if part.function_call:
            function_calls.append(part.function_call)

    for function_call in function_calls:
        action_result = {}
        fname = function_call.name
        args = function_call.args
        print(f"  -> Executing: {fname}")

        try:
            if fname == "open_web_browser":
                pass # Already open
            elif fname == "click_at":
                actual_x = denormalize_x(args["x"], screen_width)
                actual_y = denormalize_y(args["y"], screen_height)
                page.mouse.click(actual_x, actual_y)
            elif fname == "type_text_at":
                actual_x = denormalize_x(args["x"], screen_width)
                actual_y = denormalize_y(args["y"], screen_height)
                text = args["text"]
                press_enter = args.get("press_enter", False)

                page.mouse.click(actual_x, actual_y)
                # Simple clear (Command+A, Backspace for Mac)
                page.keyboard.press("Meta+A")
                page.keyboard.press("Backspace")
                page.keyboard.type(text)
                if press_enter:
                    page.keyboard.press("Enter")
            else:
                print(f"Warning: Unimplemented or custom function {fname}")

            # Wait for potential navigations/renders
            page.wait_for_load_state(timeout=5000)
            time.sleep(1)

        except Exception as e:
            print(f"Error executing {fname}: {e}")
            action_result = {"error": str(e)}

        results.append((fname, action_result))

    return results

4. Neuen Umgebungsstatus erfassen

Senden Sie nach der Ausführung der Aktionen das Ergebnis der Funktionsausführung zurück an das Modell, damit es diese Informationen zum Generieren der nächsten Aktion verwenden kann. Wenn mehrere Aktionen (parallele Aufrufe) ausgeführt wurden, müssen Sie im nächsten Nutzerzug für jede Aktion ein FunctionResponse senden.

def get_function_responses(page, results):
    screenshot_bytes = page.screenshot(type="png")
    current_url = page.url
    function_responses = []
    for name, result in results:
        response_data = {"url": current_url}
        response_data.update(result)
        function_responses.append(
            types.FunctionResponse(
                name=name,
                response=response_data,
                parts=[types.FunctionResponsePart(
                        inline_data=types.FunctionResponseBlob(
                            mime_type="image/png",
                            data=screenshot_bytes))
                ]
            )
        )
    return function_responses

Agent-Schleife erstellen

Um mehrstufige Interaktionen zu ermöglichen, kombinieren Sie die vier Schritte aus dem Abschnitt Computer Use implementieren in einer Schleife. Denken Sie daran, den Unterhaltungsverlauf richtig zu verwalten, indem Sie sowohl Modellantworten als auch Ihre Funktionsantworten anhängen.

So führen Sie dieses Codebeispiel aus:

• Installieren Sie die erforderlichen Playwright-Abhängigkeiten.

• Definieren Sie die Hilfsfunktionen aus den Schritten (3) Empfangene Aktionen ausführen und (4) Neuen Umgebungsstatus erfassen.

import time
from typing import Any, List, Tuple
from playwright.sync_api import sync_playwright

from google import genai
from google.genai import types
from google.genai.types import Content, Part

client = genai.Client()

# Constants for screen dimensions
SCREEN_WIDTH = 1440
SCREEN_HEIGHT = 900

# Setup Playwright
print("Initializing browser...")
playwright = sync_playwright().start()
browser = playwright.chromium.launch(headless=False)
context = browser.new_context(viewport={"width": SCREEN_WIDTH, "height": SCREEN_HEIGHT})
page = context.new_page()

# Define helper functions. Copy/paste from steps 3 and 4
# def denormalize_x(...)
# def denormalize_y(...)
# def execute_function_calls(...)
# def get_function_responses(...)

try:
    # Go to initial page
    page.goto("https://ai.google.dev/gemini-api/docs")

    # Configure the model (From Step 1)
    config = types.GenerateContentConfig(
        tools=[types.Tool(computer_use=types.ComputerUse(
            environment=types.Environment.ENVIRONMENT_BROWSER
        ))],
        thinking_config=types.ThinkingConfig(include_thoughts=True),
    )

    # Initialize history
    initial_screenshot = page.screenshot(type="png")
    USER_PROMPT = "Go to ai.google.dev/gemini-api/docs and search for pricing."
    print(f"Goal: {USER_PROMPT}")

    contents = [
        Content(role="user", parts=[
            Part(text=USER_PROMPT),
            Part.from_bytes(data=initial_screenshot, mime_type='image/png')
        ])
    ]

    # Agent Loop
    turn_limit = 5
    for i in range(turn_limit):
        print(f"\n--- Turn {i+1} ---")
        print("Thinking...")
        response = client.models.generate_content(
            model='gemini-2.5-computer-use-preview-10-2025',
            contents=contents,
            config=config,
        )

        candidate = response.candidates[0]
        contents.append(candidate.content)

        has_function_calls = any(part.function_call for part in candidate.content.parts)
        if not has_function_calls:
            text_response = " ".join([part.text for part in candidate.content.parts if part.text])
            print("Agent finished:", text_response)
            break

        print("Executing actions...")
        results = execute_function_calls(candidate, page, SCREEN_WIDTH, SCREEN_HEIGHT)

        print("Capturing state...")
        function_responses = get_function_responses(page, results)

        contents.append(
            Content(role="user", parts=[Part(function_response=fr) for fr in function_responses])
        )

finally:
    # Cleanup
    print("\nClosing browser...")
    browser.close()
    playwright.stop()

Benutzerdefinierte Funktionen verwenden

Optional können Sie benutzerdefinierte Funktionen in Ihre Anfrage einfügen, um die Funktionalität des Modells zu erweitern. Im folgenden Beispiel wird das Modell und Tool für die Computernutzung an mobile Anwendungsfälle angepasst. Dazu werden benutzerdefinierte Aktionen wie open_app, long_press_at und go_home einbezogen, während browserspezifische Aktionen ausgeschlossen werden. Das Modell kann diese benutzerdefinierten Funktionen zusammen mit Standard-UI-Aktionen intelligent aufrufen, um Aufgaben in Nicht-Browser-Umgebungen auszuführen.

from typing import Optional, Dict, Any

from google import genai
from google.genai import types
from google.genai.types import Content, Part

client = genai.Client()

SYSTEM_PROMPT = """You are operating an Android phone. Today's date is October 15, 2023, so ignore any other date provided.
* To provide an answer to the user, *do not use any tools* and output your answer on a separate line. IMPORTANT: Do not add any formatting or additional punctuation/text, just output the answer by itself after two empty lines.
* Make sure you scroll down to see everything before deciding something isn't available.
* You can open an app from anywhere. The icon doesn't have to currently be on screen.
* Unless explicitly told otherwise, make sure to save any changes you make.
* If text is cut off or incomplete, scroll or click into the element to get the full text before providing an answer.
* IMPORTANT: Complete the given task EXACTLY as stated. DO NOT make any assumptions that completing a similar task is correct.  If you can't find what you're looking for, SCROLL to find it.
* If you want to edit some text, ONLY USE THE `type` tool. Do not use the onscreen keyboard.
* Quick settings shouldn't be used to change settings. Use the Settings app instead.
* The given task may already be completed. If so, there is no need to do anything.
"""

def open_app(app_name: str, intent: Optional[str] = None) -> Dict[str, Any]:
    """Opens an app by name.

    Args:
        app_name: Name of the app to open (any string).
        intent: Optional deep-link or action to pass when launching, if the app supports it.

    Returns:
        JSON payload acknowledging the request (app name and optional intent).
    """
    return {"status": "requested_open", "app_name": app_name, "intent": intent}

def long_press_at(x: int, y: int) -> Dict[str, int]:
    """Long-press at a specific screen coordinate.

    Args:
        x: X coordinate (absolute), scaled to the device screen width (pixels).
        y: Y coordinate (absolute), scaled to the device screen height (pixels).

    Returns:
        Object with the coordinates pressed and the duration used.
    """
    return {"x": x, "y": y}

def go_home() -> Dict[str, str]:
    """Navigates to the device home screen.

    Returns:
        A small acknowledgment payload.
    """
    return {"status": "home_requested"}

#  Build function declarations
CUSTOM_FUNCTION_DECLARATIONS = [
    types.FunctionDeclaration.from_callable(client=client, callable=open_app),
    types.FunctionDeclaration.from_callable(client=client, callable=long_press_at),
    types.FunctionDeclaration.from_callable(client=client, callable=go_home),
]

#Exclude browser functions
EXCLUDED_PREDEFINED_FUNCTIONS = [
    "open_web_browser",
    "search",
    "navigate",
    "hover_at",
    "scroll_document",
    "go_forward",
    "key_combination",
    "drag_and_drop",
]

#Utility function to construct a GenerateContentConfig
def make_generate_content_config() -> genai.types.GenerateContentConfig:
    """Return a fixed GenerateContentConfig with Computer Use + custom functions."""
    return genai.types.GenerateContentConfig(
        system_instruction=SYSTEM_PROMPT,
        tools=[
            types.Tool(
                computer_use=types.ComputerUse(
                    environment=types.Environment.ENVIRONMENT_BROWSER,
                    excluded_predefined_functions=EXCLUDED_PREDEFINED_FUNCTIONS,
                )
            ),
            types.Tool(function_declarations=CUSTOM_FUNCTION_DECLARATIONS),
        ],
    )

# Create the content with user message
contents: list[Content] = [
    Content(
        role="user",
        parts=[
            # text instruction
            Part(text="Open Chrome, then long-press at 200,400."),
        ],
    )
]

# Build your fixed config (from helper)
config = make_generate_content_config()

# Generate content with the configured settings
response = client.models.generate_content(
        model='gemini-2.5-computer-use-preview-10-2025',
        contents=contents,
        config=config,
    )

print(response)

Unterstützte UI-Aktionen

Das Modell kann die folgenden UI-Aktionen über ein FunctionCall anfordern. In Ihrem clientseitigen Code muss die Ausführungslogik für diese Aktionen implementiert werden. Referenzimplementierung

Sicherheit

Sicherheitsentscheidung bestätigen

Je nach Aktion kann die Modellantwort auch ein safety_decision von einem internen Sicherheitssystem enthalten, das die vorgeschlagene Aktion des Modells prüft.

{
  "content": {
    "parts": [
      {
        "text": "I have evaluated step 2. It seems Google detected unusual traffic and is asking me to verify I'm not a robot. I need to click the 'I'm not a robot' checkbox located near the top left (y=98, x=95).",
      },
      {
        "function_call": {
          "name": "click_at",
          "args": {
            "x": 60,
            "y": 100,
            "safety_decision": {
              "explanation": "I have encountered a CAPTCHA challenge that requires interaction. I need you to complete the challenge by clicking the 'I'm not a robot' checkbox and any subsequent verification steps.",
              "decision": "require_confirmation"
            }
          }
        }
      }
    ]
  }
}

Wenn safety_decision gleich require_confirmation ist, müssen Sie den Endnutzer um Bestätigung bitten, bevor Sie mit der Ausführung der Aktion fortfahren. Gemäß den Nutzungsbedingungen ist es nicht zulässig, Anfragen zur Bestätigung durch einen Menschen zu umgehen.

In diesem Codebeispiel wird der Endnutzer vor der Ausführung der Aktion um Bestätigung gebeten. Wenn der Nutzer die Aktion nicht bestätigt, wird die Schleife beendet. Wenn der Nutzer die Aktion bestätigt, wird sie ausgeführt und das Feld safety_acknowledgement wird als True markiert.

import termcolor

def get_safety_confirmation(safety_decision):
    """Prompt user for confirmation when safety check is triggered."""
    termcolor.cprint("Safety service requires explicit confirmation!", color="red")
    print(safety_decision["explanation"])

    decision = ""
    while decision.lower() not in ("y", "n", "ye", "yes", "no"):
        decision = input("Do you wish to proceed? [Y]es/[N]o\n")

    if decision.lower() in ("n", "no"):
        return "TERMINATE"
    return "CONTINUE"

def execute_function_calls(candidate, page, screen_width, screen_height):

    # ... Extract function calls from response ...

    for function_call in function_calls:
        extra_fr_fields = {}

        # Check for safety decision
        if 'safety_decision' in function_call.args:
            decision = get_safety_confirmation(function_call.args['safety_decision'])
            if decision == "TERMINATE":
                print("Terminating agent loop")
                break
            extra_fr_fields["safety_acknowledgement"] = "true" # Safety acknowledgement

        # ... Execute function call and append to results ...

Wenn der Nutzer dies bestätigt, müssen Sie die Sicherheitsbestätigung in Ihre FunctionResponse aufnehmen.

function_response_parts.append(
    FunctionResponse(
        name=name,
        response={"url": current_url,
                  **extra_fr_fields},  # Include safety acknowledgement
        parts=[
            types.FunctionResponsePart(
                inline_data=types.FunctionResponseBlob(
                    mime_type="image/png", data=screenshot
                )
             )
           ]
         )
       )

Best Practices für die Sicherheit

Die Computernutzung ist ein neuartiges Tool, das neue Risiken birgt, die Entwickler berücksichtigen sollten:

• Nicht vertrauenswürdige Inhalte und Betrug: Da das Modell versucht, das Ziel des Nutzers zu erreichen, kann es auf nicht vertrauenswürdige Informationsquellen und Anweisungen auf dem Bildschirm zurückgreifen. Wenn das Ziel des Nutzers beispielsweise darin besteht, ein Pixel Smartphone zu kaufen, und das Modell auf einen Betrugsstil „Kostenloses Pixel, wenn Sie eine Umfrage ausfüllen“ stößt, besteht eine gewisse Wahrscheinlichkeit, dass das Modell die Umfrage ausfüllt.
• Gelegentliche unbeabsichtigte Aktionen:Das Modell kann das Ziel eines Nutzers oder den Inhalt einer Webseite falsch interpretieren und dadurch falsche Aktionen ausführen, z. B. auf die falsche Schaltfläche klicken oder das falsche Formular ausfüllen. Dies kann zu fehlgeschlagenen Aufgaben oder zum Abziehen von Daten führen.
• Richtlinienverstöße:Die Funktionen der API könnten, ob absichtlich oder nicht, auf Aktivitäten ausgerichtet sein, die gegen die Google-Richtlinien verstoßen (Richtlinie zu unzulässiger Nutzung von generativer KI und Zusatzbedingungen für die Gemini API). Dazu gehören Aktionen, die die Integrität eines Systems beeinträchtigen, die Sicherheit gefährden, Sicherheitsmaßnahmen umgehen oder medizinische Geräte steuern könnten.

Um diese Risiken zu minimieren, können Sie die folgenden Sicherheitsmaßnahmen und Best Practices implementieren:

1. Human-in-the-Loop (HITL):

   • Nutzerbestätigung implementieren:Wenn in der Sicherheitsantwort require_confirmation angegeben ist, müssen Sie vor der Ausführung eine Nutzerbestätigung implementieren. Beispielcode

   • Benutzerdefinierte Sicherheitshinweise bereitstellen:Zusätzlich zu den integrierten Nutzerbestätigungsprüfungen können Entwickler optional eine benutzerdefinierte Systemanweisung hinzufügen, mit der sie ihre eigenen Sicherheitsrichtlinien durchsetzen, um bestimmte Modellaktionen zu blockieren oder eine Nutzerbestätigung zu verlangen, bevor das Modell bestimmte irreversible Aktionen mit hohem Risiko ausführt. Hier ist ein Beispiel für eine benutzerdefinierte Systemanweisung zur Sicherheit, die Sie bei der Interaktion mit dem Modell einfügen können.

     Beispiele für Sicherheitshinweise

     Legen Sie Ihre benutzerdefinierten Sicherheitsregeln als Systemanweisung fest:

         ## **RULE 1: Seek User Confirmation (USER_CONFIRMATION)**
     
         This is your first and most important check. If the next required action falls
         into any of the following categories, you MUST stop immediately, and seek the
         user's explicit permission.
     
         **Procedure for Seeking Confirmation:**  * **For Consequential Actions:**
         Perform all preparatory steps (e.g., navigating, filling out forms, typing a
         message). You will ask for confirmation **AFTER** all necessary information is
         entered on the screen, but **BEFORE** you perform the final, irreversible action
         (e.g., before clicking "Send", "Submit", "Confirm Purchase", "Share").  * **For
         Prohibited Actions:** If the action is strictly forbidden (e.g., accepting legal
         terms, solving a CAPTCHA), you must first inform the user about the required
         action and ask for their confirmation to proceed.
     
         **USER_CONFIRMATION Categories:**
     
         *   **Consent and Agreements:** You are FORBIDDEN from accepting, selecting, or
             agreeing to any of the following on the user's behalf. You must ask the
             user to confirm before performing these actions.
             *   Terms of Service
             *   Privacy Policies
             *   Cookie consent banners
             *   End User License Agreements (EULAs)
             *   Any other legally significant contracts or agreements.
         *   **Robot Detection:** You MUST NEVER attempt to solve or bypass the
             following. You must ask the user to confirm before performing these actions.
         *   CAPTCHAs (of any kind)
             *   Any other anti-robot or human-verification mechanisms, even if you are
                 capable.
         *   **Financial Transactions:**
             *   Completing any purchase.
             *   Managing or moving money (e.g., transfers, payments).
             *   Purchasing regulated goods or participating in gambling.
         *   **Sending Communications:**
             *   Sending emails.
             *   Sending messages on any platform (e.g., social media, chat apps).
             *   Posting content on social media or forums.
         *   **Accessing or Modifying Sensitive Information:**
             *   Health, financial, or government records (e.g., medical history, tax
                 forms, passport status).
             *   Revealing or modifying sensitive personal identifiers (e.g., SSN, bank
                 account number, credit card number).
         *   **User Data Management:**
             *   Accessing, downloading, or saving files from the web.
             *   Sharing or sending files/data to any third party.
             *   Transferring user data between systems.
         *   **Browser Data Usage:**
             *   Accessing or managing Chrome browsing history, bookmarks, autofill data,
                 or saved passwords.
         *   **Security and Identity:**
             *   Logging into any user account.
             *   Any action that involves misrepresentation or impersonation (e.g.,
                 creating a fan account, posting as someone else).
         *   **Insurmountable Obstacles:** If you are technically unable to interact with
             a user interface element or are stuck in a loop you cannot resolve, ask the
             user to take over.
         ---
     
         ## **RULE 2: Default Behavior (ACTUATE)**
     
         If an action does **NOT** fall under the conditions for `USER_CONFIRMATION`,
         your default behavior is to **Actuate**.
     
         **Actuation Means:**  You MUST proactively perform all necessary steps to move
         the user's request forward. Continue to actuate until you either complete the
         non-consequential task or encounter a condition defined in Rule 1.
     
         *   **Example 1:** If asked to send money, you will navigate to the payment
             portal, enter the recipient's details, and enter the amount. You will then
             **STOP** as per Rule 1 and ask for confirmation before clicking the final
             "Send" button.
         *   **Example 2:** If asked to post a message, you will navigate to the site,
             open the post composition window, and write the full message. You will then
             **STOP** as per Rule 1 and ask for confirmation before clicking the final
             "Post" button.
     
             After the user has confirmed, remember to get the user's latest screen
             before continuing to perform actions.
     
         # Final Response Guidelines:
         Write final response to the user in the following cases:
         - User confirmation
         - When the task is complete or you have enough information to respond to the user
         

2. Sichere Ausführungsumgebung:Führen Sie Ihren Agent in einer sicheren Sandbox-Umgebung aus, um seine potenziellen Auswirkungen zu begrenzen (z.B. Eine Sandbox-VM, ein Container (z.B. Docker) oder ein dediziertes Browserprofil mit eingeschränkten Berechtigungen.

3. Eingabebereinigung:Bereinigen Sie alle von Nutzern generierten Texte in Prompts, um das Risiko unbeabsichtigter Anweisungen oder Prompt-Injection zu minimieren. Dies ist eine hilfreiche Sicherheitsebene, aber kein Ersatz für eine sichere Ausführungsumgebung.

4. Inhaltsvorkehrungen:Verwenden Sie Vorkehrungen und APIs für die Inhaltssicherheit, um Nutzereingaben, Tool-Ein- und -Ausgaben sowie die Antwort eines Agenten auf Angemessenheit, Prompt-Injection und Jailbreak-Erkennung zu prüfen.

5. Zulassungs- und Sperrlisten:Implementieren Sie Filtermechanismen, um zu steuern, wohin das Modell navigieren und was es tun kann. Eine Sperrliste mit verbotenen Websites ist ein guter Ausgangspunkt. Eine restriktivere Zulassungsliste ist noch sicherer.

6. Beobachtbarkeit und Protokollierung:Führen Sie detaillierte Protokolle für das Debugging, die Prüfung und die Reaktion auf Vorfälle. Ihr Client sollte Eingabeaufforderungen, Screenshots, vom Modell vorgeschlagene Aktionen (function_call), Sicherheitsantworten und alle Aktionen protokollieren, die letztendlich vom Client ausgeführt werden.

7. Umgebungsverwaltung:Sorgen Sie für eine konsistente GUI-Umgebung. Unerwartete Pop-ups, Benachrichtigungen oder Layoutänderungen können das Modell verwirren. Beginnen Sie nach Möglichkeit jede neue Aufgabe mit einem bekannten, sauberen Zustand.

Modellversionen

Nächste Schritte

• Browserbase-Demo
• Beispielcode finden Sie in der Referenzimplementierung.
• Weitere Informationen zu anderen Gemini API-Tools:
  • Funktionsaufrufe
  • Fundierung mit der Google Suche