Automatizace vícekrokových pracovních postupů
Na této stránce
Lekce aktualizována 3. listopadu 2026 podle pokynů OpenAI pro integraci Computer Use: agent již nezpracovává přihlášení; validace příkazů a větve, které zavazují uživatele (recenze, nové objednávky), vyžadují lidské potvrzení; orchestrátor nyní kontroluje kritérium
success_text_contains, které dříve ignoroval, označuje neúspěšné kroky místo jejich přeskakování a nikdy nepřehrává krok, který vytváří data. Zdroj: Confirmation and consent.
Orchestrování složitých úkolů
Reálné pracovní postupy se zřídka skládají z jediné akce. Naplnění CRM zahrnuje navigaci mezi stránkami, vyhledání kontaktu, aktualizaci jeho informací a následné vytvoření obchodní příležitosti – čtyři navazující operace, z nichž každá může selhat z vlastních důvodů. Předání celého tohoto bloku agentovi v jediném promptu někdy funguje, ale nikdy nezjistíš, kde přesně došlo k chybě. Tato lekce tě naučí strukturovat tyto vícekrokové automatizace tak, aby byl každý článek pozorovatelný a opakovatelný.
Architektura založená na krocích
Začni rozdělením pracovního postupu na atomické kroky, každý s jasným cílem a kritériem úspěchu. Právě toto kritérium odlišuje seznam úkolů od skutečného pracovního postupu: bez něj tvůj orchestrátor nerozpozná, zda agent skutečně uspěl, nebo zastavil na chybové stránce. V níže uvedeném příkladu je otevření modulu ověřeno URL adresou a vyhledávání přítomností jména kontaktu na obrazovce. Přihlášení zde není zahrnuto: tvůj kód to zpracoval předem, aniž by modelu odhalil heslo (Lekce 8). Poslední krok má "retry": False, protože vytváří data: jeho přehrání po částečném selhání by mohlo vytvořit duplicitu.
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
Nyní musíš tento seznam spustit. Orchestrátor prochází kroky sekvenčně a každý z nich obaluje smyčkou pro opakování: krok, který vyvolá výjimku nebo nesplní své kritérium úspěchu, se opakuje až max_retries krát, pokud není označen jako nepřehrávatelný. Tento detail je v produkci zásadní, protože mnoho selhání vizuálních agentů je přechodných – pomalá stránka, neúplné vykreslení v okamžiku snímku obrazovky. Krok, který selže definitivně, zastaví celý pracovní postup, protože na něm závisí následné kroky. Nakonec orchestrátor vrátí strukturovaný log, který pro každý krok uvádí jeho stav a počet spotřebovaných pokusů: tvůj první 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
Předávání dat mezi kroky
Často jeden krok produkuje data potřebná pro další: cena načtená na stránce košíku musí být ověřena v kroku pokladny; číslo případu vytvořené ve 2. kroku slouží jako reference v 5. kroku. Sdílený kontext řeší tuto potřebu, aniž by se tvůj kód změtil v spleť globálních proměnných. Níže uvedený příklad záměrně končí před platbou: OpenAI klasifikuje potvrzení finanční transakce jako akci vyžadující validaci uživatelem v okamžiku provedení. Níže uvedená třída ukládá páry klíč-hodnota a vystavuje metodu inject, která nahrazuje značky {key} v šabloně promptu, což ti umožňuje psát úkoly jako parametrizované šablony.
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)
Podmíněné pracovní postupy
Lineární sekvence rychle naráží na své limity, protože další krok může záviset na výsledku toho předchozího. Vzorec, který si musíš zapamatovat, je tento: nejprve požádej agenta o přečtení stavu tím, že ho omezíš na odpověď hodnotou z uzavřené množiny, a poté větvi v Pythonu. U sledování objednávek stav „zpracováváno“ vede ke sledování balíčku, „doručeno“ k získání data doručení a „zrušeno“ k získání důvodu. Omezení formátu v promptu jsou zásadní: bez nich agent vrátí větu, kterou tvá porovnání pravidelně minou. Všechny tři větve zůstávají pouze pro čtení: odeslání recenze nebo nové objednání by zavazovalo uživatele a vyžadovalo by jeho potvrzení.
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}")
Paralelizace
Když jsou úkoly nezávislé, není třeba je zpracovávat sekvenčně. Extrakce dat ze tří produktových listů trvá mnohem méně času, pokud pracují tři agenti současně, každý ve své vlastní kartě. Asynchronní verze Playwright a asyncio.gather stačí: jedna korutina na URL, jedna new_page na korutinu a systematické zavírání stránek, aby se v paměti nehromadily karty. run_agent_async je smyčka z Lekce 4 přepsaná s klientem AsyncOpenAI a asynchronním API Playwright: stejná logika, s await před každým voláním. Měj na paměti, že paralelismus také násobí propustnost tvých volání API, což zvyšuje riziko dosažení limitů rychlosti (Lekce 11), a zatížení cílového webu – tři karty projdou bez povšimnutí, padesát mnohem méně.
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))
Klíčové poznatky
- Rozděl pracovní postupy na atomické kroky s explicitními kritérii úspěchu
- Automaticky přehrávej kroky, které lze bezpečně opakovat, nikdy ty, které vytvářejí data
- Používej sdílený kontext k předávání dat mezi kroky
- Podmíněné pracovní postupy se přizpůsobují obsahu stránky; větve, které zavazují uživatele, vyžadují jeho potvrzení
- Paralelizuj nezávislé úkoly pro úsporu času