Основные выводы

• Цикл «скриншот-действие» — это основной паттерн: Ваш скрипт делает скриншот, отправляет его в GPT-5.4 через Responses API с включенным computer_use, получает структурированные команды действий (click, type, scroll) и выполняет их с помощью PyAutoGUI в цикле.
• GPT-5.4 превзошел экспертов-людей в OSWorld на 75%: Это первая модель AI, превзошедшая человеческие показатели в бенчмарках автоматизации рабочего стола, что делает практическую автоматизацию жизнеспособной для реальных рабочих процессов.
• Стоимость на удивление низкая: Типичная сессия автоматизации с 10-20 скриншотами стоит $0.10-0.50, тарифицируясь по стандартным ставкам GPT-5.4 (~$10/$30 за миллион входных/выходных tokens).
• Безопасность требует, чтобы ваш код выполнял действия: GPT-5.4 только отправляет команды действий — ваше приложение решает, выполнять ли их, что делает тестирование в sandboxed среде и проверку действий необходимыми перед запуском без присмотра.
• Три предварительных условия для начала работы: Python 3.10+, API key OpenAI с доступом Tier 1 (минимум $5 предыдущих расходов) и десктопная среда с дисплеем.

GPT-5.4 набрал 75% в бенчмарке OSWorld, впервые превзойдя экспертов-людей в автоматизации рабочего стола. Но знание результатов бенчмарков и реальное использование Computer Use — это две разные вещи.

Это руководство устраняет этот разрыв. К концу вы получите работающий Python скрипт, который делает скриншоты вашего рабочего стола, отправляет их в GPT-5.4, получает структурированные команды действий и выполняет их автоматически. Никакой теории, никакого хайпа — только код, который вы можете запустить сегодня.

---

Что вы создадите

Вы создадите полный цикл автоматизации рабочего стола, который работает следующим образом:

1. Ваш скрипт делает скриншот вашего экрана
2. Он отправляет этот скриншот в GPT-5.4 через OpenAI Responses API с включенным инструментом computer_use
3. GPT-5.4 анализирует скриншот и возвращает структурированные действия (click, type, scroll, keypress)
4. Ваш скрипт выполняет эти действия с помощью PyAutoGUI
5. Цикл повторяется до завершения задачи

К концу этого туториала у вас будет два рабочих примера: один для автоматического заполнения веб-формы, и другой для извлечения данных из десктопного приложения в CSV файл.

---

Предварительные условия

Перед началом убедитесь, что у вас есть следующее:

• Python 3.10 или новее, установленный на вашем компьютере
• OpenAI API key с доступом к GPT-5.4 (требуется платный аккаунт с доступом как минимум Tier 1 — минимум $5 предыдущих расходов)
• Десктопная среда — Computer Use работает на macOS, Windows и Linux с дисплеем. Для headless серверов вам понадобится виртуальный дисплей, такой как Xvfb
• Базовое знакомство с Python (вам не нужно быть экспертом — весь код предоставлен)

---

Шаг 1: Настройка среды

Начните с создания директории проекта и установки необходимых пакетов.

mkdir gpt54-computer-use && cd gpt54-computer-use
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

pip install openai pyautogui pillow

Что делает каждый пакет:

• openai — официальный OpenAI Python SDK для вызова GPT-5.4 API
• pyautogui — кроссплатформенная библиотека для управления мышью и клавиатурой
• pillow — библиотека обработки изображений для работы со скриншотами

Затем установите ваш API key как переменную окружения:

export OPENAI_API_KEY="sk-your-api-key-here"

На Windows используйте set OPENAI_API_KEY=sk-your-api-key-here.

Создайте файл с названием automation.py и добавьте базовую настройку:

import os
import base64
import json
import pyautogui
from openai import OpenAI

client = OpenAI()  # Reads OPENAI_API_KEY from environment

# Safety: add a short pause before actions so you can move the mouse
# to a corner to trigger PyAutoGUI's fail-safe and abort
pyautogui.PAUSE = 0.5
pyautogui.FAILSAFE = True

SCREEN_WIDTH, SCREEN_HEIGHT = pyautogui.size()
print(f"Screen resolution: {SCREEN_WIDTH}x{SCREEN_HEIGHT}")

Запустите это, чтобы убедиться, что все установлено правильно:

