Automatyzacja wieloetapowych przepływów pracy
Na tej stronie
Lekcja zaktualizowana 3 listopada 2026 r. zgodnie z wytycznymi integracji Computer Use od OpenAI: agent nie obsługuje już logowania; walidacja poleceń i gałęzie angażujące użytkownika (recenzje, nowe zamówienia) wymagają potwierdzenia przez człowieka; orkiestrator sprawd teraz kryterium
success_text_contains, które wcześniej ignorował, oznacza nieudane kroki zamiast je pomijać i nigdy nie powtarza kroku tworzącego dane. Źródło: Confirmation and consent.
Orkiestracja złożonych zadań
Prawdziwe przepływy pracy rzadko składają się z pojedynczej akcji. Wypełnienie CRM wymaga nawigacji między stronami, odnalezienia kontaktu, aktualizacji jego danych, a następnie stworzenia szansy sprzedażowej – cztery połączone operacje, z których każda może zakończyć się niepowodzeniem z własnych przyczyn. Przekazanie całego tego bloku agentowi w jednym monicie czasem działa, ale nigdy nie dowiesz się, gdzie nastąpił błąd. Ta lekcja nauczy Cię strukturyzowania tych wieloetapowych automatyzacji tak, aby każde ogniwo było obserwowalne i możliwe do ponownego wykonania.
Architektura oparta na krokach
Zacznij od rozbicia przepływu pracy na atomowe kroki, każdy z jasnym celem i kryterium sukcesu. To kryterium odróżnia listę zadań od prawdziwego przepływu pracy: bez niego Twój orkiestrator nie rozróżni, czy agent faktycznie odniósł sukces, czy zatrzymał się na stronie błędu. W poniższym przykładzie otwarcie modułu weryfikowane jest przez URL, a wyszukiwanie przez obecność nazwiska kontaktu na ekranie. Logowanie nie jest tu uwzględnione: Twój kod obsłużył to wcześniej, nie ujawniając hasła modelowi (Lekcja 8). Ostatni krok ma ustawione "retry": False, ponieważ tworzy dane: jego powtórzenie po częściowej awarii mogłoby stworzyć duplikat.
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
},
]
Orkiestrator
Teraz musisz wykonać tę listę. Orkiestrator przechodzi przez kroki sekwencyjnie, opakowując każdy w pętlę ponawiania: krok, który zgłosi wyjątek lub nie spełni kryterium sukcesu, jest powtarzany do max_retries razy, chyba że został oznaczony jako niepowtarzalny. Ten szczegół ma znaczenie w środowisku produkcyjnym, ponieważ wiele błędów agentów wizualnych jest przemijających – wolna strona, niekompletny render w momencie robienia zrzutu ekranu. Krok, który ostatecznie zawiedzie, zatrzymuje cały przepływ pracy, ponieważ kolejne kroki zależą od jego wyniku. Na koniec orkiestrator zwraca ustrukturyzowany log wskazujący dla każdego kroku jego status i liczbę zużytych prób: Twoje pierwsze narzędzie diagnostyczne.
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
Przekazywanie danych między krokami
Często jeden krok produkuje dane potrzebne następnemu: cena odczytana na stronie koszyka musi zostać zweryfikowana na etapie płatności; numer sprawy utworzony w kroku 2 służy jako odniesienie w kroku 5. Wspólny kontekst rozwiązuje tę potrzebę, nie zamieniając Twojego kodu w plątaninę zmiennych globalnych. Poniższy przykład celowo zatrzymuje się przed płatnością: OpenAI klasyfikuje potwierdzanie transakcji finansowych jako działanie wymagające walidacji przez użytkownika w momencie wykonania. Poniższa klasa przechowuje pary klucz-wartość i udostępnia metodę inject, która zastępuje znaczniki {klucz} w szablonie monitu, pozwalając Ci pisać zadania jako sparametryzowane szablony.
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)
Przepływy pracy z warunkami
Sekwencje liniowe szybko osiągają swoje limity, ponieważ następny krok może zależeć od wyniku poprzedniego. Zapamiętaj ten wzorzec: najpierw poproś agenta o odczytanie stanu, ograniczając go do odpowiedzi wartością z domkniętego zbioru, a następnie rozgałęziaj logikę w Pythonie. W przypadku śledzenia zamówień status „w trakcie przetwarzania“ prowadzi do śledzenia przesyłki, „dostarczone“ do pobrania daty dostawy, a „anulowane“ do pobrania przyczyny. Ograniczenia formatu w monocie są kluczowe: bez nich agent zwraca zdanie, które Twoje porównania regularnie będą pomijać. Wszystkie trzy gałęzie pozostają tylko do odczytu: opublikowanie recenzji lub ponowne zamówienie zaangażowałoby użytkownika i wymagałoby jego potwierdzenia.
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}")
Równoległość
Gdy zadania są niezależne, nie ma potrzeby przetwarzania ich sekwencyjnie. Ekstrakcja danych z trzech kart produktów zajmuje znacznie mniej czasu, jeśli trzech agentów pracuje jednocześnie, każdy w swojej własnej karcie. Wersja asynchroniczna Playwright i asyncio.gather wystarczą: jedna korutyna na URL, jedna new_page na korutynę i systematyczne zamykanie stron, aby uniknąć gromadzenia kart w pamięci. run_agent_async to pętla z Lekcji 4 przepisana z użyciem klienta AsyncOpenAI i asynchronicznego API Playwright: ta sama logika, z await przed każdym wywołaniem. Pamiętaj, że równoległość mnoży również przepustowość wywołań API, zwiększając ryzyko osiągnięcia limitów szybkości (Lekcja 11) oraz obciążenie strony docelowej – trzy karty przejdą niezauważone, pięćdziesiąt znacznie mniej.
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))
Kluczowe wnioski
- Rozbijaj przepływy pracy na atomowe kroki z wyraźnymi kryteriami sukcesu
- Automatycznie powtarzaj kroki, które można bezpiecznie ponowić, nigdy te, które tworzą dane
- Używaj współdzielonego kontekstu do przekazywania danych między krokami
- Przepływy warunkowe dostosowują się do zawartości strony; gałęzie angażujące użytkownika wymagają jego potwierdzenia
- Równoleglij niezależne zadania, aby zaoszczędzić czas