Использование компьютера

Функция «Использование компьютера» позволяет создавать агенты управления браузером, которые взаимодействуют с задачами и автоматизируют их. Используя скриншоты, модель может «видеть» экран компьютера и «действовать», генерируя определенные действия пользовательского интерфейса, такие как щелчки мыши и ввод с клавиатуры. Подобно вызову функций, вам необходимо написать код клиентского приложения для получения и выполнения действий, выполняемых функцией «Использование компьютера».

С помощью Computer Use вы можете создавать агентов, которые:

• Автоматизируйте повторяющийся ввод данных или заполнение форм на веб-сайтах.
• Проведите автоматизированное тестирование веб-приложений и пользовательских сценариев.
• Проведите исследование на различных веб-сайтах (например, соберите информацию о товарах, ценах и отзывах на сайтах электронной коммерции, чтобы принять решение о покупке).

Простейший способ проверить возможности использования компьютера — это использовать эталонную реализацию или демонстрационную среду Browserbase .

Как работает использование компьютера

Для создания агента управления браузером с использованием модели «Использование компьютера» необходимо реализовать цикл агента, выполняющий следующие действия:

1. Отправьте запрос модели

   • Добавьте в свой API-запрос инструмент «Использование компьютера», а также, при необходимости, любые пользовательские функции или функции, которые могут быть исключены.
   • Предоставьте модели использования компьютера запрос пользователя.

2. Получите ответ модели.

   • Модель использования компьютера анализирует запрос пользователя и снимок экрана и генерирует ответ, который включает предлагаемый function_call , представляющий собой действие пользовательского интерфейса (например, «щелкните по координатам (x,y)» или «введите 'текст'»). Описание всех действий пользовательского интерфейса, поддерживаемых моделью использования компьютера, см. в разделе «Поддерживаемые действия ».
   • В ответ API также может быть включено safety_decision от внутренней системы безопасности, которая проверяет предлагаемое моделью действие. Это safety_decision классифицирует действие следующим образом:
     • Обычный/разрешенный: Действие считается безопасным. Это также может быть обозначено отсутствием значения safety_decision .
     • Требуется подтверждение ( require_confirmation ): Модель собирается выполнить действие, которое может быть рискованным (например, нажать на баннер «принять cookie»).

3. Выполните полученное действие

   • Ваш клиентский код получает function_call и любое сопутствующее safety_decision .
     • Обычный/разрешенный: Если safety_decision указывает на обычный/разрешенный режим (или если safety_decision отсутствует), ваш клиентский код может выполнить указанный function_call в целевой среде (например, в веб-браузере).
     • Требуется подтверждение: Если safety_decision указывает на необходимость подтверждения, ваше приложение должно запросить подтверждение у конечного пользователя перед выполнением function_call . Если пользователь подтвердит, переходите к выполнению действия. Если пользователь откажется, действие выполняться не будет.

4. Зафиксировать новое состояние окружающей среды

   • Если действие выполнено, ваш клиент делает новый снимок экрана графического интерфейса и текущий URL-адрес, который отправляется обратно в модель использования компьютера в рамках function_response .
   • Если действие было заблокировано системой безопасности или отклонено пользователем, ваше приложение может отправить модели другой вид обратной связи или завершить взаимодействие.

Этот процесс повторяется, начиная с шага 2, при этом модель, используя новый снимок экрана и текущую цель, предлагает следующее действие. Цикл продолжается до тех пор, пока задача не будет выполнена, не возникнет ошибка или процесс не будет завершен (например, из-за срабатывания защитной реакции или решения пользователя).

Как внедрить использование компьютеров

Перед началом работы с инструментом «Использование компьютера» необходимо выполнить следующие настройки:

• Безопасная среда выполнения: В целях безопасности следует запускать агент использования компьютера в безопасной и контролируемой среде (например, в изолированной виртуальной машине, контейнере или в специальном профиле браузера с ограниченными правами доступа).
• Обработчик действий на стороне клиента: Вам потребуется реализовать логику на стороне клиента для выполнения действий, сгенерированных моделью, и создания снимков экрана среды после каждого действия.

В примерах этого раздела в качестве среды выполнения используется браузер, а в качестве обработчика действий на стороне клиента — Playwright . Для запуска этих примеров необходимо установить необходимые зависимости и инициализировать экземпляр браузера 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.
    