python automation.py

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

---

Шаг 2: Создание скриншота

Computer Use работает путем анализа скриншотов. Ваш код захватывает экран и преобразует его в строку в кодировке base64, которую может принять API.

Добавьте эту функцию в automation.py:

def take_screenshot():
    """Capture the screen and return it as a base64-encoded PNG string."""
    screenshot = pyautogui.screenshot()
    # Save to a buffer instead of disk for speed
    import io
    buffer = io.BytesIO()
    screenshot.save(buffer, format="PNG")
    buffer.seek(0)
    return base64.b64encode(buffer.read()).decode("utf-8")

Протестируйте её, добавив быструю проверку в конец файла:

if __name__ == "__main__":
    img_data = take_screenshot()
    print(f"Screenshot captured: {len(img_data)} characters (base64)")

Это должно вывести что-то вроде Screenshot captured: 2847392 characters (base64). Точное число зависит от разрешения вашего экрана и того, что на нем отображено.

---

Шаг 3: Отправка скриншота в GPT-5.4

Теперь переходим к основе Computer Use: отправке скриншота в GPT-5.4 с включенным инструментом computer_use и получению в ответ структурированных команд действий.

Добавьте эту функцию:

def send_to_gpt54(screenshot_b64, task_description, previous_response_id=None):
    """
    Send a screenshot to GPT-5.4 with computer_use enabled.
    Returns the API response with action commands.
    """
    tools = [
        {
            "type": "computer_use_preview",
            "display_width": SCREEN_WIDTH,
            "display_height": SCREEN_HEIGHT,
            "environment": "mac"  # Change to "windows" or "linux" as needed
        }
    ]

    input_content = [
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": task_description
                },
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{screenshot_b64}"
                    }
                }
            ]
        }
    ]

    params = {
        "model": "gpt-5.4",
        "tools": tools,
        "input": input_content,
        "reasoning": {"effort": "medium"}
    }

    if previous_response_id:
        params["previous_response_id"] = previous_response_id

    response = client.responses.create(**params)
    return response

Объяснение ключевых параметров:

• computer_use_preview — указывает GPT-5.4 анализировать скриншот и возвращать действия на рабочем столе
• display_width / display_height — разрешение вашего экрана, чтобы GPT-5.4 возвращал координаты, соответствующие вашему фактическому дисплею
• environment — установите значение "mac", "windows" или "linux", чтобы GPT-5.4 использовал правильные сочетания клавиш и конвенции UI
• reasoning.effort — контролирует, насколько глубоко GPT-5.4 проводит рассуждения. Используйте "medium" для стандартных задач, "high" для сложных многошаговых процессов
• previous_response_id — связывает несколько вызовов вместе, чтобы GPT-5.4 помнил, что он уже сделал

---

Шаг 4: Выполнение действий

GPT-5.4 возвращает структурированные команды действий в своем ответе. Вам нужно распарсить их и выполнить с помощью PyAutoGUI.

Добавьте исполнитель действий:

def execute_action(action):
    """Execute a single computer_use action using PyAutoGUI."""
    action_type = action.type

    if action_type == "click":
        x, y = action.x, action.y
        button = getattr(action, "button", "left")
        print(f"  -> Click ({button}) at ({x}, {y})")
        pyautogui.click(x, y, button=button)

    elif action_type == "double_click":
        x, y = action.x, action.y
        print(f"  -> Double-click at ({x}, {y})")
        pyautogui.doubleClick(x, y)

    elif action_type == "type":
        text = action.text
        print(f"  -> Type: {text[:50]}{'...' if len(text) > 50 else ''}")
        pyautogui.write(text, interval=0.03)

    elif action_type == "keypress":
        keys = action.keys
        print(f"  -> Keypress: {keys}")
        for key in keys:
            pyautogui.press(key)

    elif action_type == "scroll":
        x, y = action.x, action.y
        scroll_x = getattr(action, "scroll_x", 0)
        scroll_y = getattr(action, "scroll_y", 0)
        print(f"  -> Scroll at ({x}, {y}): x={scroll_x}, y={scroll_y}")
        pyautogui.scroll(scroll_y, x=x, y=y)

    elif action_type == "drag":
        start_x, start_y = action.start_x, action.start_y
        end_x, end_y = action.end_x, action.end_y
        print(f"  -> Drag from ({start_x}, {start_y}) to ({end_x}, {end_y})")
        pyautogui.moveTo(start_x, start_y)
        pyautogui.drag(end_x - start_x, end_y - start_y, duration=0.5)

    elif action_type == "screenshot":
        print("  -> Model requested a new screenshot")
        return "screenshot_requested"

    else:
        print(f"  -> Unknown action type: {action_type}")

    return "executed"


