Automatizácia viacstupňových pracovných postupov
Na tejto strane
Lekcia aktualizovaná 3. novembra 2026 podľa pokynov OpenAI pre integráciu Computer Use: agent už nezvláda prihlásenie; validácia príkazov a vetvy, ktoré zaväzujú používateľa (recenzie, nové objednávky), si vyžadujú ľudské potvrdenie; orchestrátor teraz kontroluje kritérium
success_text_contains, ktoré predtým ignoroval, označuje neúspešné kroky namiesto ich preskočenia a nikdy neopakuje krok, ktorý vytvára dáta. Zdroj: Potvrdenie a súhlas.
Orchestrovanie komplexných úloh
Reálne pracovné postupy sa zriedka skladajú z jednej akcie. Naplnenie CRM zahŕňa navigáciu medzi stránkami, vyhľadanie kontaktu, aktualizáciu jeho informácií a následné vytvorenie príležitosti – štyri prepojené operácie, z ktorých každá môže zlyhať z vlastných dôvodov. Odovzdanie celého tohto bloku agentovi v jednom príkaze niekedy funguje, ale nikdy nezistíš, kde presne došlo k chybe. Táto lekcia ťa naučí štruktúrovať tieto viacstupňové automatizácie tak, aby bol každý článok pozorovateľný a opakovateľný.
Architektúra založená na krokoch
Začni rozdelením pracovného postupu na atómové kroky, pričom každý má jasný cieľ a kritérium úspechu. Práve toto kritérium odlišuje zoznam úloh od skutočného pracovného postupu: bez neho tvoj orchestrátor nerozozná, či agent skutočne uspel, alebo zastavil na stránke s chybou. V nižšie uvedenom príklade je otvorenie modulu overené URL adresou a vyhľadávanie prítomnosťou mena kontaktu na obrazovke. Prihlásenie tu nie je zahrnuté: tvoj kód to vybavil vopred bez toho, aby odhalil heslo modelu (Lekcia 8). Posledný krok má "retry": False, pretože vytvára dáta: jeho opakovanie po čiastočnom zlyhaní by mohlo vytvoriť duplikát.
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
},
]
Orchestrátor
Teraz musíš tento zoznam vykonať. Orchestrátor prechádza krokmi sekvenčne a každý z nich obalí do slučky s opakovaním: krok, ktorý vyvolá výnimku alebo nesplní svoje kritérium úspechu, sa opakuje až max_retries-krát, pokiaľ nie je označený ako neopakovateľný. Tento detail je v produkcii dôležitý, pretože mnohé zlyhania vizuálnych agentov sú prechodné – pomalá stránka, neúplné vykreslenie v čase snímky obrazovky. Krok, ktorý definitívne zlyhá, zastaví celý pracovný postup, keďže nasledujúce kroky na ňom závisia. Nakoniec orchestrátor vráti štruktúrovaný záznam, ktorý pre každý krok uvádza jeho stav a počet spotrebovaných pokusov: tvoj prvý diagnostický nástroj.
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
Odovzdávanie dát medzi krokmi
Často jeden krok vyprodukuje dáta potrebné pre ďalší: cena načítaná na stránke košíka sa musí overiť v kroku pokladne; číslo prípadu vytvorené v kroku 2 slúži ako referencia v kroku 5. Zdieľaný kontext rieši túto potrebu bez toho, aby sa tvoj kód zmenil na spletenec globálnych premenných. Nižšie uvedený príklad zámerne končí pred platbou: OpenAI klasifikuje potvrdenie finančnej transakcie ako akciu vyžadujúcu validáciu používateľom v momente vykonania. Trieda nižšie ukladá páry kľúč-hodnota a vystavuje metódu inject, ktorá nahrádza značky {kľúč} v šablóne príkazu, čo ti umožňuje písať úlohy ako parameterizované šablóny.
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)
Podmienené pracovné postupy
Lineárne sekvencie rýchlo narážajú na svoje limity, pretože ďalší krok môže závisieť od výsledku toho predchádzajúceho. Vzorec, ktorý si treba zapamätať, je tento: najprv požiadaj agenta, aby prečítal stav obmedzením jeho odpovede na hodnotu z uzavretej množiny, a potom sa vetvi v Pythone. Pri sledovaní objednávky stav „spracováva sa“ vedie k sledovaniu balíka, „doručené“ k získaniu dátumu doručenia a „zrušené“ k získaniu dôvodu. Obmedzenia formátu v príkaze sú nevyhnutné: bez nich agent vráti vetu, ktorú tvoje porovnania pravidelne minú. Všetky tri vetvy zostávajú len na čítanie: pridanie recenzie alebo opätovné objednanie by zaviazalo používateľa a vyžadovalo si jeho potvrdenie.
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}")
Paralelizácia
Keď sú úlohy nezávislé, nie je potrebné spracovávať ich sekvenčne. Extrakcia dát z troch produktových listov trvá oveľa menej času, ak pracujú traja agenti súčasne, každý vo svojej karte. Async verzia Playwright a asyncio.gather stačia: jedna korutína na URL adresu, jedna new_page na korutínu a systematické zatváranie stránok, aby sa v pamäti nehromadili karty. run_agent_async je slučka z Lekcie 4 prepísaná s klientom AsyncOpenAI a async API Playwright: rovnaká logika, s await pred každým volaním. Maj na pamäti, že paralelizácia tiež násobí priepustnosť tvojich volaní API, čím zvyšuje riziko dosiahnutia limitov rýchlosti (Lekcia 11), a zaťaženie cieľovej stránky – tri karty zostanú bez povšimnutia, päťdesiat oveľa menej.
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))
Kľúčové poznatky
- Rozdeľ pracovné postupy na atómové kroky s explicitnými kritériami úspechu
- Automaticky opakuj kroky, ktoré sa dajú bezpečne retryovať, nikdy nie tie, ktoré vytvárajú dáta
- Použi zdieľaný kontext na odovzdávanie dát medzi krokmi
- Podmienené pracovné postupy sa prispôsobujú obsahu stránky; vetvy, ktoré zaväzujú používateľa, si vyžadujú jeho potvrdenie
- Paralelizuj nezávislé úlohy na úsporu času