Uso de la computadora

El modelo y la herramienta de versión preliminar de Gemini 2.5 para uso en computadoras te permiten crear agentes de control del navegador que interactúan con tareas y las automatizan. Con capturas de pantalla, el modelo de uso de la computadora puede "ver" una pantalla de computadora y "actuar" generando acciones específicas de la IU, como clics del mouse y entradas del teclado. Al igual que con la llamada a funciones, debes escribir el código de la aplicación del cliente para recibir y ejecutar las acciones de Computer Use.

Con Computer Use, puedes compilar agentes que hagan lo siguiente:

• Automatiza el ingreso de datos repetitivos o el llenado de formularios en sitios web.
• Realiza pruebas automatizadas de aplicaciones web y flujos de usuarios
• Realizar investigaciones en varios sitios web (p.ej., recopilar información de productos, precios y opiniones de sitios de comercio electrónico para informar una compra)

La forma más sencilla de probar el modelo de Gemini Computer Use es a través de la implementación de referencia o el entorno de demostración de Browserbase.

Cómo funciona el uso de la computadora

Para compilar un agente de control del navegador con el modelo de uso de la computadora, implementa un bucle del agente que haga lo siguiente:

1. Envía una solicitud al modelo

   • Agrega la herramienta Computer Use y, de manera opcional, cualquier función personalizada definida por el usuario o función excluida a tu solicitud de API.
   • Indica al modelo de Computer Use la solicitud del usuario y una captura de pantalla que represente el estado actual de la GUI.

2. Recibe la respuesta del modelo

   • El modelo de Computer Use analiza la solicitud y la captura de pantalla del usuario, y genera una respuesta que incluye un function_call sugerido que representa una acción de la IU (p.ej., "click at coordinate (x,y)" o "type 'text'"). Para obtener una descripción de todas las acciones de la IU compatibles con el modelo de uso de la computadora, consulta Acciones compatibles.
   • La respuesta de la API también puede incluir un safety_decision de un sistema de seguridad interno que verifica la acción propuesta del modelo. Este safety_decision clasifica la acción de la siguiente manera:
     • Normal o permitida: La acción se considera segura. Esto también se puede representar con la ausencia de safety_decision.
     • Requiere confirmación (require_confirmation): El modelo está a punto de realizar una acción que puede ser riesgosa (p.ej., hacer clic en un "banner de aceptación de cookies").

3. Ejecuta la acción recibida

   • Tu código del cliente recibe el objeto function_call y cualquier objeto safety_decision que lo acompañe.
     • Normal / permitido: Si el safety_decision indica normal/permitido (o si no hay ningún safety_decision), tu código del cliente puede ejecutar el function_call especificado en tu entorno objetivo (p.ej., un navegador web).
     • Requiere confirmación: Si safety_decision indica que se requiere confirmación, tu aplicación debe solicitarle al usuario final que confirme antes de ejecutar function_call. Si el usuario confirma, continúa con la ejecución de la acción. Si el usuario rechaza la acción, no la ejecutes.

4. Captura el estado del entorno nuevo

   • Si la acción se ejecutó, tu cliente captura una nueva captura de pantalla de la GUI y la URL actual para enviarla de vuelta al modelo de Computer Use como parte de un function_response.
   • Si el sistema de seguridad bloqueó una acción o el usuario rechazó la confirmación, es posible que tu aplicación envíe otro tipo de comentarios al modelo o finalice la interacción.

Este proceso se repite desde el paso 2 con el modelo de uso de la computadora, que usa la nueva captura de pantalla y el objetivo en curso para sugerir la siguiente acción. El bucle continúa hasta que se completa la tarea, se produce un error o se finaliza el proceso (p.ej., debido a una respuesta de seguridad de "bloqueo" o a una decisión del usuario).

Cómo implementar el uso de la computadora

Antes de compilar con el modelo y la herramienta de uso de la computadora, deberás configurar lo siguiente:

• Entorno de ejecución seguro: Por motivos de seguridad, debes ejecutar tu agente de Computer Use en un entorno seguro y controlado (p.ej., una máquina virtual de zona de pruebas, un contenedor o un perfil de navegador dedicado con permisos limitados).
• Controlador de acciones del cliente: Deberás implementar lógica del cliente para ejecutar las acciones que genera el modelo y capturar capturas de pantalla del entorno después de cada acción.

En los ejemplos de esta sección, se usa un navegador como entorno de ejecución y Playwright como controlador de acciones del cliente. Para ejecutar estas muestras, debes instalar las dependencias necesarias e inicializar una instancia del navegador Playwright.

    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.
    

En la sección Cómo usar funciones personalizadas definidas por el usuario, se incluye un ejemplo de código para extenderse a un entorno de Android.

1. Envía una solicitud al modelo

Agrega la herramienta Computer Use a tu solicitud de API y envía una instrucción al modelo Computer Use que incluya el objetivo del usuario y una captura de pantalla inicial de la GUI. Debes usar el modelo de uso de computadora de Gemini, gemini-2.5-computer-use-preview-10-2025. Si intentas usar la herramienta Computer Use con un modelo diferente, recibirás un error.

