0Pricing
AI Agents · Lekcja

Wykrywanie i przerywanie nieskończonych pętli

Limity maksymalnej liczby iteracji, wykrywanie powtarzających się działań i bezpieczniki pętli.

Wykrywanie i przerywanie nieskończonych pętli to bezpłatna lekcja AI Agents na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej AI Agents, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs AI Agents zawiera 4 lekcji w sumie.

Zagrożenie związane z pętlą nieskończoną

Agent uwięziony w pętli nieskończonej zużywa tokeny, blokuje zasoby i nie generuje użytecznych wyników. W środowisku produkcyjnym oznacza to bezpośrednio zmarnowane pieniądze i frustrację użytkowników.

Trzy mechanizmy współdziałają, aby zapobiegać pętlom nieskończonym: limity liczby iteracji, wykrywanie powtarzających się działań i limity czasu.

Mechanizm ochronny 1: Limit liczby iteracji

Najprostszym i najważniejszym mechanizmem ochronnym jest sztywny limit kroków. Każda pętla agenta musi go mieć. Po osiągnięciu limitu agent zwraca najlepszą dostępną w danym momencie odpowiedź albo jawny komunikat o błędzie.

MAX_ITERATIONS = 20

def run_agent(query: str) -> dict:
    history = []

    for step in range(1, MAX_ITERATIONS + 1):
        action = decide_action(query, history)

        if action['type'] == 'final_answer':
            return {'status': 'ok', 'answer': action['answer'], 'steps': step}

        result = execute_tool(action['tool'], action['args'])
        history.append({'step': step, 'tool': action['tool'], 'result': result})

    # Hard stop — max iterations reached
    return {
        'status': 'max_iterations_reached',
        'answer': None,
        'steps': MAX_ITERATIONS
    }

Mechanizm ochronny 2: Wykrywanie powtarzających się działań

Powtarzające się działania są charakterystyczną oznaką pętli nieskończonej. Należy śledzić historię par (tool_name, arguments). Jeśli ta sama para pojawi się więcej niż N razy, agent jest zablokowany — należy przerwać pętlę i wstrzyknąć komunikat o błędzie.

import hashlib
import json

def action_hash(tool_name: str, args: dict) -> str:
    payload = json.dumps({'tool': tool_name, 'args': args}, sort_keys=True)
    return hashlib.md5(payload.encode()).hexdigest()

def run_agent_with_repeat_detection(query: str) -> dict:
    history = []
    action_counts = {}

    for step in range(1, 21):
        action = decide_action(query, history)
        if action['type'] == 'final_answer':
            return {'status': 'ok', 'answer': action['answer']}

        key = action_hash(action['tool'], action['args'])
        action_counts[key] = action_counts.get(key, 0) + 1

        if action_counts[key] > 2:  # seen this exact action more than twice
            history.append({
                'role': 'system',
                'content': f'You have called {action["tool"]} with the same arguments {action_counts[key]} times. '
                           f'This approach is not working. Try a completely different strategy or state what you know so far.'
            })
            continue

        result = execute_tool(action['tool'], action['args'])
        history.append({'tool': action['tool'], 'result': result})

    return {'status': 'loop_detected', 'answer': None}

Śledzenie powtarzających się działań w oknie

Zamiast śledzić zliczenia ze wszystkich kroków, należy wykrywać powtórzenia w przesuwanym oknie obejmującym ostatnich N kroków. Pozwala to wykrywać pętle, które nieznacznie się zmieniają, ale cyklicznie powtarzają w krótkim okresie.

from collections import deque

def is_cycling(recent_actions: deque, window: int = 6) -> bool:
    if len(recent_actions) < window:
        return False

    # Check if the last window/2 actions repeat the first window/2
    half = window // 2
    first_half = list(recent_actions)[:half]
    second_half = list(recent_actions)[half:window]
    return first_half == second_half

# In the agent loop:
# recent_actions = deque(maxlen=6)
# recent_actions.append(action_hash(tool, args))
# if is_cycling(recent_actions):
#     print('Cycling detected — breaking loop')
#     break

recent = deque(['a', 'b', 'a', 'b'], maxlen=6)
print(is_cycling(recent, window=4))  # True — cycling detected

Mechanizm ochronny 3: Limit czasu rzeczywistego z użyciem signal.alarm

W systemach Unix signal.alarm() zgłasza SIGALRM po upływie określonej liczby sekund. Zapewnia to twardy limit czasu, nawet jeśli pętla agenta zostanie zablokowana w wolnym wywołaniu narzędzia.

import signal

class AgentTimeout(Exception):
    pass

def timeout_handler(signum, frame):
    raise AgentTimeout('Agent exceeded time limit')