Пример кода для расширения функциональности под среду Android приведен в разделе «Использование пользовательских функций» .

1. Отправьте запрос модели.

Добавьте инструмент «Использование компьютера» в свой API-запрос и отправьте запрос модели, содержащей цель пользователя. Необходимо использовать одну из моделей, поддерживаемых инструментом «Использование компьютера», иначе вы получите ошибку:

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

Также по желанию можно добавить следующие параметры:

• Исключенные действия: Если в списке поддерживаемых действий пользовательского интерфейса есть действия, которые вы не хотите, чтобы модель выполняла, укажите эти действия как excluded_predefined_functions .
• Пользовательские функции: Помимо инструмента «Использование компьютера», вы можете добавить пользовательские функции.

Обратите внимание, что при отправке запроса указывать размер экрана не нужно; модель прогнозирует пиксельные координаты, масштабированные в соответствии с высотой и шириной экрана.

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)

Пример использования пользовательских функций см. в разделе «Использование пользовательских функций» .

2. Получите ответ модели.

Когда инструмент «Использование компьютера» включен, модель будет отвечать одним или несколькими FunctionCalls если определит, что для выполнения задачи необходимы действия пользовательского интерфейса. Инструмент «Использование компьютера» поддерживает параллельный вызов функций, то есть модель может возвращать несколько действий за один ход.

Вот пример ответа модели.

{
  "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. Выполните полученные действия.

Код вашего приложения должен анализировать ответ модели, выполнять действия и собирать результаты.

Приведенный ниже пример кода извлекает вызовы функций из ответа модели «Использование компьютера» и преобразует их в действия, которые можно выполнить с помощью Playwright. Модель выдает нормализованные координаты (0-999) независимо от размеров входного изображения, поэтому часть этапа преобразования заключается в конвертации этих нормализованных координат обратно в фактические значения пикселей.

Рекомендуемый размер экрана для использования с моделью «Компьютер» — (1440, 900). Модель будет работать с любым разрешением, хотя качество результатов может ухудшиться.

Обратите внимание, что этот пример включает реализацию только для 3 наиболее распространенных действий пользовательского интерфейса: open_web_browser , click_at и type_text_at . Для использования в производственной среде вам потребуется реализовать все остальные действия пользовательского интерфейса из списка поддерживаемых действий , если вы явно не добавите их в список 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

4. Зафиксируйте новое состояние окружающей среды.

После выполнения действий отправьте результат выполнения функции обратно в модель, чтобы она могла использовать эту информацию для генерации следующего действия. Если было выполнено несколько действий (параллельных вызовов), необходимо отправить FunctionResponse для каждого из них при последующем обращении пользователя.

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

Создайте цикл взаимодействия агентов.

Для обеспечения многошагового взаимодействия объедините четыре шага из раздела « Как реализовать использование компьютера» в цикл. Не забудьте правильно управлять историей диалога, добавляя как ответы модели, так и ответы вашей функции.

Для запуска этого примера кода вам необходимо:

• Установите необходимые зависимости Playwright .

• Определите вспомогательные функции из шагов (3) Выполните полученные действия и (4) Зафиксируйте новое состояние среды .

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

Использование пользовательских функций

При желании вы можете включить в свой запрос пользовательские функции, чтобы расширить функциональность модели. В приведенном ниже примере модель и инструмент «Использование компьютера» адаптированы для мобильных приложений путем включения пользовательских действий, таких как open_app , long_press_at и go_home , при этом исключаются действия, специфичные для браузера. Модель может интеллектуально вызывать эти пользовательские функции наряду со стандартными действиями пользовательского интерфейса для выполнения задач в средах, отличных от браузера.

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)

Поддерживаемые действия пользовательского интерфейса

Модель может запрашивать следующие действия пользовательского интерфейса посредством вызова FunctionCall . Ваш клиентский код должен реализовать логику выполнения этих действий. Примеры см. в эталонной реализации .

Безопасность и охрана

Подтвердите решение, принятое в целях безопасности.

В зависимости от выполняемого действия, ответ модели может также включать решение safety_decision от внутренней системы безопасности, которая проверяет предложенное моделью действие.

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

Если параметр safety_decision имеет require_confirmation , необходимо запросить подтверждение у конечного пользователя перед выполнением действия. В соответствии с условиями предоставления услуг , обход запросов на подтверждение от человека запрещен.

