Eerste workflow: navigeren en interactie
Op deze pagina
Les herschreven op 3 november 2026 op basis van de gids Computer use van OpenAI en de Computer use integration recipes: de agent gebruikt het
computer-gereedschap van de Responses API, een actiehandler gemodelleerd naar de documentatie (gegropeerde acties,keypress,scroll_x/scroll_y,drag-paden), en ketening viaprevious_response_id, ter vervanging van code geschreven voor de API van Anthropic. Bronnen: Computer use · Integration recipes.
De onderdelen samenvoegen
U heeft de lus voor ogen en de omgeving geconfigureerd. Nu moet u ze samenvoegen tot een werkend programma: een agent die een online encyclopedie opent, zoekt naar een term, het eerste resultaat opent en rapporteert welke titel de bereikte pagina heeft. Het scenario lijkt bescheiden, maar het omvat de fundamentele gebaren—navigeren, typen, klikken, informatie lezen—en alles wat u hierna bouwt, is slechts een langere variant hiervan.
De actiehandler
Het model neemt beslissingen, maar voert niets zelf uit: het retourneert een lijst met acties, en uw code vertaalt deze op volgorde naar Playwright-gebaren. Deze functie volgt de handler die door OpenAI is gepubliceerd in zijn integratierecepten, vereenvoudigd voor een browser.
import time
KEYS = {
"ENTER": "Enter", "RETURN": "Enter", "ESC": "Escape", "ESCAPE": "Escape",
"TAB": "Tab", "SPACE": "Space", "BACKSPACE": "Backspace", "DELETE": "Delete",
"UP": "ArrowUp", "DOWN": "ArrowDown", "LEFT": "ArrowLeft", "RIGHT": "ArrowRight",
"CTRL": "Control", "CONTROL": "Control", "SHIFT": "Shift", "ALT": "Alt",
"CMD": "Meta", "META": "Meta",
}
BUTTONS = {"left": "left", "right": "right", "wheel": "middle"}
def execute_actions(page, actions):
"""Executes the actions from a computer_call in order."""
for action in actions:
if action.type in ("click", "double_click", "drag", "move", "scroll") and getattr(action, "keys", None):
raise ValueError("Mouse action with modifier key: not handled here")
match action.type:
case "click":
button = getattr(action, "button", "left")
if button not in BUTTONS: # back and forward don't exist in Playwright
raise ValueError(f"Unsupported button: {button}")
page.mouse.click(action.x, action.y, button=BUTTONS[button])
case "double_click":
page.mouse.dblclick(action.x, action.y)
case "drag":
points = [(p.x, p.y) for p in action.path]
page.mouse.move(*points[0])
page.mouse.down()
for x, y in points[1:]:
page.mouse.move(x, y)
page.mouse.up()
case "move":
page.mouse.move(action.x, action.y)
case "scroll":
page.mouse.move(action.x, action.y)
page.mouse.wheel(action.scroll_x, action.scroll_y)
case "keypress":
page.keyboard.press("+".join(KEYS.get(k, k) for k in action.keys))
case "type":
page.keyboard.type(action.text)
case "wait":
time.sleep(2)
case "screenshot":
continue # screenshot is taken after each batch of actions
case _:
raise ValueError(f"Unsupported action: {action.type}")
Twee keuzes verdienen uitleg. De namen van toetsen en knoppen die door het model worden geretourneerd (ENTER, CTRL, wheel…) komen niet overeen met wat Playwright verwacht (Enter, Control, middle…): de mapping-tabellen, overgenomen uit de documentatie, overbruggen deze kloof, en de knoppen back en forward, die de API ook kan aanvragen, worden geweigerd zoals in de handler van OpenAI. En een onbekende actie leidt tot een fout in plaats van stilzwijgend te worden genegeerd: een harde stop is beter dan een agent die denkt gehandeld te hebben terwijl dat niet zo is.
De volledige lus
De agent orkestreert vervolgens de cyclus. De eerste oproep verzendt de taak; als deze alleen een verzoek om een screenshot bevat, retourneert u eenvoudig het scherm. Elke screenshot komt terug bij het model als resultaat van de oproep die erom vroeg, gerefereerd via zijn call_id, en previous_response_id koppelt de beurten aan elkaar.
import base64
from openai import OpenAI
from playwright.sync_api import sync_playwright
client = OpenAI()
MODEL = "gpt-6.1-sol"
MAX_TURNS = 15
def launch_agent(task: str, start_url: str = "https://en.wikipedia.org"):
"""Launches a Computer Use agent on a given task."""
pw = sync_playwright().start()
browser = pw.chromium.launch(headless=False) # False to observe
page = browser.new_page(viewport={"width": 1280, "height": 720})
page.goto(start_url)
page.wait_for_load_state("networkidle")
try:
response = client.responses.create(
model=MODEL, tools=[{"type": "computer"}], input=task,
)
for turn in range(MAX_TURNS):
call = next((i for i in response.output if i.type == "computer_call"), None)
if call is None:
print(f"Task complete: {response.output_text}")
return response.output_text
if call.pending_safety_checks: # see lesson 12
raise RuntimeError("Pending safety checks: human intervention required")
for action in call.actions:
print(f" Action: {action.type}")
execute_actions(page, call.actions)
screenshot = base64.b64encode(page.screenshot()).decode("utf-8")
response = client.responses.create(
model=MODEL,
tools=[{"type": "computer"}],
previous_response_id=response.id,
input=[{
"type": "computer_call_output",
"call_id": call.call_id,
"output": {
"type": "computer_screenshot",
"image_url": f"data:image/png;base64,{screenshot}",
"detail": "original",
},
}],
)
raise RuntimeError("Maximum number of turns reached: check the page state")
finally:
browser.close()
pw.stop()
Drie veiligheidsmaatregelen zijn al ingesteld. MAX_TURNS begrenst de lus: zonder deze limiet zou een gedesoriënteerde agent uw budget tot uitputting verbruiken. Een oproep met openstaande veiligheidscontroles (pending_safety_checks) stopt alles, zoals in het officiële voorbeeld van OpenAI: les 12 laat zien hoe u deze door een mens laat valideren. En normale voltooiing wordt aangegeven door de afwezigheid van een computer_call: het model is gestopt met handelen en antwoordt u, waarna u de paginatitel ophaalt uit output_text.
De workflow starten
if __name__ == "__main__":
launch_agent(
"Search for 'Computer Use' in Wikipedia's search engine, "
"open the first result, and give me the title of the page. "
"Use the computer tool to act on the interface."
)
Met headless=False is de show instructief: het venster opent, de klik landt in het zoekveld, de tekst verschijnt, de eerste link opent en de titel komt terug in uw console. Laat het twee of drie keer draaien voordat u doorgaat naar ambitieuzere taken; u ziet precies waar de agent aarzelt en wat uw instructies moeten adresseren.
Een herbruikbare functie voor de rest van de cursus
De volgende lessen werken op een reeds geopende pagina—na een inlogprocedure, midden in een workflow. Ze vertrouwen op run_agent(task, page=page): dezelfde lus, geëxtraheerd uit launch_agent, met optionele instructions die bij elke beurt worden geretourneerd (les 5 legt uit waarom).
def run_agent(task: str, page, instructions: str | None = None, max_turns: int = MAX_TURNS) -> str:
"""Computer Use loop on an already-open page; returns the final message."""
request = {"model": MODEL, "tools": [{"type": "computer"}]}
if instructions:
request["instructions"] = instructions # to be returned on each request
response = client.responses.create(**request, input=task)
for turn in range(max_turns):
call = next((i for i in response.output if i.type == "computer_call"), None)
if call is None:
return response.output_text
if call.pending_safety_checks:
raise RuntimeError("Pending safety checks: human intervention required")
execute_actions(page, call.actions)
screenshot = base64.b64encode(page.screenshot()).decode("utf-8")
response = client.responses.create(
**request,
previous_response_id=response.id,
input=[{
"type": "computer_call_output",
"call_id": call.call_id,
"output": {
"type": "computer_screenshot",
"image_url": f"data:image/png;base64,{screenshot}",
"detail": "original",
},
}],
)
raise RuntimeError("Maximum number of turns reached: check the page state")
Drie fouten die u zult tegenkomen
Klikt de agent systematisch naast zijn doelwit? De boosdoener is bijna altijd een schaalverschil tussen de verzonden screenshot en de pagina waarop u klikt: formaatgewijzigde screenshot, browserzoom, scherm met hoge dichtheid. De coördinaten van het model verwijzen naar de afbeelding die het heeft ontvangen; als u deze verkleint, converteert u de coördinaten in de tegenovergestelde richting.
Gaat de agent in cirkels en herhaalt hij hetzelfde gebaar? De turn-limiet zal hem uiteindelijk stoppen, maar het is beter de lus eerder te detecteren: als dezelfde screenshot meerdere keren achter elkaar terugkomt, boekt de agent geen vooruitgang, en het onderbreken ervan bespaart u onnodige oproepen.
Handelt de agent op een pagina die nog leeg is? Op een zware site keert page.goto() terug voordat het renderen is voltooid, en toont de eerste screenshot alleen een witte achtergrond. Wacht op netwerkinactiviteit voordat u de foto maakt:
page.goto(url)
page.wait_for_load_state("networkidle")
Belangrijkste punten
- Een Computer Use-agent combineert een actiehandler, een controlemodule en respons-ketening
- De eerste oproep verzendt de taak; elke screenshot komt terug in een
computer_call_outputmet dezelfdecall_id - De handler voert acties op volgorde uit en weigert wat hij niet weet uit te voeren
- Beperk altijd het aantal beurten, stop bij
pending_safety_checksen gebruikheadless=Falsetijdens ontwikkeling run_agent(task, page=page)hergebruikt deze lus voor een reeds geopende pagina; dit is wat de volgende lessen gebruiken