Как заставить кодирующего агента учиться на ошибках: методика выхода из циклов «fail → retry»

Когда ваш AI-агент тупит в бесконечном цикле

Вы видели это сотни раз. Агент получает задачу, пишет код, запускает, получает ошибку. Переписывает код почти идентично, снова ошибка. И так по кругу, пока не кончатся токены или ваше терпение. Это не баг – это фундаментальная проблема архитектуры большинства кодирующих агентов на 2026 год.

Современные агенты на базе GPT-5, Claude 4 или специализированных моделей вроде Qwen3.5-Coder-32B умеют генерировать красивый код, но не умеют учиться на провалах. Каждая попытка для них – первый день в школе. Они забывают, что уже пробовали, не понимают причину провала, просто бьются головой об стену.

Почему «fail → retry» – это тупиковая архитектура

Давайте разберем типичный сценарий. Агенту нужно написать функцию парсинга JSON с вложенными структурами. Первая версия:

def parse_deep_json(data):
    return json.loads(data)

Ошибка: JSONDecodeError из-за невалидных данных. Агент генерирует второй вариант:

def parse_deep_json(data):
    try:
        return json.loads(data)
    except:
        return {}

Ошибка: теперь функция молча глотает ошибки, что недопустимо. Третий вариант, четвертый... Каждый раз агент реагирует на симптом, но не анализирует корневую причину. Это как лечить кашель при туберкулезе сиропом от горла.

Строим систему, которая запоминает провалы

Методика основана на трех китах: извлечение, хранение и применение уроков из ошибок. Не просто «запомни, что не сработало», а «понимай, почему не сработало и какие фиксы помогают».

Я тестировал это на фреймворках вроде LangChain и собственных агентах. Результат: сокращение циклов с 8-12 до 1-3. Экономия токенов – 40-70%. Скорость решения задач из SWE-bench выросла в 2.5 раза.

1 Ловим ошибку и вытаскиваем из нее душу

Первое – перестать просто показывать агентам traceback. Нужно разобрать ошибку на компоненты:

• Тип ошибки: не просто «ошибка», а конкретный класс (TypeError, ValueError, ImportError)
• Контекст: какая часть кода вызвала проблему, с какими данными
• Корневая причина: не «файл не найден», а «путь вычисляется относительно рабочей директории, а не директории скрипта»
• Уже пробованные решения: что агент уже пытался сделать и почему это не сработало

Вот как выглядит плохой подход (90% разработчиков так и делают):

# ПЛОХО: просто передаем ошибку агенту
error_message = str(e)
context.append(f"Ошибка: {error_message}")

А вот как надо:

# ХОРОШО: анализируем и структурируем
from typing import Dict, Any
import traceback

def extract_error_insight(error: Exception, code_context: str, attempt: int) -> Dict[str, Any]:
    """Извлекаем структурированную информацию из ошибки"""
    tb = traceback.extract_tb(error.__traceback__)
    
    insight = {
        "error_type": error.__class__.__name__,
        "error_message": str(error),
        "location": {
            "file": tb[-1].filename if tb else "unknown",
            "line": tb[-1].lineno if tb else 0,
            "function": tb[-1].name if tb else "unknown"
        },
        "code_snippet": code_context,  # Фрагмент кода, вызвавший ошибку
        "root_cause_hypothesis": generate_root_cause_hypothesis(error, code_context),
        "attempt_number": attempt,
        "timestamp": datetime.now().isoformat(),
        "working_fixes": []  # Будем заполнять позже, когда найдутся рабочие решения
    }
    return insight

2 Строим базу знаний, а не мусорную свалку

Хранить ошибки в списке – бесполезно. Нужна семантическая поисковая система. К 2026 году есть два рабочих варианта:

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

