Рекурсивное самоулучшение AI-агентов — запускаешь /ratchet на ночь, утром код стал лучше

Рекурсивное самоулучшение AI-агентов — запускаешь /ratchet на ночь, утром код стал лучше

90% кода Claude Code написан самим Claude Code. Это не маркетинг — это факт из утёкших исходников. Recursive self-improvement уже происходит внутри Anthropic. А теперь такой же цикл доступен любому разработчику — бесплатно, open-source, и работает с Claude Code, Codex и любым LLM-клиентом.

TL;DR: Фреймворк recursive-improve добавляет трейсинг к вашему AI-агенту, анализирует паттерны ошибок, предлагает фиксы и проверяет результат. Команда /ratchet запускает цикл на автопилоте: улучшил → протестировал → оставил или откатил → повторил. На enterprise-бенчмарке tau2 — +25% за один цикл. Вдохновлено autoresearch Карпатого, который за 2 дня нашёл 20 улучшений и ускорил обучение GPT-2 на 11%.

Предыстория: Карпатый и рычаг, который крутится только вперёд

В марте Андрей Карпатый выложил autoresearch — простейший цикл: AI-агент правит код, запускает эксперимент на 5 минут, проверяет метрику. Стало лучше — коммит. Стало хуже — git reset. Повтор. Бесконечно.

За 2 дня на одной H100: 700 экспериментов, 20 выживших улучшений, бенчмарк "Time to GPT-2" с 2.02 до 1.80 часов — 11% ускорение на задаче, которую тысячи инженеров тюнят вручную. Одно из найденных улучшений — баг в собственном коде Карпатого (пропущенный скейлер в QKNorm), который автор не замечал месяцами.

CEO Shopify попробовал на внутренних данных: 37 экспериментов за ночь, +19% производительность модели. Результирующая модель на 0.8B параметров обогнала предыдущую на 1.6B.

Ключевая идея — ratchet (храповик). Механизм, который крутится только в одну сторону: каждое изменение либо улучшает результат и сохраняется, либо откатывается. Регрессий не бывает. Улучшения накапливаются автоматически.

Но autoresearch заточен под ML-эксперименты. А что если применить тот же принцип к любому AI-агенту?

recursive-improve: autoresearch для всех агентов

recursive-improve от Kayba.ai — open-source фреймворк (Apache 2.0), который приносит паттерн рекурсивного самоулучшения из ML-мира в повседневную разработку агентов. Работает с Claude Code, Codex CLI и любым LLM-клиентом через OpenAI, Anthropic или LiteLLM.

Идея: ваш агент оставляет трейсы (структурированные логи каждого LLM-вызова). Фреймворк анализирует эти трейсы, находит паттерны ошибок, предлагает фиксы и проверяет, что фиксы реально работают.

Как устроен цикл

Шесть стадий, каждая — отдельный шаг с проверкой:

1. Build Context — фреймворк сканирует архитектуру агента: системный промпт, инструменты, конфиги. Строит карту того, что можно менять.

2. Analyze Traces — читает JSON-трейсы из eval/traces/, находит повторяющиеся ошибки, упущенные возможности, зацикливания. Не просто "ошибка на строке 42", а паттерны: "агент сдаётся после второй неудачной попытки вместо смены стратегии".

3. Measure — запускает встроенные детекторы (бесконечные циклы, сдачи, ошибки восстановления) плюс генерирует кастомные метрики для вашего домена. Фиксирует baseline.

4. Plan — каждый найденный инсайт попадает в одну из трёх категорий: выбросить / правка кода / правка промпта. Приоритизация по ожидаемому импакту.

5. Review — план показывается разработчику на одобрение. Ничего не меняется без вашего "да".

6. Fix — одобренные изменения применяются на отдельной git-ветке. Каждый фикс привязан к конкретному инсайту и конкретной метрике.

Три команды, которые нужно запомнить

/recursive-improve — управляемый цикл. Вы видите каждый шаг, одобряете каждый фикс. Для первого раза и для критичных агентов.

/ratchet — автономный цикл в стиле autoresearch. Спрашивает, что оптимизировать, и дальше крутится сам: улучшение → запуск агента → оценка → оставить или откатить. Результаты — в eval/ratchet_summary.md. Запускаете вечером, утром читаете отчёт.

/benchmark — снимок метрик до и после. Хранит результаты в eval/benchmark_results.json, автоматически сравнивает с предыдущими прогонами. CLI-вариант: recursive-improve benchmark --label "v1-baseline".

Пошаговый пример: от установки до первого улучшения

1. Установка

uv tool install "recursive-improve[all] @ git+https://github.com/kayba-ai/recursive-improve.git"

Затем в папке проекта:

recursive-improve init

Это создаёт структуру eval/traces/ и файлы скиллов.

2. Добавить трейсинг — 2 строки кода

import recursive_improve as ri

ri.patch()  # перехватывает вызовы OpenAI, Anthropic, LiteLLM

with ri.session("./eval/traces") as run:
    result = my_agent("книга рейсов в Париж")
    run.finish(output=result, success=True)

ri.patch() — monkey-patch, который автоматически записывает каждый LLM-вызов. ri.session() — контекст-менеджер, который складывает структурированные JSON-трейсы в указанную папку.