También puedes agregar los siguientes parámetros de forma opcional:

• Acciones excluidas: Si hay acciones de la lista de acciones de IU admitidas que no quieres que realice el modelo, especifícalas como excluded_predefined_functions.
• Funciones definidas por el usuario: Además de la herramienta Uso de la computadora, es posible que desees incluir funciones personalizadas definidas por el usuario.

Ten en cuenta que no es necesario especificar el tamaño de la pantalla cuando se envía una solicitud. El modelo predice las coordenadas de píxeles ajustadas a la altura y el ancho de la pantalla.

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."),
            # Optional: include a screenshot of the initial state
            #Part.from_bytes(
                #data=screenshot_image_bytes,
                #mime_type='image/png',
            #),
        ],
    )
]

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

Para ver un ejemplo con funciones personalizadas, consulta Cómo usar funciones personalizadas definidas por el usuario.

2. Recibe la respuesta del modelo

El modelo de uso de la computadora responderá con uno o más FunctionCalls si determina que se necesitan acciones de la IU para completar la tarea. El uso de la computadora admite llamadas a funciones paralelas, lo que significa que el modelo puede devolver varias acciones en un solo turno.

Esta es una respuesta de ejemplo del modelo.

{
  "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. Ejecuta las acciones recibidas

El código de tu aplicación debe analizar la respuesta del modelo, ejecutar las acciones y recopilar los resultados.

En el siguiente código de ejemplo, se extraen las llamadas a función de la respuesta del modelo de uso de la computadora y se traducen en acciones que se pueden ejecutar con Playwright. El modelo genera coordenadas normalizadas (0 a 999) independientemente de las dimensiones de la imagen de entrada, por lo que parte del paso de traducción consiste en convertir estas coordenadas normalizadas de nuevo en valores de píxeles reales.

El tamaño de pantalla recomendado para usar con el modelo de uso de la computadora es (1440, 900). El modelo funcionará con cualquier resolución, aunque la calidad de los resultados puede verse afectada.

Este ejemplo solo incluye la implementación de las 3 acciones de IU más comunes: open_web_browser, click_at y type_text_at. Para los casos de uso de producción, deberás implementar todas las demás acciones de la IU de la lista de acciones admitidas, a menos que las agregues explícitamente como excluded_predefined_functions.

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

# Execute function calls
candidate = response.candidates[0]
results = execute_function_calls(response.candidates[0], page, SCREEN_WIDTH, SCREEN_HEIGHT)

4. Captura el estado del entorno nuevo

Después de ejecutar las acciones, envía el resultado de la ejecución de la función al modelo para que pueda usar esta información y generar la siguiente acción. Si se ejecutaron varias acciones (llamadas paralelas), debes enviar un FunctionResponse para cada una en el turno del usuario subsiguiente.

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

# Capture state and return to model
function_responses = get_function_responses(page, results)
user_feedback_content = Content(
    role="user",
    parts=[Part(function_response=fr) for fr in function_responses])

# Append this feedback to the 'contents' history list for the next API call.
contents.append(user_feedback_content)

Crea un bucle de agente

Para habilitar las interacciones de varios pasos, combina los cuatro pasos de la sección Cómo implementar el uso de la computadora en un bucle. Recuerda administrar el historial de conversación correctamente agregando las respuestas del modelo y las respuestas de tu función.

Para ejecutar esta muestra de código, debes hacer lo siguiente:

• Instala las dependencias necesarias de Playwright.

• Define las funciones de ayuda de los pasos (3) Ejecuta las acciones recibidas y (4) Captura el nuevo estado del entorno.

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

Cómo usar funciones personalizadas definidas por el usuario

De manera opcional, puedes incluir funciones personalizadas definidas por el usuario en tu solicitud para extender la funcionalidad del modelo. En el siguiente ejemplo, se adapta el modelo y la herramienta de uso de la computadora para casos de uso en dispositivos móviles, ya que se incluyen acciones personalizadas definidas por el usuario, como open_app, long_press_at y go_home, y se excluyen las acciones específicas del navegador. El modelo puede llamar de forma inteligente a estas funciones personalizadas junto con las acciones estándar de la IU para completar tareas en entornos que no son navegadores.

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."),
            # optional screenshot attachment
            Part.from_bytes(
                data=screenshot_image_bytes,
                mime_type="image/png",
            ),
        ],
    )
]

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

Acciones de IU admitidas

El modelo de uso de la computadora puede solicitar las siguientes acciones de la IU a través de un FunctionCall. Tu código del cliente debe implementar la lógica de ejecución para estas acciones. Consulta la implementación de referencia para ver ejemplos.

Seguridad y protección

Confirma la decisión de seguridad

Según la acción, la respuesta del modelo también puede incluir un safety_decision de un sistema de seguridad interno que verifica la acción propuesta del modelo.

