Automatiser arbejdsgange i flere trin
På denne side
Lektion opdateret 3. november 2026 i henhold til OpenAIs retningslinjer for integration af computerbrug: agenten håndterer ikke længere login; kommandovalidering og grene, der binder brugeren (anmeldelser, nye ordrer), kræver menneskelig bekræftelse; orkestratoren tjekker nu kriteriet
success_text_contains, som den tidligere ignorerede, flagger mislykkede trin i stedet for at springe dem over og gentager aldrig et trin, der opretter data. Kilde: Bekræftelse og samtykke.
Orkestrering af komplekse opgaver
Arbejdsgange i den virkelige verden består sjældent af én enkelt handling. At udfylde et CRM-system indebærer navigation mellem sider, lokalisering af en kontakt, opdatering af deres oplysninger og derefter oprettelse af en mulighed – fire kædede operationer, som hver især kan fejle af forskellige årsager. At overlade hele denne blok til en agent i én enkelt prompt fungerer nogle gange, men du vil aldrig vide, hvor det gik galt. Denne lektion lærer dig at strukturere disse automatiseringer i flere trin, så hvert led er observerbart og kan gentages.
Arkitektur baseret på trin
Start med at opdele arbejdsgangen i atomare trin, hver med et klart mål og et succeskriterium. Det er dette kriterium, der adskiller en huskeliste fra en ægte arbejdsgang: uden det kan din orkestrator ikke afgøre, om agenten faktisk lykkedes, eller om den stoppede på en fejlside. I eksemplet nedenfor verificeres åbningen af modulet via URL’en, og søgningen ved tilstedeværelsen af kontaktens navn på skærmen. Login er ikke inkluderet her: din kode håndterede det på forhånd uden at eksponere adgangskoden for modellen (Lektion 8). Det sidste trin har "retry": False, fordi det opretter data: at gentage det efter en delvis fejl kunne skabe en dublet.
workflow = [
{
"name": "open_contacts",
"task": "Open the Contacts module in the CRM.",
"success_url_contains": "/contacts",
},
{
"name": "search_contact",
"task": "Search for contact 'Jean Dupont' in the search bar.",
"success_text_contains": "Jean Dupont",
},
{
"name": "update_record",
"task": "Open Jean Dupont's profile and update their phone number: 06 98 76 54 32.",
},
{
"name": "create_opportunity",
"task": "Create an opportunity: 'Cloud Migration Q2 2026', amount 50000 EUR, probability 60%.",
"retry": False, # non-replayable step: creates data
},
]
Orkestratoren
Nu skal du eksekvere denne liste. Orkestratoren gennemgår trinnene sekventielt og pakker hvert trin ind i en gentagelsesløkke: et trin, der udløser en undtagelse eller ikke opfylder sit succeskriterium, gentages op til max_retries gange, medmindre det er markeret som ikke-genafspilleligt. Denne detalje er vigtig i produktion, fordi mange visuelle agentfejl er forbigående – en langsom side, en ufuldstændig gengivelse på tidspunktet for skærmbilledet. Et trin, der fejler definitivt, stopper arbejdsgangen, da efterfølgende trin afhænger af det. Til sidst returnerer orkestratoren en struktureret log, der for hvert trin angiver status og antallet af brugte forsøg: dit første diagnostiske værktøj.
def run_workflow(workflow: list, page, max_retries: int = 2):
"""Executes a multi-step workflow with retries."""
results = []
for step in workflow:
step_name = step["name"]
print(f"\n--- Step: {step_name} ---")
attempts = max_retries + 1 if step.get("retry", True) else 1
error = "success criterion not met"
for attempt in range(attempts):
try:
run_agent(step["task"], page=page)
# Optional checks: URL, then visible text
url_check = step.get("success_url_contains")
if url_check and url_check not in page.url:
print(" Expected URL not found")
continue
text_check = step.get("success_text_contains")
if text_check and text_check not in page.locator("body").inner_text():
print(" Expected text not found")
continue
print(f" Success (attempt {attempt + 1})")
results.append({"step": step_name, "status": "success", "attempts": attempt + 1})
break
except Exception as e:
print(f" Error: {e}")
error = str(e)
else:
# No attempt succeeded: subsequent steps depend on this one
results.append({"step": step_name, "status": "failed", "error": error})
break
return results
Videregivelse af data mellem trin
Ofte producerer ét trin data, som det næste har brug for: prisen læst på en indkøbskurv-side skal verificeres ved kassen; sagsnummeret oprettet i trin 2 fungerer som reference i trin 5. En delt kontekst løser dette behov uden at gøre din kode til et virvar af globale variabler. Eksemplet nedenfor stopper bevidst før betaling: OpenAI klassificerer bekræftelse af en finansiel transaktion som en handling, der kræver brugervalidering på udførelsestidspunktet. Klassen nedenfor gemmer nøgle-værdi-par og eksponerer en inject-metode, der erstatter {key}-markører i en prompt-skabelon, så du kan skrive dine opgaver som parametriserede skabeloner.
class WorkflowContext:
"""Stores data shared between steps."""
def __init__(self):
self.data = {}
def set(self, key: str, value):
self.data[key] = value
def get(self, key: str, default=None):
return self.data.get(key, default)
def inject(self, template: str) -> str:
"""Replaces {key} variables in the template."""
task = template
for key, value in self.data.items():
task = task.replace("{" + key + "}", str(value))
return task
# Usage example
ctx = WorkflowContext()
# Step 1: agent reads a price
extracted_price = run_agent(
"Read the total price displayed and return only the number.",
page=page
)
ctx.set("price", extracted_price.strip())
# Step 2: agent verifies, without validating anything
verdict = run_agent(ctx.inject(
"The expected amount is {price} EUR. Compare it to the total on the payment page "
"and answer only OK or MISMATCH. Do not validate anything."
), page=page)
# Step 3: a transaction is confirmed at the moment of action, by a human
if verdict.strip() == "OK":
if input(f"Confirm order for {ctx.get('price')} EUR? [y/N] ").strip().lower() == "y":
run_agent("Click the order confirmation button.", page=page)
Betingede arbejdsgange
Lineære sekvenser støder hurtigt på deres begrænsninger, fordi næste trin kan afhænge af resultatet af det foregående. Mønsteret, du skal huske, er dette: Bed først agenten om at læse en tilstand ved at begrænse den til at svare med en værdi fra en lukket mængde, og foretag derefter en forgrening i Python. Til ordretracking fører statussen „behandling” til pakkesporing, „leveret” til hentning af leveringsdatoen og „annulleret” til hentning af årsagen. Formatbegrænsninger i prompten er afgørende: uden dem returnerer agenten en sætning, som dine sammenligninger regelmæssigt vil overse. Alle tre grene forbliver skrivebeskyttede: at poste en anmeldelse eller genbestille ville binde brugeren og kræve deres bekræftelse.
def conditional_workflow(page):
"""Workflow with conditional branching."""
# Step 1: Read status
status = run_agent(
"Read the order status. "
"Return only: processing, delivered, or canceled.",
page=page
)
# Branch based on result
match status.strip().lower():
case "processing":
return run_agent("Click 'Track package' and note the displayed stage.", page=page)
case "delivered":
return run_agent("Note the displayed delivery date.", page=page)
case "canceled":
return run_agent("Note the displayed cancellation reason.", page=page)
case _:
raise ValueError(f"Unexpected status: {status!r}")
Parallelisering
Når opgaver er uafhængige, er der ingen grund til at behandle dem sekventielt. Udtrækning af data fra tre produktdatablade tager langt mindre tid, hvis tre agenter arbejder samtidigt, hver i sin egen fane. Playwrights async-version og asyncio.gather er tilstrækkelige: én coroutine pr. URL, én new_page pr. coroutine og systematisk lukning af sider for at undgå at ophobe faner i hukommelsen. run_agent_async er løkken fra Lektion 4 omskrevet med AsyncOpenAI-klienten og Playwrights async-API: samme logik, men med await før hvert kald. Husk, at parallelisering også ganger din API-kaldsgennemstrømning op, hvilket øger risikoen for at ramme dine hastighedsgrænser (Lektion 11), og belastningen på målsitet – tre faner går ubemærket hen, halvtreds meget mindre.
import asyncio
from playwright.async_api import async_playwright
async def parallel_extraction(urls: list[str]):
"""Extracts data from multiple pages in parallel."""
async with async_playwright() as pw:
browser = await pw.chromium.launch(headless=True)
async def extract_one(url: str):
page = await browser.new_page(
viewport={"width": 1280, "height": 720}
)
try:
await page.goto(url)
result = await run_agent_async(
"Extract the product title and price.", page=page
)
finally:
await page.close()
return {"url": url, "data": result}
results = await asyncio.gather(
*[extract_one(url) for url in urls]
)
return results
# Run
urls = [
"https://shop.example.com/product/1",
"https://shop.example.com/product/2",
"https://shop.example.com/product/3",
]
data = asyncio.run(parallel_extraction(urls))
Vigtige pointer
- Opdel arbejdsgange i atomare trin med eksplicitte succeskriterier
- Gentag automatisk trin, der kan gentages sikkert, men aldrig dem, der opretter data
- Brug en delt kontekst til at videregive data mellem trin
- Betingede arbejdsgange tilpasser sig sideindhold; grene, der binder brugeren, kræver deres bekræftelse
- Paralleliser uafhængige opgaver for at spare tid