Если у вас уже есть трейсы в другом формате — просто закиньте их в eval/traces/ и переходите к шагу 4.

3. Прогнать агента несколько раз

Запустите агента на типичных задачах 5-10 раз. Чем больше разных сценариев — тем больше паттернов найдёт анализ.

4. Запустить улучшение

Откройте Claude Code или Codex в папке проекта:

/recursive-improve

Фреймворк пройдёт все 6 стадий. На стадии Review покажет план: "нашёл 3 паттерна ошибок, предлагаю 2 правки кода и 1 правку промпта". Вы решаете, что применить.

5. Проверить результат

/benchmark

Сравнивает метрики до и после. Дашборд доступен через recursive-improve dashboard на localhost:8420.

6. Включить автопилот (опционально)

/ratchet

Дальше можно идти спать. Утром в eval/ratchet_summary.md будет список того, что улучшилось.

Что изменилось на tau2

Автор фреймворка протестировал на enterprise-бенчмарке tau2 (реальные задачи для продакшен-агентов, не синтетика). Один цикл /recursive-improve в полностью автономном режиме дал +25% производительности.

Для контекста: ручная оптимизация промптов и инструментов на том же бенчмарке обычно даёт 5-10% за итерацию, если повезёт. Фреймворк нашёл паттерны, которые человек пропускает, потому что они видны только при анализе десятков прогонов одновременно.

Куда это ведёт: от autoresearch до HyperAgents

recursive-improve — практический инструмент для сегодня. Но направление движется дальше.

Meta Research в марте опубликовала HyperAgents — агенты, которые модифицируют не только свой код задач, но и сам механизм самоулучшения. Мета-агент + таск-агент в одной редактируемой программе. Улучшения, найденные в одном домене, автоматически переносятся в другие — то, что обычный ratchet loop не умеет.

Это уже не оптимизация. Это агент, который учится лучше учиться. Пока только в песочнице и с кучей ограничений, но репозиторий открыт (2K+ звёзд), и исследователи явно относятся к безопасности серьёзно: sandbox, human approval gates, capability limits.

Подводные камни

Потолок креативности. Ratchet loop не может сделать шаг назад, чтобы потом прыгнуть дальше. Он находит инкрементальные улучшения, но пропускает архитектурные переделки. По данным DataCamp: "агент циклится через вариации того, что уже сработало, вместо того чтобы пробовать принципиально другой подход". Если вашему агенту нужна не шлифовка, а перестройка — ratchet не поможет.

Закон Гудхарта в действии. Агент оптимизирует метрику, а не реальную цель. Исследователи HyperAgents прямо предупреждают: "система будет усиливать и эксплуатировать любое смещение в метрике". Если ваш benchmark не отражает реальное качество — агент научится обманывать бенчмарк, а не улучшать работу. Чем точнее eval — тем полезнее цикл.

Это дорого. Каждый цикл /ratchet — это десятки запросов к LLM. Ночь работы Opus может стоить $20-100+ в зависимости от количества итераций и размера контекста. Один практик описал это как "brittle, flakey, and expensive — getting agents to stay on track for long stretches is no small feat". Начинайте с Haiku или Sonnet для первых экспериментов, не с Opus.

Требует инструментированного агента. Если ваш агент — чёрный ящик без трейсов, фреймворку нечего анализировать. ri.patch() работает с OpenAI, Anthropic и LiteLLM. Кастомные API-клиенты нужно обёртывать вручную или складывать трейсы в eval/traces/ самостоятельно.

Улучшения не всегда переносятся. +25% на tau2 не гарантирует +25% на ваших задачах. Бенчмарк — контролируемая среда. В продакшене входные данные разнообразнее, edge-кейсы злее, а пользователи непредсказуемее. Всегда проверяйте на своих сценариях.

Вердикт

Из трёх инструментов (autoresearch, recursive-improve, HyperAgents) для практического использования прямо сейчас подходит один — recursive-improve. Autoresearch заточен под ML-эксперименты, HyperAgents — исследовательский проект Meta. А recursive-improve — это skill для Claude Code, который ставится за 2 минуты и работает с любым Python-агентом.

Реальный эффект: если ваш агент уже работает и у вас есть хотя бы 10 прогонов с трейсами — один цикл /recursive-improve с высокой вероятностью найдёт 2-3 паттерна ошибок, которые вы не замечали. +25% на бенчмарке — верхняя граница; ожидайте 10-15% на реальных задачах. Но это 10-15% за одну ночь, без ручной работы. И каждый следующий цикл добавляет ещё.

Как попробовать

1. Установите фреймворк: uv tool install "recursive-improve[all] @ git+https://github.com/kayba-ai/recursive-improve.git" и recursive-improve init в папке проекта
2. Добавьте ri.patch() и ri.session() к вашему агенту — инструкция в README
3. Прогоните агента 5-10 раз на типичных задачах для сбора трейсов
4. Запустите /recursive-improve в Claude Code — посмотрите, какие паттерны найдёт. Одобрите или отклоните предложенные фиксы
5. Проверьте результат через /benchmark — сравните с baseline
6. Когда разберётесь — /ratchet на ночь, утром проверьте eval/ratchet_summary.md