{
  "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"
            }
          }
        }
      }
    ]
  }
}

Si safety_decision es require_confirmation, debes pedirle al usuario final que confirme antes de ejecutar la acción. Según las condiciones del servicio, no puedes omitir las solicitudes de confirmación humana.

En esta muestra de código, se solicita confirmación al usuario final antes de ejecutar la acción. Si el usuario no confirma la acción, el bucle finaliza. Si el usuario confirma la acción, esta se ejecuta y el campo safety_acknowledgement se marca como True.

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

Si el usuario confirma, debes incluir la confirmación de seguridad en tu FunctionResponse.

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

Prácticas recomendadas de seguridad

La API de Computer Use es una API novedosa y presenta nuevos riesgos que los desarrolladores deben tener en cuenta:

• Contenido no confiable y estafas: A medida que el modelo intenta alcanzar el objetivo del usuario, es posible que se base en fuentes de información y en instrucciones de la pantalla que no sean confiables. Por ejemplo, si el objetivo del usuario es comprar un teléfono Pixel y el modelo se encuentra con una estafa del tipo "Pixel gratis si completas una encuesta", es posible que el modelo complete la encuesta.
• Acciones no deseadas ocasionales: El modelo puede interpretar de forma incorrecta el objetivo del usuario o el contenido de la página web, lo que hace que realice acciones incorrectas, como hacer clic en el botón equivocado o completar el formulario incorrecto. Esto puede provocar errores en las tareas o la filtración de datos.
• Incumplimientos de políticas: Las capacidades de la API podrían dirigirse, ya sea de forma intencional o no intencional, a actividades que incumplan las políticas de Google (la Política de Uso Prohibido de IA Generativas y las Condiciones del Servicio Adicionales de la API de Gemini). Esto incluye acciones que podrían interferir en la integridad de un sistema, comprometer la seguridad, eludir medidas de seguridad, controlar dispositivos médicos, etcétera.

Para abordar estos riesgos, puedes implementar las siguientes medidas de seguridad y prácticas recomendadas:

1. Interacción humana (HITL):

   • Implementa la confirmación del usuario: Cuando la respuesta de seguridad indique require_confirmation, debes implementar la confirmación del usuario antes de la ejecución. Consulta Acknowledge safety decision para obtener una muestra de código.

   • Proporciona instrucciones de seguridad personalizadas: Además de las verificaciones de confirmación del usuario integradas, los desarrolladores pueden agregar de forma opcional una instrucción del sistema personalizada que aplique sus propias políticas de seguridad, ya sea para bloquear ciertas acciones del modelo o para requerir la confirmación del usuario antes de que el modelo realice ciertas acciones irreversibles de alto riesgo. A continuación, se muestra un ejemplo de una instrucción personalizada del sistema de seguridad que puedes incluir cuando interactúas con el modelo.

     Ejemplo de instrucciones de seguridad

     Establece tus reglas de seguridad personalizadas como una instrucción del sistema:

         ## **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. Entorno de ejecución seguro: Ejecuta tu agente en un entorno seguro de zona de pruebas para limitar su impacto potencial (p.ej., Una máquina virtual (VM) en zona de pruebas, un contenedor (p.ej., Docker) o un perfil de navegador dedicado con permisos limitados.

3. Limpieza de entradas: Limpia todo el texto generado por el usuario en las instrucciones para mitigar el riesgo de instrucciones no deseadas o inyección de instrucciones. Esta es una capa de seguridad útil, pero no reemplaza un entorno de ejecución seguro.

4. Protecciones de contenido: Usa protecciones y APIs de seguridad del contenido para evaluar las entradas del usuario, la entrada y salida de herramientas, la respuesta de un agente en cuanto a adecuación, la inyección de instrucciones y la detección de jailbreaking.

5. Listas de entidades permitidas y bloqueadas: Implementa mecanismos de filtrado para controlar dónde puede navegar el modelo y qué puede hacer. Una lista de entidades bloqueadas de sitios web prohibidos es un buen punto de partida, mientras que una lista de entidades permitidas más restrictiva es aún más segura.

6. Observabilidad y registro: Mantén registros detallados para la depuración, la auditoría y la respuesta a incidentes. Tu cliente debe registrar las instrucciones, las capturas de pantalla, las acciones sugeridas por el modelo (function_call), las respuestas de seguridad y todas las acciones que, en última instancia, ejecute el cliente.

7. Administración del entorno: Asegúrate de que el entorno de la GUI sea coherente. Las ventanas emergentes, las notificaciones o los cambios en el diseño inesperados pueden confundir al modelo. Si es posible, comienza cada tarea nueva desde un estado limpio y conocido.

Versiones del modelo

¿Qué sigue?

• Experimenta con el uso de la computadora en el entorno de demostración de Browserbase.
• Consulta la implementación de referencia para ver un ejemplo de código.
• Obtén más información sobre otras herramientas de la API de Gemini:
  • Llamada a función
  • Grounding with Google Search