Automatiseer meerstapsworkflows
Op deze pagina
Les bijgewerkt op 3 november 2026 conform de richtlijnen van OpenAI voor Computer Use-integratie: de agent handelt geen inlogpogingen meer af; commando-validatie en vertakkingen die de gebruiker binden (beoordelingen, nieuwe bestellingen) vereisen menselijke bevestiging; de orchestrator controleert nu het criterium
success_text_containsdat eerder werd genegeerd, markeert mislukte stappen in plaats van ze over te slaan, en herhaalt nooit een stap die data creëert. Bron: Confirmation and consent.
Complexe taken orchestreren
Workflows in de praktijk bestaan zelden uit één enkele actie. Het vullen van een CRM vereist navigatie tussen pagina’s, het vinden van een contactpersoon, het bijwerken van hun gegevens en vervolgens het aanmaken van een opportunity—vier gekoppelde bewerkingen die elk om hun eigen reden kunnen mislukken. Dit hele blok in één prompt aan een agent overhandigen werkt soms, maar u weet nooit waar het misging. Deze les leert u hoe u deze meerstapsautomatiseringen structureert zodat elke schakel observeerbaar en herhaalbaar is.
Stap-gebaseerde architectuur
Begin met het opsplitsen van de workflow in atomische stappen, elk met een duidelijk doel en een succes criterium. Dit criterium onderscheidt een takenlijst van een echte workflow: zonder dit criterium kan uw orchestrator niet vaststellen of de agent daadwerkelijk succesvol was of stopte op een foutpagina. In het onderstaande voorbeeld wordt het openen van de module geverifieerd via de URL, en de zoekopdracht via de aanwezigheid van de naam van de contactpersoon op het scherm. Inloggen is hier niet opgenomen: uw code heeft dat vooraf afgehandeld, zonder het wachtwoord bloot te stellen aan het model (Les 8). De laatste stap heeft "retry": False omdat deze data creëert: herhalen na een gedeeltelijke mislukking zou een duplicaat kunnen veroorzaken.
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
},
]
De orchestrator
Nu moet u deze lijst uitvoeren. De orchestrator doorloopt de stappen sequentieel en omwikkelt elke stap met een retry-lus: een stap die een uitzondering veroorzaakt of niet voldoet aan het succes criterium, wordt maximaal max_retries keren opnieuw geprobeerd, tenzij deze als niet-herhaalbaar is gemarkeerd. Dit detail is belangrijk in productie, omdat veel visuele agent-fouten tijdelijk zijn—een trage pagina, een onvolledige weergave op het moment van de screenshot. Een stap die definitief mislukt, stopt de workflow, omdat daaropvolgende stappen ervan afhankelijk zijn. Tot slot retourneert de orchestrator een gestructureerd logboek dat per stap de status en het aantal verbruikte pogingen aangeeft: uw eerste diagnostische hulpmiddel.
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
Data doorgeven tussen stappen
Vaak produceert één stap data die nodig is voor de volgende: de prijs die op een winkelwagenpagina wordt gelezen, moet bij de checkout-stap worden geverifieerd; het zaaknummer dat in stap 2 is aangemaakt, dient als referentie in stap 5. Een gedeelde context lost deze behoefte op zonder uw code te veranderen in een warboel van globale variabelen. Het onderstaande voorbeeld stopt bewust vóór de betaling: OpenAI classificeert het bevestigen van een financiële transactie als een actie die op het moment van uitvoering validatie door de gebruiker vereist. De onderstaande klasse slaat sleutel-waardeparen op en exposeert een inject-methode die {key}-markers in een prompt-sjabloon vervangt, zodat u uw taken als geparametriseerde sjablonen kunt schrijven.
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)
Voorwaardelijke workflows
Lineaire sequenties stuiten snel op hun grenzen, omdat de volgende stap afhangt van het vorige resultaat. Het patroon om te onthouden is dit: vraag de agent eerst om een status te lezen door hem te beperken tot een antwoord met een waarde uit een gesloten set, en vertak vervolgens in Python. Voor ordertracking leidt een status “processing” tot pakkettracking, “delivered” tot het ophalen van de leveringsdatum, en “canceled” tot het ophalen van de reden. Opmaakbeperkingen in de prompt zijn essentieel: zonder deze retourneert de agent een zin die uw vergelijkingen regelmatig zullen missen. Alle drie de vertakkingen blijven read-only: het plaatsen van een beoordeling of het opnieuw bestellen zou de gebruiker binden en diens bevestiging vereisen.
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}")
Parallelisatie
Wanneer taken onafhankelijk zijn, is er geen behoefte om ze sequentieel te verwerken. Het extraheren van data uit drie productfiches gaat veel sneller als drie agents gelijktijdig werken, elk in zijn eigen tabblad. De async-versie van Playwright en asyncio.gather volstaan: één coroutine per URL, één new_page per coroutine, en systematisch sluiten van de pagina om te voorkomen dat tabbladen zich in het geheugen ophopen. run_agent_async is de lus uit Les 4, herschreven met de AsyncOpenAI-client en de async-API van Playwright: dezelfde logica, met await voor elke aanroep. Houd er rekening mee dat parallelisme ook uw API-call-doorvoer vermenigvuldigt, wat het risico vergroot dat u uw rate limits bereikt (Les 11), evenals de belasting op de doelsite—drie tabbladen vallen niet op, vijftig veel minder.
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))
Belangrijkste punten
- Splits workflows op in atomische stappen met expliciete succescriteria
- Herhaal automatisch stappen die veilig opnieuw kunnen worden geprobeerd, maar nooit stappen die data creëren
- Gebruik een gedeelde context om data tussen stappen door te geven
- Voorwaardelijke workflows passen zich aan de pagina-inhoud aan; vertakkingen die de gebruiker binden vereisen diens bevestiging
- Paralleliseer onafhankelijke taken om tijd te besparen