def run_agent_with_signal_timeout(query: str, timeout_seconds: int = 60) -> dict:
    signal.signal(signal.SIGALRM, timeout_handler)
    signal.alarm(timeout_seconds)  # set the alarm

    try:
        result = run_core_agent_loop(query)
        signal.alarm(0)  # cancel the alarm on success
        return result
    except AgentTimeout:
        signal.alarm(0)
        return {'status': 'timeout', 'answer': None}
    except Exception as e:
        signal.alarm(0)
        raise

# Note: signal.alarm is Unix-only (Linux/Mac)

Limit czasu z użyciem threading.Timer (wieloplatformowy)

threading.Timer działa na wszystkich platformach, w tym w systemie Windows. Po upływie limitu czasu należy ustawić flagę — pętla agenta sprawdza tę flagę i kończy działanie, jeśli jest ustawiona.

import threading

def run_agent_with_timer_timeout(query: str, timeout_seconds: int = 60) -> dict:
    timed_out = threading.Event()

    def set_timeout():
        timed_out.set()

    timer = threading.Timer(timeout_seconds, set_timeout)
    timer.start()

    history = []
    try:
        for step in range(1, 21):
            if timed_out.is_set():
                return {'status': 'timeout', 'answer': None, 'steps': step}

            action = decide_action(query, history)
            if action['type'] == 'final_answer':
                return {'status': 'ok', 'answer': action['answer']}

            result = execute_tool(action['tool'], action['args'])
            history.append({'tool': action['tool'], 'result': result})

    finally:
        timer.cancel()  # always cancel if done before timeout

    return {'status': 'max_steps', 'answer': None}

Asynchroniczny limit czasu z użyciem asyncio.wait_for

W architekturach asynchronicznych agentów należy użyć asyncio.wait_for(coroutine, timeout=N). Zgłasza on asyncio.TimeoutError, jeśli korutyna nie zakończy się w określonej liczbie sekund.

import asyncio

async def run_async_agent(query: str) -> dict:
    history = []
    for step in range(1, 21):
        action = await async_decide_action(query, history)
        if action['type'] == 'final_answer':
            return {'status': 'ok', 'answer': action['answer']}
        result = await async_execute_tool(action['tool'], action['args'])
        history.append({'tool': action['tool'], 'result': result})
    return {'status': 'max_steps', 'answer': None}

async def run_with_timeout(query: str, timeout: float = 60.0) -> dict:
    try:
        return await asyncio.wait_for(run_async_agent(query), timeout=timeout)
    except asyncio.TimeoutError:
        return {'status': 'timeout', 'answer': None}

# asyncio.run(run_with_timeout('What is Python?', timeout=30.0))

Wstrzykiwanie instrukcji wyjścia do historii

Po wykryciu pętli nie należy po prostu po cichu jej przerywać. Należy wstrzyknąć do historii konwersacji komunikat systemowy wyjaśniający, co się stało, i proszący agenta o zakończenie zadania. Daje to LLM szansę na wygenerowanie odpowiedzi końcowej przed przerwaniem działania.

def inject_loop_escape(history: list, step: int, reason: str):
    message = (
        f'[SYSTEM] You have been running for {step} steps. Reason: {reason}. '
        f'You MUST now provide a FINAL_ANSWER based on what you have found so far, '
        f'even if the information is incomplete. Do not call any more tools.'
    )
    history.append({'role': 'system', 'content': message})

# In the agent loop, when approaching the limit:
# if step >= MAX_ITERATIONS - 2:
#     inject_loop_escape(history, step, 'approaching max iteration limit')

# Or when a repeat is detected:
# if action_counts[key] > 2:
#     inject_loop_escape(history, step, 'repeated action detected')

if __name__ == '__main__':
    demo_history = []
    inject_loop_escape(demo_history, step=18, reason='approaching max iteration limit')
    print(demo_history[-1]['content'])

Rejestrowanie przerwania pętli

Należy zawsze rejestrować moment zadziałania mechanizmu ochronnego pętli. Tworzy to zapis pokazujący, jak często i z jakiego powodu agenty się blokują — są to niezwykle cenne dane przy ulepszaniu promptów i implementacji narzędzi.

import logging

logger = logging.getLogger('agent_guard')

def check_and_break_loop(step: int, action_counts: dict, current_key: str) -> bool:
    count = action_counts.get(current_key, 0)

    if count > 2:
        logger.warning(
            f'Infinite loop detected at step {step}. '
            f'Action hash {current_key[:8]} seen {count} times. '
            f'Breaking loop.'
        )
        return True  # signal to break

    if step >= 18:  # approaching limit
        logger.warning(
            f'Approaching max iterations at step {step}. '
            f'Injecting escape prompt.'
        )

    return False

