תובנות מרכזיות

• לולאת צילום מסך-פעולה היא דפוס הליבה: הסקריפט שלכם מצלם מסך, שולח אותו ל-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 למיליון input/output tokens).
• בטיחות דורשת שהקוד שלכם יבצע את הפעולות: GPT-5.4 רק שולח פקודות פעולה -- האפליקציה שלכם מחליטה האם לבצע אותן, מה שהופך בדיקות בסביבת sandbox וסקירת פעולות לחיוניות לפני הרצה ללא פיקוח.
• שלוש דרישות קדם כדי להתחיל: Python 3.10+, מפתח API של 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 ומעלה מותקן במחשב שלכם
• מפתח API של OpenAI עם גישה ל-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 — ה-SDK הרשמי של OpenAI עבור Python לקריאה ל-API של GPT-5.4
• pyautogui — ספרייה חוצת-פלטפורמות לשליטה בעכבר ובמקלדת
• pillow — ספריית עיבוד תמונה לטיפול בצילומי מסך

לאחר מכן, הגדירו את מפתח ה-API שלכם כמשתנה סביבה:

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

אתם אמורים לראות את רזולוציית המסך שלכם מודפסת. אם אתם מקבלים שגיאות import, בדקו שוב שהפעלתם את הסביבה הווירטואלית והתקנתם את כל החבילות.

---

שלב 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 — שולט בכמות ה-reasoning ש-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 יבין איך לפתוח את המחשבון ולבצע את הכפל — לחיצה על כפתורים, קריאת התוצאה ועצירה בסיום.

---

דוגמה מעשית 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.")

הגדירו מגבלות קצב. הוסיפו מספר מקסימלי של פעולות לסשן ותקציב עלות מקסימלי. הפרמטר 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 עלול שלא להצליח לפרש את צילום המסך נכון.

"לחיצות נוחתות במיקום הלא נכון" -- זה קורה בדרך כלל בתצוגות עם scaling (למשל, תצוגות Retina ב-macOS). PyAutoGUI עובד בקואורדינטות פיקסלים, אך התצוגה שלכם עשויה להשתמש בקואורדינטות לוגיות. נסו ללכוד את הרזולוציה שלכם בעזרת pyautogui.size() והשוו אותה לרזולוציית הפיקסלים הממשית שלכם. ב-macOS עם Retina, ייתכן שתצטרכו לחלק את הקואורדינטות בפקטור ה-scaling שלכם.

"PyAutoGUI לא מצליח למצוא את התצוגה" -- בשרתי Linux ללא תצוגה, התקינו והפעילו את Xvfb: Xvfb :99 -screen 0 1920x1080x24 & ולאחר מכן export DISPLAY=:99. ב-macOS, עליכם להעניק ל-Terminal (או ל-IDE שלכם) הרשאות נגישות (accessibility) ב-System Settings > Privacy & Security > Accessibility.

"ה-API מחזיר שגיאת rate limit 429" -- הוסיפו time.sleep(2) בין קריאות ה-API, או הטמיעו מנגנון exponential backoff. סשנים של Computer Use ב-GPT-5.4 יכולים להגיע למגבלות קצב אם שולחים צילומי מסך במהירות רבה מדי.

"עלויות tokens גבוהות" -- צילומי מסך ברזולוציה מלאה צורכים tokens רבים. הפחיתו עלויות על ידי שינוי גודל (resizing) של צילומי המסך לפני הקידוד שלהם:

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 עבור אוטומציית דפדפן.

בניית ספריית משימות. שמרו prompt-ים ותהליכי עבודה נפוצים כפונקציות לשימוש חוזר. צרו ספריית tasks/ עם סקריפטים כמו fill_invoice.py, export_report.py, ו-update_crm.py שהצוות שלכם יוכל להריץ לפי דרישה.

תזמון אוטומציות. השתמשו ב-cron (Linux/macOS) או ב-Task Scheduler (Windows) כדי להריץ את סקריפטי האוטומציה שלכם בזמנים קבועים. שלבו עם תצוגה וירטואלית להפעלה מלאה ללא תצוגה.

ה-Computer Use של GPT-5.4 הוא עדיין יכולת חדשה, וממשק ה-API ימשיך להתפתח. השאירו את חבילת ה-openai שלכם מעודכנת בעזרת pip install --upgrade openai כדי לקבל את סוגי הכלים והפרמטרים העדכניים ביותר ככל ש-OpenAI משכללת את התכונה.

הקוד במדריך זה נותן לכם בסיס עובד. התחילו עם משימות פשוטות בסיכון נמוך, ודאו שהאוטומציה עובדת כראוי, ולאחר מכן עברו לתהליכי עבודה מורכבים יותר ככל שתבנו ביטחון במערכת.