> Hogyan működik az ügynökhurok a kódban, mely leállási feltételeket és kereteket érdemes kikényszeríteni, és hogyan viselkedik a Ralph, a /loop és a /goal.
>
> Web page: https://balazscsorba.com/hu/blog/agent-loop-explained · Language: Magyar · Also available in: [English](https://balazscsorba.com/blog/agent-loop-explained.md) · [Deutsch](https://balazscsorba.com/de/blog/agent-loop-explained.md)
> Author: Balázs Csorba · Published: 2026-07-16 · Updated: 2026-09-04 · Keywords: ügynökhurok, ügynökhurok magyarázat, human in the loop ai ügynök, ai ügynök hurok, tool calling loop, ralph loop kódoló ügynök, claude code /loop, claude code /goal, hogyan állítsunk meg egy ai ügynököt, react ügynök minta, stop_reason tool_use

[Blog](https://balazscsorba.com/hu/blog)/[MI-ügynökök](https://balazscsorba.com/hu/blog/category/agents)

# Az ügynökhurok magyarázata: hogyan futnak a kódoló ügynökök, és hogyan állítjuk meg őket

Hogyan működik az ügynökhurok a kódban, mely leállási feltételeket és kereteket érdemes kikényszeríteni, és hogyan viselkedik a Ralph, a /loop és a /goal.

[Balázs Csorba](https://balazscsorba.com/hu/about)·2026\. július 16.·frissítve 2026\. szeptember 4.·10 perc olvasás

-   Agent loop
-   [Coding agents](https://balazscsorba.com/hu/blog/tag/coding-agents)
-   Tool calling
-   [Claude Code](https://balazscsorba.com/hu/blog/tag/claude-code)
-   Stop conditions

![Az ügynökhurok: egy kis robot körpályán jár, a célzászló mellett csíkos sorompó zárja le a kört.](https://balazscsorba.com/images/blog/agent-loop-explained/cover.webp?v=08ca8ece50)

## A lényeg röviden

-   Az ügynökhurok meghívja a modellt, lefuttatja a kért eszközt, hozzáfűzi az eredményt, és ezt addig ismétli, amíg egy leállási feltétel le nem zárja a futást.
-   A Claude Messages API-ban a stop\_reason tool\_use azt jelenti: futtasd le az eszközt, és küldj vissza egy tool\_result blokkot a passoló tool\_use\_id-val.
-   A modell saját end\_turn-je a leggyengébb leállási feltétel; a kódban kikényszerített iterációs, token- és időkeret mellett kell előrehaladás-figyelés is.
-   A tesztek csak akkor az ügynökhurok igazságértékei, ha tudnak bukni: a regressziós tesztnek el kell buknia, ha csak a javítást vonjuk vissza.
-   A külső hurkok, mint a Ralph shell hurok, a Claude Code /loop és /goal, újraindítják vagy újrapromptolják az ügynököt, és mindegyiknek saját leállási szabály kell.

Ezen az oldalon

1.  [Mi az ügynökhurok?](https://balazscsorba.com/#what-is-an-agent-loop)
2.  [Hogyan működik az ügynökhurok a kódban?](https://balazscsorba.com/#agent-loop-in-code)
3.  [Mikor álljon meg egy ügynökhurok?](https://balazscsorba.com/#stop-conditions)
4.  [Miért a tesztek az ügynökhurok igazságértékei](https://balazscsorba.com/#ground-truth)
5.  [Külső hurkok: Ralph, /loop és /goal](https://balazscsorba.com/#outer-loops)
6.  [Mikor ne használj ügynökhurokot, és hogyan bukik el](https://balazscsorba.com/#failure-modes)
7.  [Ügynökhurok-ellenőrzőlista](https://balazscsorba.com/#checklist)
8.  [Források](https://balazscsorba.com/#sources)

Cikk meghallgatása

0:00

Az **ügynökhurok** minden MI-ügynökben megtalálható vezérlőhurok: a modell elolvassa a saját kontextusát, eszközhívást kér, a kódod lefuttatja az eszközt és hozzáfűzi az eredményt, majd a modellt újra meghívják. Ez addig ismétlődik, amíg egy leállási feltétel le nem zárja a futást. A kódoló ügynökök, a kutatási ügynökök és a support botok ugyanezt használják. Amitől egy hasznos ügynök nem lesz drága, az elsősorban az, hogyan ellenőrzi a hurok a saját munkáját, és mikor áll meg.

Ez a cikk végigmegy a hurkon a kódban, a leállási feltételeken és a kereteken, amelyeket érdemes kikényszeríteni, azon, miért a tesztek az ügynökhurok igazságértékei, és az ezekre épülő külső hurkokon: Geoffrey Huntley „Ralph” technikáján és a Claude Code `/loop` és `/goal` parancsain. A végén hibaformák és egy ellenőrzőlista következik.

## Mi az ügynökhurok?

Az ügynökhurok egy olyan modell, amely újra és újra meghívja az eszközeit, minden eredményből eldönti a következő lépést, addig, amíg úgy nem dönt, hogy kész van, vagy amíg valami meg nem állítja. Az Anthropic [„Building effective agents”](https://www.anthropic.com/engineering/building-effective-agents) cikke (2024. december) így írja le az ügynököket: „környezeti visszajelzésre épülő eszközhívásokat ismételnek egy hurokban”, és elválasztja őket a munkafolyamatoktól, amelyekben „az LLM-eket és az eszközöket előre definiált kódutak szervezik”. Egy ügynökben a modell maga irányítja a folyamatát, egy munkafolyamatban a kódod.

Az ötlet régebbi, mint a mai kódoló ügynökök. A Yao et al. ReAct-papírja ([„ReAct: Synergizing Reasoning and Acting in Language Models”](https://arxiv.org/abs/2210.03629), 2022) azt tanította a modelleknek, hogy „gondolatmenet-nyomokat és feladatspecifikus műveleteket váltakozva” generáljanak: gondolkodni, cselekedni, megfigyelni, megint gondolkodni. Az interaktív ALFWorld és WebShop benchmarkokon egy-két in-context példával 34, illetve 10 abszolút százalékponttal verte az utánzási és a megerősítéses tanulás alapvonalait. A modern eszközhívó API-k ezt a promptmintát protokollá alakították: a modell strukturált eszközkérést ad vissza olyan szöveg helyett, amelyet parszolni kellene.

## Hogyan működik az ügynökhurok a kódban?

A kódban az ügynökhurok egy `while` hurok egy API-hívás körül. Minden iteráció elküldi a teljes üzenetelőzményt, és a válasz leállási oka mondja meg, hogy futtassunk-e eszközt és folytassuk, vagy álljunk meg.

A Claude Messages API-nél a szerződés egyértelmű. Ha a modell eszközt akar, a válaszban `stop_reason: "tool_use"` áll, és egy vagy több `tool_use` blokk van benne, mindegyik `id`\-vel, eszköz-`name`\-mel és `input`\-tel. A kódod lefuttatja az eszközt, majd visszaküld egy „user” szerepű üzenetet, amely kizárólag `tool_result` blokkokat tartalmaz, a `tool_use_id` alapján illesztve. A [leállási okokról szóló dokumentáció](https://platform.claude.com/docs/en/build-with-claude/handling-stop-reasons) felsorolja a többi értéket: `end_turn` (befejeződött), `max_tokens`, `stop_sequence`, `refusal`, `model_context_window_exceeded` és `pause_turn`, ami azt jelenti, hogy egy szerveroldali eszközhurok elérte a saját iterációs limitjét (alapértelmezetten 10), és a folytatáshoz vissza kell küldeni a tartalmat.

Python

```
# Simplified sketch of an agent loop (Claude Messages API, Python SDK)
messages = [{"role": "user", "content": task}]

for turn in range(MAX_TURNS):                        # hard stop 1: iterations
    response = client.messages.create(
        model=MODEL, max_tokens=4096, tools=TOOLS, messages=messages)
    messages.append({"role": "assistant", "content": response.content})

    if response.stop_reason != "tool_use":           # end_turn, max_tokens, refusal ...
        break

    results = []
    for block in response.content:
        if block.type == "tool_use":
            output = run_tool(block.name, block.input)   # your code, your sandbox
            results.append({"type": "tool_result",
                            "tool_use_id": block.id,
                            "content": output})
    messages.append({"role": "user", "content": results})

    if budget.exceeded() or no_progress(messages):    # hard stops 2 and 3
        break
```

Két részlet fontosabb, mint elsőre látszik. Első: a `run_tool` hordozza az összes kockázatot: azt futtatja le, amit a modell kért, tehát szűk hatókörű hitelesítő adatokkal ellátott sandboxba kerül (lásd [a kódoló ügynökök sandboxolását a CI-ban](https://balazscsorba.com/hu/blog/sandboxing-coding-agents-ci-checklist)). Másod: minden eszközeredmény a `messages` listában marad, a kontextus tehát minden iterációval nő. Egy hosszú hurok minden hívásban kifizeti a teljes előzményét.

![Az ügynökhurok egy köre: modellhívás, leállási ok ellenőrzése, eszközfuttatás és a tool_result visszaküldése.](https://balazscsorba.com/images/blog/agent-loop-explained/diagram-10.webp?v=7c5efcd7b7)

Egy iteráció az ügynökhurokban: meghívjuk a modellt, ellenőrizzük a leállási okot, lefuttatjuk a kért eszközt, hozzáfűzzük a tool\_result blokkot, és ismételjük – a keretellenőrzés akkor is leállíthatja a hurkot, ha a modell tovább akar menni.

## Mikor álljon meg egy ügynökhurok?

Egy ügynökhurok akkor álljon meg, ha a feladat bizonyíthatóan kész, és akkor is, ha elfogy egy keret, bármit gondol is a modell. Az Anthropic útmutatása kimondja: „különösen fontos leállási feltételeket (például egy maximális iterációszámot) beépíteni, hogy megőrizzük az uralmat”.

A modell saját `end_turn` jele a természetes kilépés, de a leggyengébb. Csak azt jelenti, hogy a modell késznek érzi magát. Az alábbi táblázat minden más sora azért létezik, mert ez a hit néha téves, és mert a soha véget nem érő hurok csendben pénzt éget.

Leállási feltétel

Mit fog meg

Önmagában vett gyengesége

A modell befejezi a köréét (`end_turn`)

Normális befejeződés

A modell túl korán győzelmet hirdethet

Maximális iterációk száma

Kontroll nélkül szaladó hurkok

Levágja a legitim hosszú feladatokat

Token- vagy költségkeret

Drága spirálok, növekvő kontextus

Feladatonkénti, mért számok kellenek hozzá

Időlimit (valós idő)

Beragadt eszközök, lassú külső rendszerek

A minőségről nem mond semmit

Előrehaladás-figyelés

Körbe-körbe járás

Definiálni kell, mi az „előrehaladás”

Külső ellenőrzés (tesztek, értékelő)

Hamis „kész”

Csak annyira jó, mint maga az ellenőrzés

Az **előrehaladás-figyelés** az, amit a csapatok kihagynak, és épp ez menti a legtöbbet. Az előrehaladást valamire kell definiálni, amit a hurok számolni tud: a bukó tesztek számának csökkenésére, lezárt review szálakra, egy zsugorodó teendőlistára. A review-kör skillem a lezárt review szálakat számolja, és **három eredménytelen kör után leáll**, majd embernek adja át, ahelyett hogy a javítás negyedik variációjával próbálkozna. A szám magától fogva tetszőleges; hogy van ilyen, az nem.

## Miért a tesztek az ügynökhurok igazságértékei

A hurok csak valamihoz tudja magát igazítani, amitől nem tud vitatkozni. Kódoló ügynököknél ez egy tesztfutás, egy fordító vagy egy típusellenőrző: a környezet kimenete, nem a modell véleménye a saját munkájáról.

A „Building effective agents” szerint az ügynököknek „minden lépésben igazságértékre van szükségük a környezetből (például eszközhívás eredményére vagy kódfuttatásra)”. A gyakorlatban ez két szabályt jelent. Az ügynök maga futtatja a teszteket, a hurkon belül, és elolvassa a kimenetet. És a teszteknek tudniuk kell bukni. Simon Willison [piros/zöld TDD mintája](https://simonwillison.net/guides/agentic-engineering-patterns/red-green-tdd/) ezt kimondja: „Ha kihagyod ezt a lépést, már zölden átmenő tesztet építhetsz.” Saját szabályom a hibajavításra szigorúbb: a regressziós tesztnek a javítással át kell mennie, és el kell buknia, ha _csak_ a javítást vonjuk vissza. Az a teszt, amely így is, úgy is átmegy, nem ad semmi támpontot a huroknak.

Az Anthropic [„Effective harnesses for long-running agents”](https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents) cikke (2025. november) ugyanezt nagyobb léptékben mutatja: egy JSON-ban futó feature-lista, amelyben minden feature `"passes": false` értékkel indul, sessionenként egy feature, és az utasítás, hogy „elfogadhatatlan a teszteket törölni vagy szerkeszteni”. Az általuk felsorolt hibaformák pontosan azok, amelyek gyenge ellenőrzésnél várhatók: a projekt túl korai befejezetté nyilvánítása, és a feature-ök end-to-end tesztelés nélküli lezárása. A modellt körülvevő teljes ellenőrző rendszer a [harness engineering](https://balazscsorba.com/hu/blog/harness-engineering-coding-agents) témája.

## Külső hurkok: Ralph, /loop és /goal

A külső hurok magát az ügynökhurokot indítja újra: sessionönkénti friss munkamenetet, egy ütemezést vagy egy minden forduló után ellenőrzött feltételt. Így órák munkát tudsz kivenni abból az ügynökből, amelynek egyetlen futása percek alatt véget ér.

### A Ralph technika

Geoffrey Huntley [„Ralph”](https://ghuntley.com/ralph/) technikája (2025. július) a legkisebb változat. A saját szavával: „Ralph egy bash hurok”:

Shell

```
while :; do cat PROMPT.md | claude-code ; done
```

Minden iteráció új ügynöksessiont indít ugyanazzal a prompttal. Az állapot nem a kontextusban, hanem a lemezen él: specifikációk és egy `fix_plan.md` a prioritás szerint rendezett fennmaradó munkával, amelyet az ügynök frissít. A központi szabálya „egy tétel egy hurokban”, mert „minél többet használod a kontextusablakot, annál rosszabb lesz az eredmény”. A minden módosítás után futó tesztek tartják tisztességben a hurkot. A határokról nyíltan szól: greenfield projektekhez illik, egy meglévő kódbázisban nem használná.

### Claude Code /loop és /goal

A Claude Code két session szintű külső hurkot szállít. Az [ütemezett feladatok dokumentációja](https://code.claude.com/docs/en/scheduled-tasks) szerint a `/loop` egy beépített skill, amely újrafuttat egy promptot, amíg a session nyitva marad. A `/loop 5m check the deploy` cron ütemezéssé alakítja az időközt (egységek: `s`, `m`, `h`, `d`, egyperces pontossággal). Ha van prompt, de nincs időköz, a Claude minden iteráció után egy és egy óra közötti késleltetést választ, és kiírja, hogy miért. Egy csupasz `/loop` beépített karbantartó promptot futtat: folytasd a befejezetlen munkát, ápold az aktuális ág pull requestjét, majd jönnek a takarító körök. Egy `.claude/loop.md` vagy `~/.claude/loop.md` felülírja ezt az alapértelmezett promptot.

A leállítási szabályok az érdekesek. Az ütemezett promtok csak fordulók között, a session üresjárata közben futnak le. Az `Esc` megállít egy saját tempójú hurkot, és a Claude maga is befejezheti, ha kész a munka. A rögzített időközű hurkok addig futnak, amíg le nem állítod őket, az ismétlődő feladatok pedig hét nap után lejárnak, ami „korlátozza, meddig futhat egy elfelejtett hurok”. Egy session legfeljebb 50 ütemezett feladatot tart.

A [`/goal`](https://code.claude.com/docs/en/goal) nem órával, hanem feltétellel dolgozik. Minden forduló után egy kicsi, gyors modell ellenőrzi, hogy a feltétel teljesül-e; ha nem, a Claude új fordulót indít. A cél teljesül, ha a feltétel megvan, ha az értékelő lehetetlennek ítéli, vagy ha egy olyan hibába ütközöl, amelyet javítani kell. Ha a Claude néhány fordulóban sorban nem használ eszközt, a Claude Code megállítja a hurkot, és visszaadja a vezérlést. A dokumentáció egyetlen mérhető végállapotot, egy megnevezett ellenőrzést és egy korlátot javasol, például „vagy 20 forduló után állj meg”.

Külső hurok

A következő iteráció akkor indul, ha

Kontextus iterációnként

Megáll, ha

Ralph (shell `while`)

Az előző session véget ér

Friss; az állapot fájlokban

Megállítod, vagy elfogy a terv

Claude Code `/loop`

Egy időköz letelik

Ugyanaz a session

Leállítod vagy megszakítod, a Claude befejezi, vagy hét nap múlva

Claude Code `/goal`

Az előző forduló véget ér

Ugyanaz a session

Az értékelő teljesülést vagy lehetetlenséget mond, vagy helyre nem hozható hiba

![Három egymásba ágyazott hurok: az eszközhurok a sessionben fut, a session hurkját pedig egy külső hurok indítja újra.](https://balazscsorba.com/images/blog/agent-loop-explained/diagram-31.webp?v=aa8a6476b6)

Hurkok a hurkokban: az eszközhurok egy sessionben fut, és egy külső hurok újraindítja vagy újrapromptolja a sessiont. Minden szintnek saját leállási feltétele kell.

Az alügynökök a hurkok beágyazásának másik módja. Egy orkestrator az Anthropic szavával „dinamikusan felbontja a feladatokat, átadja őket dolgozó LLM-eknek, és összefoglalja az eredményüket”. Minden dolgozó a saját hurkát futtatja a saját kontextusában, és csak egy összefoglalót ad vissza, így a szülő kontextusa kicsi marad. Hogyan mérődik ez le a szabályfájlokkal, a skillekkel és az eszközökkel, azt a [kontextuskeret-döntési mátrix](https://balazscsorba.com/hu/blog/agents-md-skills-mcp-cli-decision-matrix) tárgyalja.

## Mikor ne használj ügynökhurokot, és hogyan bukik el

Ne használj ügynökhurokot, ha már tudod a lépéseket. Egy rögzített munkafolyamat olcsóbb, gyorsabb és könnyebben tesztelhető. Az Anthropic tanácsa az, hogy „többlépéses agentikus rendszert csak akkor vezessünk be, ha az egyszerűbb megoldások már nem elegendők”.

Ha az ügynökhurok a megfelelő eszköz, akkor ezeken a módokon megy félre:

-   **Végtelen körben járás.** Ugyanannak a javításnak az újrapróbálása kis módosításokkal. Az ellenszer egy kemény iterációs limit és az előrehaladás-figyelés, nem egy jobb prompt.
-   **A kontextus felhízik.** Minden eszközeredmény az előzményben marad, és a minőség romlik, ahogy a kontextus nő. Huntley „egy tétel egy hurokban” szabálya és az iterációnkénti friss sessionök közvetlen válasz erre; ugyanúgy az alügynökök és a tömörítés.
-   **A teszt kijátszása.** Ha az egyetlen kiút az, hogy „zöldek a tesztek”, akkor a teszt szerkesztése rövidút a kiúthoz. Tiltsd le az utasításokban, védd ahol lehet a tesztfájlokat, és a teszt diffjét külön nézd át, nem együtt a kód diffjével.
-   **Túl korai győzelemhirdetés.** A modell befejezi a fordulóját, de maradt munka. A készről egy külső ellenőrzés dönt (egy értékelő, egy feature-lista, a CI), nem az ügynök.
-   **Korlátlan mellékhatások.** Azok a hurkok, amelyek pusholnak, deployolnak vagy posztolnak, megismételhetik a visszafordíthatatlan műveletet. Mindent, ami nyilvános vagy visszafordíthatatlan, ember hagy jóvá; a hurok előkészíti.

**A keret a kódba való, nem a promptba**

Az „állj meg 20 próbálkozás után” egy kérés. A `for turn in range(20)` garancia. Minden olyan korlát, amire valóban támaszkodsz, kerüljön abba a harnessbe, amelyik a hurkot futtatja.

## Ügynökhurok-ellenőrzőlista

1.  **Döntsd el, kell-e hurok egyáltalán.** Ha a lépések ismertek, írj munkafolyamatot.
2.  **Állíts be kemény limiteket a kódban:** maximális iterációk, token- vagy költségkeret és valós idő szerinti időlimit.
3.  **Definiáld az előrehaladást számmal** (bukó tesztek, nyitott szálak, hátra maradó tételek), és állj meg N eredménytelen kör után.
4.  **Adj igazságértéket a huroknak:** tesztek, típusok és linterek, amelyeket az ügynök maga futtat, plusz egy regressziós teszt, amely elbukik, ha a javítást visszavonjuk.
5.  **Tartsd az állapotot a lemezen,** ne csak a kontextusban: egy tervfájl, egy haladási napló, git commitok.
6.  **Egy tétel iterációnként** hosszú futásoknál, friss kontextussal vagy alügynökökkel a felderítéshez.
7.  **Tedd sandboxba az eszközfuttatót,** és adj neki szűk hatókörű, rövid életű hitelesítő adatokat.
8.  **Adj át embernek,** ha a hurok elakad, és minden nyilvános vagy visszafordíthatatlan lépés előtt.

A [kódoló ügynököm skilleiben](https://balazscsorba.com/hu/blog/coding-agent-skills-workflow) így működik a review-kör, és ugyanez a hurok jelenik meg megint, ha [az ügynök által írt pull requestek kezeléséről](https://balazscsorba.com/hu/blog/ai-generated-pr-review-bottleneck) van szó. Ha a saját csapatodnak tervezel ügynökhurkokat, nézd meg az [AI engineering](https://balazscsorba.com/hu/expertise/ai-engineer) oldalt.

## Források

1.  [Anthropic: Building effective agents (2024. december)](https://www.anthropic.com/engineering/building-effective-agents)
2.  [Yao et al.: ReAct: Synergizing Reasoning and Acting in Language Models (2022)](https://arxiv.org/abs/2210.03629)
3.  [Claude API dokumentáció: Handling stop reasons](https://platform.claude.com/docs/en/build-with-claude/handling-stop-reasons)
4.  [Anthropic: Effective harnesses for long-running agents (2025. november)](https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents)
5.  [Simon Willison: Red/green TDD (Agentic Engineering Patterns)](https://simonwillison.net/guides/agentic-engineering-patterns/red-green-tdd/)
6.  [Geoffrey Huntley: Ralph Wiggum as a "software engineer" (2025. július)](https://ghuntley.com/ralph/)
7.  [Claude Code dokumentáció: Run prompts on a schedule (/loop)](https://code.claude.com/docs/en/scheduled-tasks)
8.  [Claude Code dokumentáció: Keep Claude working toward a goal (/goal)](https://code.claude.com/docs/en/goal)

## Gyakori kérdések

Mi az MI-ügynök és a munkafolyamat között a különbség?

Egy munkafolyamatban a kódod előre meghatározza az LLM-hívások és az eszközhívások sorrendjét. Egy ügynökben a modell maga dönti el a következő lépést, a korábbi eszközhívások eredményei alapján, és addig megy tovább, amíg meg nem áll, vagy egy limit meg nem állítja. A munkafolyamatok olcsóbbak és könnyebben tesztelhetők, ezért csak akkor válassz ügynököt, ha a lépések nem ismerhetők előre.

Hogyan állítsam meg egy MI-ügynököt abban, hogy végtelenül körbe-körbe járjon?

Tegyél kemény limiteket a hurokot futtató kódba: egy maximális iterációszámot, egy token- vagy költségkeretet és egy valós idő szerinti időlimitet. Adj hozzá előrehaladás-figyelést is, például állj meg három olyan kör után, amelyben a bukó tesztek vagy a nyitott review szálak száma nem csökkent, és ott add át a feladatot egy embernek.

Mire való a Ralph hurok a kódoló ügynököknél?

Ralph egy technika, amelyet Geoffrey Huntley 2025. júliusában írt le: egy while hurok a shellben, amely újra és újra ugyanazt a promptfájlt adja át egy friss kódoló ügynöksessionnek. Az állapot fájlokban él, például specifikációkban és egy prioritás szerint rendezett javítási tervben, minden iteráció egy tételt visz előre, és a tesztek tartják tisztességben a munkát. Huntley greenfield projektekhez ajánlja, meglévő kódbázisokhoz nem.

Mit csinál a Claude Code /loop parancsa?

A /loop a Claude Code beépített skillje, amely újrafuttat egy promptot, amíg a session nyitva marad. 5m jellegű időközzel cron ütemezésként fut; időköz nélkül a Claude minden alkalommal egy és egy óra közötti késleltetést választ. Egy csupasz /loop beépített karbantartó promptot vagy a saját loop.md fájlodat futtatja. Az ismétlődő feladatok hét nap után lejárnak.

Mit jelent a pause\_turn a Claude API-ban?

A pause\_turn egy leállási ok: egy szerveroldali eszközhurok, mondjuk az API által futtatott webes keresés, elérte az iterációs limitjét, ami alapértelmezetten 10. Ez nem hiba. Küldd vissza az asszisztens tartalmát egy új kérésben, és a modell onnan folytatja, ahol abbahagyta.

Mit jelent a human in the loop egy MI-ügynöknél?

Azt, hogy egy ember átnézi vagy jóváhagyja az ügynökhurok bizonyos lépéseit, mielőtt azok érvénybe lépnek. Ez általában a következményekkel járó, visszafordíthatatlan vagy kifelé ható műveletekre vonatkozik, például üzenetküldésre, fizetésre, törlésre vagy mergere, míg az alacsony kockázatú lépések, például fájlok olvasása vagy tesztek futtatása felügyelet nélkül mennek. A kódban ez egy szünet: a tool-hívás megáll, az ember jóváhagyja, módosítja vagy elutasítja, és a hurok ezzel a döntéssel mint tool-eredménnyel folytatódik.

Írta: Csorba Balázs

Senior fullstack és AI mérnök Stájerországban – több mint 10 év Vue, Nuxt, Node.js és PHP, ma AI-ügynököknek építek eszközöket.

[AI fejlesztés és MCP szerverek →](https://balazscsorba.com/hu/expertise/ai-engineer)[Rólam →](https://balazscsorba.com/hu/about)

## További cikkek

-   [Claude az OpenCode-ban: a Claude Agent szolgáltató, az API-kulcsok és a többi út](https://balazscsorba.com/hu/blog/claude-in-opencode)
-   [A Claude Code Review általánosan elérhető: hogyan működik és mibe kerül](https://balazscsorba.com/hu/blog/claude-code-review)
-   [Claude skillek: így írjon SKILL.md fájlt, amely a megfelelő pillanatban töltődik be](https://balazscsorba.com/hu/blog/claude-skills-guide)
-   [Legacy kódbázis migrálása coding agentekkel: strangler fig playbook](https://balazscsorba.com/hu/blog/coding-agents-legacy-codebase-migration)

## Pont erre van szükséged?

Írj a projektedről vagy a pozícióról – szívesen hallok felőled.

[Lépj velem kapcsolatba](mailto:contact@balazscsorba.com) [Kapcsolódjunk LinkedInen](https://www.linkedin.com/in/balazs-csorba)