if __name__ == '__main__':
    import sys
    logging.basicConfig(level=logging.WARNING, format='%(message)s', stream=sys.stdout)
    demo_counts = {'search:{"q": "weather"}': 3}
    check_and_break_loop(step=10, action_counts=demo_counts, current_key='search:{"q": "weather"}')

Połączenie wszystkich trzech mechanizmów ochronnych

Agenty produkcyjne powinny łączyć wszystkie trzy mechanizmy ochronne: maksymalną liczbę iteracji (obowiązkowo), wykrywanie powtórzeń (wykrywa cykle) i limit czasu (wykrywa blokujące wywołania narzędzi). Razem zapewniają one niezawodne działanie pętli.

import threading
import hashlib
import json

def run_production_agent(query: str) -> dict:
    MAX_STEPS = 20
    TIMEOUT_SEC = 120

    timed_out = threading.Event()
    timer = threading.Timer(TIMEOUT_SEC, timed_out.set)
    timer.start()

    history = []
    action_counts = {}

    try:
        for step in range(1, MAX_STEPS + 1):
            if timed_out.is_set():
                return {'status': 'timeout'}

            action = decide_action(query, history)
            if action['type'] == 'final_answer':
                return {'status': 'ok', 'answer': action['answer']}

            key = hashlib.md5(json.dumps(action, sort_keys=True).encode()).hexdigest()
            action_counts[key] = action_counts.get(key, 0) + 1
            if action_counts[key] > 2:
                inject_loop_escape(history, step, 'repeat detected')
                continue

            result = execute_tool(action['tool'], action['args'])
            history.append({'tool': action['tool'], 'result': result})
    finally:
        timer.cancel()

    return {'status': 'max_steps'}

Testowanie mechanizmów ochronnych pętli za pomocą testów jednostkowych

Należy napisać dedykowane testy jednostkowe dla mechanizmów ochronnych pętli. Trzeba utworzyć mockowanego agenta, który zawsze wywołuje to samo narzędzie, i zweryfikować, że mechanizm ochronny wykrywa ten przypadek w oczekiwanej liczbie kroków.

from unittest.mock import MagicMock

def test_repeat_detection_breaks_loop():
    # Create a mock that always returns the same action
    always_same_action = MagicMock(return_value={
        'type': 'tool',
        'tool': 'search_web',
        'args': {'query': 'same query'}
    })
    always_success = MagicMock(return_value='some result')

    result = run_agent_with_repeat_detection(
        query='test',
        decide_action=always_same_action,
        execute_tool=always_success
    )

    # Should stop due to loop detection, not run all 20 steps
    assert result['status'] in ('loop_detected', 'max_iterations_reached')
    # Should not have run all 20 steps (loop should be detected by step 6-7)
    print('Loop guard test passed')

Sprawdzenie wiedzy: wykrywanie pętli nieskończonych

Sprawdź swoje rozumienie technik wykrywania i przerywania pętli nieskończonych.

Podsumowanie: wykrywanie i przerywanie pętli nieskończonych

Mogą Państwo teraz chronić agentów przed pętlami nieskończonymi za pomocą trzech uzupełniających się mechanizmów ochronnych:

  • Maksymalna liczba iteracji: sztywny limit kroków, obowiązkowy w każdej pętli agenta
  • Wykrywanie powtórzeń: obliczać skróty par (tool, args) i przerywać działanie, gdy pojawią się więcej niż N razy
  • Limit czasu: signal.alarm() w systemie Unix, threading.Timer na różnych platformach, asyncio.wait_for() w kodzie asynchronicznym
  • Wstrzykiwanie instrukcji wyjścia: dać agentowi szansę na zakończenie przed wymuszonym zatrzymaniem
  • Zawsze rejestrować moment zadziałania mechanizmu ochronnego — są to cenne dane przy ulepszaniu promptów

Często zadawane pytania

Czy lekcja „Wykrywanie i przerywanie nieskończonych pętli” jest bezpłatna?

Tak — pełny tekst „Wykrywanie i przerywanie nieskończonych pętli” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu AI Agents, przejdź na CoddyKit PRO. Kurs AI Agents zawiera 4 lekcji w sumie.

Co nauczysz się w „Wykrywanie i przerywanie nieskończonych pętli”?

Limity maksymalnej liczby iteracji, wykrywanie powtarzających się działań i bezpieczniki pętli. Ćwiczysz AI Agents z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć AI Agents?

Nie wymagamy żadnego doświadczenia. AI Agents w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Wykrywanie i przerywanie nieskończonych pętli”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji AI Agents?

Tak. Każda lekcja AI Agents zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Typowe awarie pętli agenta
  2. Logowanie śledzenia kroków agenta
  3. Wykrywanie i przerywanie nieskończonych pętli
  4. Techniki debugowania krok po kroku
← Powrót do AI Agents