def process_response(response):
    """Parse GPT-5.4's response and execute all actions."""
    needs_screenshot = False

    for item in response.output:
        if item.type == "computer_call":
            action = item.action
            result = execute_action(action)
            if result == "screenshot_requested":
                needs_screenshot = True
        elif item.type == "text":
            print(f"  GPT-5.4 says: {item.text}")

    return needs_screenshot, response.id

Это обрабатывает все типы действий, которые может возвращать GPT-5.4: клики, двойные клики, ввод текста, нажатия клавиш, прокрутку и перетаскивание.

---

Шаг 5: Создание цикла автоматизации

Теперь свяжите все вместе в полный цикл автоматизации. Это основной движок, который выполняет ваши задачи:

import time

def run_automation(task_description, max_steps=25):
    """
    Run a complete automation loop:
    screenshot -> send to GPT-5.4 -> execute actions -> repeat.
    """
    print(f"Starting automation: {task_description}")
    print(f"Max steps: {max_steps}")
    print("-" * 60)

    previous_response_id = None

    for step in range(1, max_steps + 1):
        print(f"\nStep {step}/{max_steps}")

        # 1. Take a screenshot
        print("  Capturing screenshot...")
        screenshot_b64 = take_screenshot()

        # 2. Send to GPT-5.4
        print("  Sending to GPT-5.4...")
        response = send_to_gpt54(
            screenshot_b64,
            task_description if step == 1 else "Continue the task based on the current screen state.",
            previous_response_id
        )

        # 3. Check if the model thinks we're done
        has_actions = False
        for item in response.output:
            if item.type == "computer_call":
                has_actions = True
                break

        if not has_actions:
            # Check if model sent a text response (likely done or needs input)
            for item in response.output:
                if item.type == "text":
                    print(f"\n  GPT-5.4: {item.text}")
            print("\n" + "=" * 60)
            print("Automation complete (no more actions to perform).")
            return True

        # 4. Execute the actions
        print("  Executing actions...")
        needs_screenshot, previous_response_id = process_response(response)

        # 5. Brief pause to let UI update
        time.sleep(1.0)

    print("\n" + "=" * 60)
    print(f"Reached maximum steps ({max_steps}). Stopping.")
    return False

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

if __name__ == "__main__":
    run_automation("Open the Calculator app and compute 1234 * 5678")

Это захватит ваш экран, отправит его в GPT-5.4, и GPT-5.4 поймет, как открыть Calculator и выполнить умножение — нажимая кнопки, считывая результат и останавливаясь по завершении.

---

Практический пример 1: Автозаполнение веб-формы

Вот полный рабочий пример, который заполняет контактную форму на сайте. Сохраните это как autofill_form.py:

import os
import base64
import io
import time
import pyautogui
from openai import OpenAI

client = OpenAI()
pyautogui.PAUSE = 0.5
pyautogui.FAILSAFE = True
SCREEN_WIDTH, SCREEN_HEIGHT = pyautogui.size()


def take_screenshot():
    screenshot = pyautogui.screenshot()
    buffer = io.BytesIO()
    screenshot.save(buffer, format="PNG")
    buffer.seek(0)
    return base64.b64encode(buffer.read()).decode("utf-8")


