Første workflow: naviger og interager
På denne side
Lektionen er omskrevet den 3. november 2026 baseret på OpenAIs guide til Computer use og Computer use integration recipes: agenten bruger værktøjet
computerfra Responses API, en action handler modelleret efter dokumentationen (grupperede actions,keypress,scroll_x/scroll_y,drag-stier) og kædning viaprevious_response_id, hvilket erstatter kode skrevet til Anthropic’s API. Kilder: Computer use · Integration recipes.
Samling af brikkerne
Du har løkken i tankerne, og miljøet er konfigureret. Nu skal du samle det til et fungerende program: en agent, der åbner en online encyklopædi, søger efter et begreb, åbner det første resultat og rapporterer tilbage med titlen på den side, den nåede frem til. Scenariet virker beskedent, men det involverer de fundamentale bevægelser – navigation, tastaturinput, klik og læsning af information – og alt, hvad du bygger videre på, vil blot være en længere variation af dette.
Action handleren
Modellen træffer beslutningerne, men den udfører intet selv: den returnerer en liste over actions, og din kode oversætter dem til Playwright-bevægelser i rækkefølge. Denne funktion følger handleren udgivet af OpenAI i deres integrationsopskrifter, forenklet til en 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}")
To valg fortjener en forklaring. Nøgle- og knapnavnene returneret af modellen (ENTER, CTRL, wheel…) er ikke det, Playwright forventer (Enter, Control, middle…): mapping-tabellerne, hentet fra dokumentationen, overbygger kløften, og knapperne back og forward, som API’et også kan anmode om, afvises ligesom i OpenAIs handler. Og en ukendt action udløser en fejl i stedet for at blive ignoreret stille og roligt: et hårdt stop er bedre end en agent, der tror, den har handlet, når den ikke har.
Den komplette løkke
Agenten orchestrerer derefter cyklussen. Det første kald sender opgaven; hvis den kun indeholder en anmodning om skærmbillede, returnerer du blot skærmen. Hvert skærmbillede sendes tilbage til modellen som resultatet af det kald, der anmodede om det, refereret ved dets call_id, og previous_response_id linker turene sammen.
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()
Tre sikkerhedsforanstaltninger er allerede på plads. MAX_TURNS begrænser løkken: uden denne grænse ville en desorienteret agent opbruge dit budget, indtil det er tømt. Et kald med verserende sikkerhedstjek (pending_safety_checks) stopper alt, ligesom i OpenAIs officielle eksempel: lektion 12 viser, hvordan disse kan valideres af et menneske. Og normal fuldførelse signaleres ved fraværet af et computer_call: modellen er holdt op med at handle og svarer dig, og du henter sidetitlen fra output_text.
Opstart af workflowet
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."
)
Med headless=False er forestillingen lærerig: vinduet åbnes, klikket lander i søgefeltet, teksten vises, det første link åbnes, og titlen kommer tilbage i din konsol. Lad det køre to eller tre gange, før du går videre til mere ambitiøse opgaver; så vil du præcist se, hvor agenten tøver, og hvad dine instrukser bør adressere.
En genanvendelig funktion til resten af kurset
De følgende lektioner arbejder på en allerede åben side – efter en login, midt i et workflow. De stole på run_agent(task, page=page): den samme løkke, udtrukket fra launch_agent, med valgfrie instructions returneret ved hver tur (lektion 5 forklarer hvorfor).
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")
Tre fejl, du vil støde på
Klikker agenten systematisk ved siden af sit mål? Synderen er næsten altid en skala-uoverensstemmelse mellem det sendte skærmbillede og den side, du klikker på: ændret størrelse på skærmbilledet, browser-zoom, skærm med høj opløsning. Modellens koordinater refererer til det billede, den modtog; hvis du krymper det, skal du konvertere dets koordinater i den modsatte retning.
Kører agenten i ring og gentager den samme bevægelse? Turn-grænsen vil til sidst stoppe den, men det er bedre at opdage løkken tidligere: hvis det samme skærmbillede kommer tilbage flere gange i træk, gør agenten ingen fremskridt, og det sparer dig for unødvendige kald at afbryde den.
Handler agenten på en side, der stadig er tom? På et tungt websted returnerer page.goto(), før renderingen er færdig, og det første skærmbillede viser kun en hvid baggrund. Vent på netværksinaktivitet, før du tager billedet:
page.goto(url)
page.wait_for_load_state("networkidle")
Vigtige pointer
- En Computer Use-agent kombinerer en action handler, en kontrol-løkke og respons-kædning
- Det første kald sender opgaven; hvert skærmbillede returneres i et
computer_call_outputmed sammecall_id - Handleren udfører actions i rækkefølge og afviser det, den ikke ved, hvordan den skal håndtere
- Begræns altid antallet af ture, stop ved
pending_safety_checks, og brugheadless=Falseunder udvikling run_agent(task, page=page)genbruger denne løkke til en allerede åben side; det er dette, de følgende lektioner bruger