0Pricing
AI Agents · Урок

Обнаружение и остановка бесконечных циклов

Ограничения числа итераций, обнаружение повторяющихся действий и автоматические прерыватели циклов.

«Обнаружение и остановка бесконечных циклов» — бесплатный урок AI Agents на CoddyKit. Это урок 3 из 4. Ты можешь прочитать весь урок бесплатно ниже — а потом практиковать его прямо в браузере с встроенным редактором кода и ИИ-репетитором 24/7. Это часть пути обучения AI Agents, и твой прогресс синхронизируется между веб-версией и приложением CoddyKit. Курс AI Agents содержит 4 уроков всего.

Угроза бесконечного цикла

Агент в бесконечном цикле расходует токены, блокирует ресурсы и не выдаёт полезного результата. В рабочей среде это напрямую приводит к напрасным расходам и недовольству пользователей.

Для предотвращения бесконечных циклов вместе работают три механизма: ограничение максимального числа итераций, обнаружение повторяющихся действий и ограничение времени ожидания.

Защитный механизм 1: ограничение числа итераций

Самый простой и важный защитный механизм — жёсткое ограничение числа шагов. Оно должно быть в каждом цикле агента. Когда предел достигнут, агент либо возвращает лучший из имеющихся ответов, либо явное сообщение о сбое.

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
    }

Защитный механизм 2: обнаружение повторяющихся действий

Повторяющиеся действия — характерный признак бесконечного цикла. Ведите историю пар (имя инструмента, аргументы). Если одна и та же пара появляется более N раз, агент завис — прервите цикл и добавьте сообщение об ошибке.

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}

Отслеживание повторяющихся действий в окне

Вместо подсчёта всех повторений за всё время обнаруживайте их в скользящем окне последних N шагов. Это позволяет выявлять циклы, которые немного изменяются, но повторяются за короткий период.

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

Защитный механизм 3: ограничение реального времени с помощью signal.alarm

В системах Unix signal.alarm() вызывает SIGALRM по истечении заданного числа секунд. Это обеспечивает жёсткое ограничение времени ожидания, даже если цикл агента заблокирован во время медленного вызова инструмента.

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)

Ограничение времени ожидания с помощью threading.Timer (для разных платформ)

threading.Timer работает на всех платформах, включая Windows. По истечении времени ожидания установите признак — цикл агента проверит его и завершит работу, если признак установлен.

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}

Асинхронное ограничение времени ожидания с помощью asyncio.wait_for

В асинхронных архитектурах агентов используйте asyncio.wait_for(coroutine, timeout=N). Если сопрограмма не завершится за указанное число секунд, будет вызвано asyncio.TimeoutError.

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))

Добавление инструкций для выхода из цикла в историю

При обнаружении цикла не прерывайте его молча. Добавьте в историю диалога системное сообщение с объяснением произошедшего и просьбой завершить работу. Так LLM получает возможность сформировать окончательный ответ до принудительной остановки.

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'])

Журналирование прерывания цикла

Всегда записывайте в журнал срабатывание защитного механизма цикла. Это создаёт историю того, как часто и почему агенты застревают, — бесценные данные для улучшения подсказок и реализации инструментов.

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"}')

Объединение всех трёх защитных механизмов

Агенты в рабочей среде должны использовать все три защитных механизма: ограничение числа итераций (обязательно), обнаружение повторений (выявляет циклы) и ограничение времени ожидания (выявляет блокирующие вызовы инструментов). Вместе они делают цикл чрезвычайно надёжным.

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'}

Проверка защитных механизмов цикла с помощью модульных проверок

Напишите отдельные модульные проверки для защитных механизмов цикла. Создайте имитацию агента, который всегда вызывает один и тот же инструмент, и убедитесь, что защитный механизм обнаруживает это за ожидаемое число шагов.

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')

Проверка знаний: обнаружение бесконечных циклов

Проверьте своё понимание способов обнаружения и прерывания бесконечных циклов.

Итоги: обнаружение и прерывание бесконечных циклов

Теперь Вы умеете защищать агентов от бесконечных циклов с помощью трёх взаимодополняющих защитных механизмов:

  • Максимальное число итераций: жёсткое ограничение шагов, обязательное в каждом цикле агента
  • Обнаружение повторений: вычисляйте хеш пар (инструмент, аргументы) и прерывайте цикл, если пара встречается более N раз
  • Ограничение времени ожидания: signal.alarm() в Unix, threading.Timer на разных платформах, asyncio.wait_for() для асинхронного выполнения
  • Добавление инструкции для выхода: дайте агенту возможность завершить работу до принудительной остановки
  • Всегда записывайте срабатывание защитного механизма в журнал — это ценные данные для улучшения подсказок

Часто задаваемые вопросы

Урок «Обнаружение и остановка бесконечных циклов» бесплатный?

Да — полный текст урока «Обнаружение и остановка бесконечных циклов» бесплатно доступен здесь в веб-версии. Чтобы практиковать его интерактивно (встроенный редактор кода и ИИ-репетитор 24/7) и разблокировать остальной курс AI Agents, подпишись на CoddyKit PRO. Курс AI Agents содержит 4 уроков всего.

Чему я научусь в уроке «Обнаружение и остановка бесконечных циклов»?

Ограничения числа итераций, обнаружение повторяющихся действий и автоматические прерыватели циклов. Ты практикуешь AI Agents с помощью реального кода, который запускаешь прямо в браузере, и ИИ-репетитор 24/7 отвечает на твои вопросы во время урока.

Нужен ли мне опыт, чтобы начать AI Agents?

Предыдущий опыт не требуется. AI Agents на CoddyKit структурирован для всех уровней — от новичков до продвинутых, поэтому ты можешь начать отсюда или с самого начала и учиться в своем темпе. Это урок 3 из 4.

Сколько времени занимает урок «Обнаружение и остановка бесконечных циклов»?

Большинство уроков CoddyKit занимают около 5–10 минут. Каждый из них компактный и интерактивный, поэтому ты постоянно делаешь прогресс и продолжаешь с того же места в веб-версии и приложении.

Можно ли писать и запускать код в этом уроке AI Agents?

Да. Каждый урок AI Agents включает встроенный редактор кода, поэтому ты пишешь и запускаешь реальный код прямо в браузере и получаешь моментальную обратную связь от AI — локальная установка не требуется.

Все уроки этого курса

  1. Распространённые сбои цикла агента
  2. Журналы трассировки шагов агента
  3. Обнаружение и остановка бесконечных циклов
  4. Методы пошаговой отладки
← Назад к AI Agents