В этом примере кода пользователю запрашивается подтверждение перед выполнением действия. Если пользователь не подтвердит действие, цикл завершится. Если пользователь подтвердит действие, действие будет выполнено, и поле safety_acknowledgement будет помечено как 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 ...

Если пользователь подтвердит действие, необходимо включить подтверждение безопасности в ваш 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
                )
             )
           ]
         )
       )

Передовые методы обеспечения безопасности

Использование компьютера — это новый инструмент, который сопряжен с новыми рисками, о которых разработчикам следует помнить:

• Ненадежный контент и мошенничество: стремясь достичь цели пользователя, модель может полагаться на ненадежные источники информации и инструкции с экрана. Например, если цель пользователя — купить телефон Pixel, а модель сталкивается с мошенничеством типа «Получите Pixel бесплатно, пройдя опрос», есть некоторая вероятность, что модель пройдет опрос.
• Случайные непредусмотренные действия: модель может неправильно интерпретировать цель пользователя или содержимое веб-страницы, что приводит к выполнению некорректных действий, таких как нажатие не той кнопки или заполнение неправильной формы. Это может привести к сбоям в выполнении задач или утечке данных.
• Нарушения политики: Возможности API могут быть направлены, как преднамеренно, так и непреднамеренно, на действия, нарушающие политику Google ( Политика запрещенного использования Gen AI и Дополнительные условия обслуживания API Gemini) . Это включает действия, которые могут помешать целостности системы, поставить под угрозу безопасность, обойти меры безопасности, управлять медицинскими устройствами и т. д.

Для устранения этих рисков можно внедрить следующие меры безопасности и передовые методы:

1. Человек в цикле событий (HITL):

   • Реализуйте подтверждение пользователя: если в ответе службы безопасности указано require_confirmation , необходимо реализовать подтверждение пользователя перед выполнением. См. пример кода в разделе « Подтверждение решения службы безопасности» .

   • Добавьте пользовательские инструкции по обеспечению безопасности: помимо встроенных проверок подтверждения пользователем, разработчики могут дополнительно добавить пользовательскую системную инструкцию , которая обеспечивает соблюдение их собственных правил безопасности, либо блокируя определенные действия модели, либо требуя подтверждения пользователя перед тем, как модель предпримет определенные необратимые действия, сопряженные с высокими рисками. Вот пример пользовательской инструкции по обеспечению безопасности, которую вы можете включить при взаимодействии с моделью.

     Пример инструкций по технике безопасности

     Задайте собственные правила безопасности в качестве системной инструкции:

         ## **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. Безопасная среда выполнения: запускайте агент в безопасной, изолированной среде, чтобы ограничить его потенциальное влияние (например, в изолированной виртуальной машине (ВМ), контейнере (например, Docker) или в специальном профиле браузера с ограниченными правами доступа).

3. Очистка входных данных: Очистка всего пользовательского текста в подсказках для снижения риска непреднамеренных инструкций или внедрения подсказок. Это полезный уровень безопасности, но он не заменяет безопасную среду выполнения.

4. Ограничения на доступ к контенту: используйте ограничения и API для обеспечения безопасности контента , чтобы оценивать вводимые пользователем данные, ввод и вывод инструментов, реакцию агента на предмет соответствия требованиям, внедрение подсказок и обнаружение взлома системы.

5. Списки разрешенных и заблокированных сайтов: Внедрите механизмы фильтрации, чтобы контролировать, куда модель может переходить и что она может делать. Список заблокированных сайтов — хорошая отправная точка, а более строгий список разрешенных сайтов еще безопаснее.

6. Наблюдаемость и ведение журналов: Ведите подробные журналы для отладки, аудита и реагирования на инциденты. Ваш клиент должен регистрировать подсказки, снимки экрана, действия, предложенные моделью (вызов функции), реакции системы безопасности и все действия, в конечном итоге выполненные клиентом.

7. Управление средой: Обеспечьте согласованность графического интерфейса пользователя. Неожиданные всплывающие окна, уведомления или изменения в расположении элементов могут сбить с толку модель. По возможности начинайте каждую новую задачу с известного, чистого состояния.

Версии моделей

Что дальше?

• Поэкспериментируйте с использованием компьютера в демонстрационной среде Browserbase .
• Примеры кода можно найти в эталонной реализации .
• Узнайте о других инструментах Gemini API:
  • Вызов функции
  • Освоение основ поиска Google