def autofill_contact_form():
    """
    Auto-fill a contact form with sample data.
    Open the web page with the form before running this script.
    """
    form_data = {
        "First Name": "Jane",
        "Last Name": "Doe",
        "Email": "jane.doe@example.com",
        "Phone": "555-0123",
        "Company": "Acme Corp",
        "Message": "I am interested in learning more about your enterprise plan."
    }

    task = f"""Fill out the contact form visible on the screen with this data:
{chr(10).join(f'- {k}: {v}' for k, v in form_data.items())}

Click each field, clear any existing text, type the value, then move to the next field.
After filling all fields, click the Submit button.
Do NOT press Enter to submit — click the Submit button instead."""

    print("Starting form auto-fill...")
    print(f"Data to fill: {json.dumps(form_data, indent=2)}")

    previous_response_id = None

    for step in range(1, 20):
        print(f"\nStep {step}")
        screenshot_b64 = take_screenshot()

        tools = [{
            "type": "computer_use_preview",
            "display_width": SCREEN_WIDTH,
            "display_height": SCREEN_HEIGHT,
            "environment": "mac"
        }]

        input_content = [{
            "role": "user",
            "content": [
                {"type": "text", "text": task if step == 1 else "Continue filling the form."},
                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{screenshot_b64}"}}
            ]
        }]

        params = {
            "model": "gpt-5.4",
            "tools": tools,
            "input": input_content,
            "reasoning": {"effort": "medium"}
        }
        if previous_response_id:
            params["previous_response_id"] = previous_response_id

        response = client.responses.create(**params)

        has_actions = False
        for item in response.output:
            if item.type == "computer_call":
                has_actions = True
                action = item.action
                if action.type == "click":
                    pyautogui.click(action.x, action.y)
                elif action.type == "type":
                    pyautogui.write(action.text, interval=0.03)
                elif action.type == "keypress":
                    for key in action.keys:
                        pyautogui.press(key)
                elif action.type == "scroll":
                    pyautogui.scroll(action.scroll_y, x=action.x, y=action.y)

        if not has_actions:
            for item in response.output:
                if item.type == "text":
                    print(f"GPT-5.4: {item.text}")
            print("Form filling complete.")
            return

        previous_response_id = response.id
        time.sleep(0.8)


if __name__ == "__main__":
    import json
    print("Make sure the web form is visible on your screen.")
    print("Starting in 3 seconds...")
    time.sleep(3)
    autofill_contact_form()

Как использовать:

1. Откройте веб-страницу с контактной формой в вашем браузере
2. Убедитесь, что форма полностью видна на экране (не требуется прокрутка для первых полей)
3. Запустите python autofill_form.py
4. Наблюдайте, как GPT-5.4 идентифицирует каждое поле, кликает по нему и вводит правильное значение

---

Практический пример 2: Извлечение данных из десктопного приложения

Этот пример считывает данные из видимой электронной таблицы или табличного приложения и сохраняет их в CSV файл. Сохраните это как extract_data.py:

import os
import base64
import io
import csv
import time
import pyautogui
from openai import OpenAI

client = OpenAI()
pyautogui.PAUSE = 0.3
pyautogui.FAILSAFE = True
SCREEN_WIDTH, SCREEN_HEIGHT = pyautogui.size()


def take_screenshot():
    screenshot = pyautogui.screenshot()
    buffer = io.BytesIO()
    screenshot.save(buffer, format="PNG")
    buffer.seek(0)
    return base64.b64encode(buffer.read()).decode("utf-8")


