Automatisera flerstegsarbetsflöden
På denna sida
Lektionen uppdaterad 3 november 2026 enligt OpenAIs riktlinjer för integration av Computer Use: agenten hanterar inte längre inloggning; kommandovalidering och grenar som binder användaren (recensioner, nya beställningar) kräver mänsklig bekräftelse; orkestratorn kontrollerar nu kriteriet
success_text_containssom den tidigare ignorerade, flaggar misslyckade steg istället för att hoppa över dem, och spelar aldrig upp ett steg som skapar data. Källa: Confirmation and consent.
Orkestrering av komplexa uppgifter
Verkliga arbetsflöden består sällan av en enda åtgärd. Att fylla i ett CRM-system innebär att navigera mellan sidor, hitta en kontakt, uppdatera deras information och sedan skapa en affärsmöjlighet – fyra kedjade operationer där var och en kan misslyckas av egna skäl. Att överlåta hela detta block till en agent i en enda prompt fungerar ibland, men du kommer aldrig att veta var det gick fel. Den här lektionen lär dig att strukturera dessa flerstegsautomatiseringar så att varje länk är observerbar och kan spelas upp.
Stegbaserad arkitektur
Börja med att bryta ner arbetsflödet i atomära steg, var och ett med ett tydligt mål och ett framgångskriterium. Det är detta kriterium som skiljer en att-göra-lista från ett verkligt arbetsflöde: utan det kan din orkestrator inte avgöra om agenten faktiskt lyckades eller stannade på en felsida. I exemplet nedan verifieras öppnandet av modulen via URL:en och sökningen genom förekomsten av kontaktens namn på skärmen. Inloggning ingår inte här: din kod hanterade det i förväg utan att exponera lösenordet för modellen (lektion 8). Det sista steget har "retry": False eftersom det skapar data: att spela upp det efter ett partiellt misslyckande skulle kunna skapa en dubblett.
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
},
]
Orkestratorn
Nu måste du köra denna lista. Orkestratorn går igenom stegen sekventiellt och包裹ar varje steg i en försöksloop: ett steg som kastar ett undantag eller misslyckas med sitt framgångskriterium försöks igen upp till max_retries gånger, såvida det inte är markerat som icke-upprepningsbart. Denna detalj är viktig i produktion, eftersom många visuella agentfel är övergående – en långsam sida, en ofullständig rendering vid ögonblicket för skärmdumpen. Ett steg som misslyckas definitivt stoppar arbetsflödet, eftersom efterföljande steg beror på det. Slutligen returnerar orkestratorn en strukturerad logg som för varje steg anger status och antal förbrukade försök: ditt första diagnostiska verktyg.
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
Överföring av data mellan steg
Ofta producerar ett steg data som behövs av nästa: priset som lästs på en varukorgssida måste verifieras vid kassasteget; ärendenumret som skapades i steg 2 fungerar som referens i steg 5. En delad kontext löser detta behov utan att göra din kod till en härva av globala variabler. Exemplet nedan stannar avsiktligt före betalningen: OpenAI klassificerar bekräftelse av en finansiell transaktion som en åtgärd som kräver användarvalidering vid utförandet. Klassen nedan lagrar nyckel-värde-par och exponerar en metod inject som ersätter markörer {nyckel} i en prompt-mall, vilket låter dig skriva dina uppgifter som parametriserade mallar.
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)
Villkorliga arbetsflöden
Linjära sekvenser når snabbt sina gränser, eftersom nästa steg kan bero på resultatet från det föregående. Mönstret att komma ihåg är detta: be först agenten att läsa av ett tillstånd genom att begränsa den till att svara med ett värde från en sluten mängd, och gren sedan i Python. För orderuppföljning leder statusen “processing” till paketspårning, “delivered” till hämtning av leveransdatum och “canceled” till hämtning av anledningen. Formatbegränsningar i prompten är avgörande: utan dem returnerar agenten en mening som dina jämförelser regelbundet kommer att missa. Alla tre grenarna är skrivskyddade: att posta en recension eller beställa igen skulle binda användaren och kräva deras 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}")
Parallellisering
När uppgifter är oberoende finns det inget behov av att bearbeta dem sekventiellt. Att extrahera data från tre produktblad tar betydligt mindre tid om tre agenter arbetar samtidigt, var och en i sin egen flik. Playwrights async-version och asyncio.gather räcker: en korutin per URL, en new_page per korutin och systematisk stängning av sidor för att undvika att ackumulera flikar i minnet. run_agent_async är loopen från lektion 4 omskriven med AsyncOpenAI-klienten och Playwrights async-API: samma logik, med await före varje anrop. Tänk på att parallellisering också multiplicerar din genomströmning av API-anrop, vilket ökar risken att nå dina hastighetsbegränsningar (lektion 11), och din belastning på målsidan – tre flikar går obemärkt förbi, femtio mycket mindre så.
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))
Viktiga punkter
- Bryt ner arbetsflöden i atomära steg med explicita framgångskriterier
- Spela automatiskt upp steg som kan försökas igen säkert, aldrig de som skapar data
- Använd en delad kontext för att föra data mellan steg
- Villkorliga arbetsflöden anpassar sig till sidinnehåll; grenar som binder användaren kräver deras bekräftelse
- Parallelisera oberoende uppgifter för att spara tid