# Пример структуры записи в базе знаний
error_knowledge_entry = {
    "id": "err_python_import_relative_2026_001",
    "error_patterns": [
        "ModuleNotFoundError: No module named '..utils'",
        "ImportError: attempted relative import with no known parent package"
    ],
    "root_cause": "Попытка относительного импорта из скрипта, запущенного как main, а не как модуль",
    "context_tags": ["python", "import", "relative-import", "__main__"],
    "working_solutions": [
        {
            "solution": "Использовать sys.path.append для добавления родительской директории",
            "code": "import sys, os\nsys.path.append(os.path.dirname(os.path.dirname(__file__)))",
            "effectiveness_score": 0.95,  # Насколько часто это решение работает
            "applicability_conditions": "Когда файл запускается напрямую, а не импортируется"
        },
        {
            "solution": "Использовать абсолютные импорты через package structure",
            "code": "from mypackage.utils import helper",
            "effectiveness_score": 1.0,
            "applicability_conditions": "Когда проект имеет структуру пакета с __init__.py"
        }
    ],
    "failed_attempts": [
        "Попытка использовать from .. import utils без правильной структуры пакета",
        "Добавление __init__.py в текущую директорию (не работает для родительских директорий)"
    ],
    "usage_stats": {
        "times_encountered": 47,
        "times_resolved": 45,
        "last_encountered": "2026-03-15T14:30:00Z"
    }
}

3 Интеграция в цикл агента: проверяй, прежде чем снова биться головой

Теперь встраиваем систему в рабочий процесс агента. Алгоритм:

1. Агент получает ошибку после выполнения кода
2. Система анализирует ошибку и ищет в базе знаний похожие случаи (семантический поиск + фильтр по контексту)
3. Если находим записи с эффективными решениями – предлагаем агенту их применить первыми
4. Если решения нет – агент генерирует свое, мы сохраняем результат (работает/не работает)
5. Обновляем статистику использования для каждой записи

class LearningAwareCodingAgent:
    def __init__(self, llm, knowledge_base):
        self.llm = llm  # Современная LLM типа GPT-5 или Claude 4
        self.kb = knowledge_base
        self.error_history = []
        
    def execute_with_learning(self, code: str, task_description: str):
        max_attempts = 5
        
        for attempt in range(max_attempts):
            try:
                # Выполняем код
                result = self._execute_code(code)
                return result
                
            except Exception as e:
                # 1. Анализируем ошибку
                insight = extract_error_insight(e, code, attempt)
                
                # 2. Ищем в базе знаний
                similar_errors = self.kb.search_similar_errors(insight)
                
                # 3. Если есть рабочие решения – используем их
                if similar_errors and similar_errors[0]['working_solutions']:
                    best_solution = self._select_best_solution(similar_errors[0])
                    code = self._apply_solution(code, best_solution)
                    
                    # Записываем, что это решение было применено
                    self.kb.record_solution_attempt(
                        error_id=similar_errors[0]['id'],
                        solution_applied=best_solution,
                        success=None  # Узнаем на следующей итерации
                    )
                    
                else:
                    # 4. Нет решений в базе – генерируем новое через LLM
                    prompt = self._build_debug_prompt(code, e, attempt)
                    new_code = self.llm.generate(prompt)
                    
                    # Проверяем, не похоже ли на уже провальные попытки
                    if self._is_similar_to_failed_attempt(new_code, insight):
                        # Пропускаем эту попытку, сразу генерируем другую
                        continue
                        
                    code = new_code
                    
                # 5. Сохраняем историю для будущего анализа
                self.error_history.append(insight)
                
        raise MaxAttemptsExceededError(f"Не удалось решить после {max_attempts} попыток")

Ошибки, которые вы гарантированно совершите (и как их избежать)

Самая коварная ошибка – давать агенту доступ к базе знаний без ограничений. Он начнет подбирать решения наугад, как студент перед экзаменом. Нужен приоритетный лист: сначала проверяем решения с эффективностью выше 0.9, потом ниже, потом генерируем новые.

Вопросы от тех, кто уже горел на циклах

Что будет через год с такими системами

К 2027 году, по моим прогнозам, мы увидим кросс-агентные базы знаний. Ваш агент на Qwen3.5 будет учиться на ошибках, которые совершил чужой агент на GPT-5. Появятся открытые репозитории с шаблонами ошибок и фиксами, как сейчас есть репозитории с Docker-образами.

Уже сейчас в продвинутых фреймворках вроде LangSmith (актуальная версия на 2026) есть зачатки такой функциональности – трейсинг цепочек, анализ ошибок, но до полноценной обучающейся системы еще далеко.

Мой совет: начните с простой SQLite-базы сегодня. Через месяц у вас будет собственная система, которая делает агента на 30% эффективнее. Через полгода вы перестанете видеть бесконечные циклы «fail → retry» в логах. А через год будете смеяться над тем, как вы вообще работали без этой системы.

Подписаться на канал