def extract_table_data(output_file="extracted_data.csv"):
    """
    Look at the current screen, identify any table or spreadsheet,
    and extract its contents to a CSV file.
    """
    screenshot_b64 = take_screenshot()

    response = client.responses.create(
        model="gpt-5.4",
        input=[{
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": """Look at this screenshot carefully. There is a table or spreadsheet visible.
Extract ALL the data from the visible table into a structured JSON format.
Return ONLY a JSON object with this structure:
{
  "headers": ["Column1", "Column2", ...],
  "rows": [["value1", "value2", ...], ...]
}
Include every visible row. Do not summarize or skip any data."""
                },
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/png;base64,{screenshot_b64}"}
                }
            ]
        }],
        reasoning={"effort": "high"}
    )

    # Parse the JSON response
    response_text = response.output_text
    # Clean up markdown code fences if present
    if "```json" in response_text:
        response_text = response_text.split("```json")[1].split("```")[0]
    elif "```" in response_text:
        response_text = response_text.split("```")[1].split("```")[0]

    import json
    data = json.loads(response_text.strip())

    # Write to CSV
    with open(output_file, "w", newline="") as f:
        writer = csv.writer(f)
        writer.writerow(data["headers"])
        writer.writerows(data["rows"])

    row_count = len(data["rows"])
    col_count = len(data["headers"])
    print(f"Extracted {row_count} rows x {col_count} columns to {output_file}")
    return output_file


def extract_multi_page_data(output_file="full_data.csv", max_pages=10):
    """
    Extract data from a table that spans multiple pages.
    Scrolls down and extracts each page, then combines results.
    """
    all_rows = []
    headers = None

    for page in range(max_pages):
        print(f"Extracting page {page + 1}...")
        screenshot_b64 = take_screenshot()

        prompt = "Extract ALL table data visible on screen as JSON: {\"headers\": [...], \"rows\": [[...], ...]}"
        if page > 0:
            prompt += " Do NOT include the header row if it is repeated from the previous page."

        response = client.responses.create(
            model="gpt-5.4",
            input=[{
                "role": "user",
                "content": [
                    {"type": "text", "text": prompt},
                    {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{screenshot_b64}"}}
                ]
            }],
            reasoning={"effort": "high"}
        )

        response_text = response.output_text
        if "```json" in response_text:
            response_text = response_text.split("```json")[1].split("```")[0]
        elif "```" in response_text:
            response_text = response_text.split("```")[1].split("```")[0]

        import json
        data = json.loads(response_text.strip())

        if headers is None:
            headers = data["headers"]

        if not data["rows"]:
            print("No more data found. Stopping.")
            break

        all_rows.extend(data["rows"])
        print(f"  Found {len(data['rows'])} rows (total: {len(all_rows)})")

        # Scroll down for next page
        pyautogui.scroll(-5)
        time.sleep(1.0)

    # Write combined CSV
    with open(output_file, "w", newline="") as f:
        writer = csv.writer(f)
        writer.writerow(headers)
        writer.writerows(all_rows)

    print(f"\nDone. Extracted {len(all_rows)} total rows to {output_file}")
    return output_file


if __name__ == "__main__":
    print("Make sure a spreadsheet or table is visible on your screen.")
    print("Starting extraction in 3 seconds...")
    time.sleep(3)
    extract_table_data()

Как использовать:

1. Откройте электронную таблицу, просмотрщик баз данных или любое приложение с табличными данными на экране
2. Запустите python extract_data.py
3. Проверьте сгенерированный файл extracted_data.csv на наличие извлеченного содержимого

Для таблиц, занимающих несколько страниц, вызовите extract_multi_page_data(). Она будет автоматически прокручивать экран и объединять все страницы в один CSV.

---

Лучшие практики безопасности

Computer Use дает GPT-5.4 возможность управлять вашей мышью и клавиатурой. Такая власть требует осторожности.

Всегда используйте sandbox. Перед запуском любой автоматизации на вашем реальном рабочем столе протестируйте её в виртуальной машине или Docker контейнере с виртуальным дисплеем. Это изолирует ошибки и предотвратит случайный ущерб.

Проверяйте действия перед выполнением. Измените функцию execute_action, чтобы она выводила каждое действие и ждала вашего подтверждения перед выполнением:

def execute_action_safe(action):
    """Execute action only after user confirmation."""
    print(f"  Proposed action: {action.type}", end="")
    if hasattr(action, "x"):
        print(f" at ({action.x}, {action.y})", end="")
    if hasattr(action, "text"):
        print(f" text='{action.text[:30]}'", end="")
    print()

    confirm = input("  Execute? (y/n): ").strip().lower()
    if confirm == "y":
        execute_action(action)
    else:
        print("  Skipped.")

Установите лимиты (rate limits). Добавьте максимальное количество действий на сессию и бюджет расходов. Параметр max_steps в run_automation уже ограничивает количество циклов. Вы также можете отслеживать использование tokens из объекта ответа для мониторинга затрат.

Никогда не автоматизируйте конфиденциальные аккаунты без присмотра. Не направляйте Computer Use на банковские приложения, почту с конфиденциальными данными или панели администратора, не наблюдая за каждым действием. GPT-5.4 может промахнуться при клике, неверно прочитать элементы UI или пойти по непредусмотренному пути.

Используйте fail-safe в PyAutoGUI. С pyautogui.FAILSAFE = True (что установлено по умолчанию) вы можете прервать любую автоматизацию, быстро переместив мышь в верхний левый угол экрана. Держите это включенным постоянно.

---

Устранение распространенных проблем

«Модель не возвращает никаких действий» — Убедитесь, что вы используете computer_use_preview в качестве типа инструмента, а не просто computer_use. Также убедитесь, что ваши display_width и display_height соответствуют фактическому разрешению экрана. Если значения неверны, GPT-5.4 может быть не в состоянии правильно интерпретировать скриншот.

«Клики попадают не в те позиции» — Обычно это происходит на дисплеях с масштабированием (например, дисплеи Retina на macOS). PyAutoGUI работает в пиксельных координатах, но ваш дисплей может использовать логические координаты. Попробуйте получить разрешение с помощью pyautogui.size() и сравните его с фактическим пиксельным разрешением. На macOS с Retina вам может потребоваться разделить координаты на коэффициент масштабирования.

«PyAutoGUI не может найти дисплей» — На headless серверах Linux установите и запустите Xvfb: Xvfb :99 -screen 0 1920x1080x24 &, затем export DISPLAY=:99. На macOS вы должны предоставить Terminal (или вашей IDE) права доступа в System Settings > Privacy & Security > Accessibility.

«API возвращает ошибку 429 rate limit» — Добавьте time.sleep(2) между вызовами API или реализуйте экспоненциальную задержку. Сессии Computer Use в GPT-5.4 могут достигать лимитов, если вы отправляете скриншоты слишком быстро.

«Высокая стоимость tokens» — Скриншоты в полном разрешении потребляют много tokens. Снизьте затраты, изменяя размер скриншотов перед их кодированием:

def take_screenshot_resized(max_width=1280):
    screenshot = pyautogui.screenshot()
    ratio = max_width / screenshot.width
    new_size = (max_width, int(screenshot.height * ratio))
    screenshot = screenshot.resize(new_size)
    buffer = io.BytesIO()
    screenshot.save(buffer, format="PNG")
    buffer.seek(0)
    return base64.b64encode(buffer.read()).decode("utf-8"), ratio

При использовании скриншотов с измененным размером не забудьте умножить координаты, возвращаемые GPT-5.4, на обратный коэффициент ratio перед передачей их в PyAutoGUI.

«GPT-5.4 зацикливается» — Если модель постоянно повторяет одно и то же действие, она может быть сбита с толку состоянием UI. Добавьте логику для обнаружения повторяющихся действий и прерывания цикла, или увеличьте reasoning effort до "high" для принятия лучших решений.

---

Что дальше

Как только вы наладите работу базового цикла автоматизации, вот способы его расширения:

Связывание нескольких задач. Создайте рабочий процесс, который открывает вашу почту, скачивает вложение, открывает его в электронной таблице, извлекает определенные ячейки и вставляет значения в шаблон отчета. Каждый шаг использует тот же цикл «скриншот-анализ-действие».

Добавление восстановления после ошибок. Проверяйте каждый скриншот на наличие диалоговых окон с ошибками или неожиданных состояний. Если GPT-5.4 обнаружит, что что-то пошло не так, он может попытаться восстановиться, нажав «Cancel», нажав Escape или повторив последнее действие.

Комбинирование с Playwright для браузерных задач. Для автоматизации только в вебе GPT-5.4 также может писать код Playwright для программного взаимодействия с браузерами. Это быстрее и надежнее, чем клики по скриншотам для структурированных веб-страниц. Используйте Computer Use для десктопных приложений и Playwright для автоматизации браузера.

Создание библиотеки задач. Сохраняйте часто используемые промпты и рабочие процессы как повторно используемые функции. Создайте директорию tasks/ со скриптами вроде fill_invoice.py, export_report.py и update_crm.py, которые ваша команда сможет запускать по запросу.

Планирование автоматизаций. Используйте cron (Linux/macOS) или Task Scheduler (Windows) для запуска ваших скриптов автоматизации в установленное время. Сочетайте это с виртуальным дисплеем для полностью headless работы.

GPT-5.4 Computer Use — это все еще новая возможность, и API будет развиваться. Обновляйте ваш пакет openai с помощью pip install --upgrade openai, чтобы получать последние типы инструментов и параметры по мере того, как OpenAI совершенствует функцию.

Код в этом туториале дает вам рабочую основу. Начните с простых задач с низким уровнем риска, убедитесь, что автоматизация работает правильно, а затем переходите к более сложным рабочим процессам по мере обретения уверенности в системе.