Как заставить ИИ-агента доводить задачу до конца: loops в Claude Code

Применить: за 30 минут · Экономит: недельный лимит подписки, сгорающий за одну сессию · Уровень: средний · Чтение: ~35 минут

Что узнаешь:

• 4 типа loops с готовыми командами (/goal, /loop, /schedule) - когда какой брать, одной таблицей и деревом решений
• Рецепт первого цикла за 30 минут: цель, стоп-условие, модель-судья - копипаст-реди
• 6 правил Anthropic по управлению токенами и разбор кейса, где 4 млн токенов сгорели меньше чем за 5 минут
• 7 ошибок, из-за которых цикл крутится вечно, «улучшает» одно и то же или жжёт бюджет
• Как агент помнит, что делал вчера: progress-файл плюс git-история вместо памяти между сессиями
• Где гонять десятки прогонов модели за одну задачу без лимитов подписки и по цене от 0.011 ₽ за 1000 токенов

Главное. Агент бросает задачу на полпути, потому что в обычном режиме он сам решает, когда закончить, и это решение регулярно расходится с твоим. Цикл (loop) снимает выбор с модели и вешает его на внешнее стоп-условие: «цель достигнута» или «попытки кончились». Типов loops для ИИ-агентов четыре, и отличаются они тем, чем запускаются и чем останавливаются: пошаговый, целевой /goal, по расписанию /loop и проактивный. Дальше - готовые команды под каждый, рецепт первого цикла за 30 минут и то, как не спалить лимит подписки одной разогнавшейся сессией.

Ты дал агенту задачу, он написал половину, отрапортовал «готово» и остановился. Тесты красные, фича не доделана, а модель уверена, что справилась. Знакомо? Второй сценарий хуже: агент вошёл во вкус, начал рекурсивно плодить саб-агентов и за пять минут сжёг недельный лимит подписки. Один пользователь Claude Code так и написал в баг-репорте: 4 миллиона токенов улетели в трубу почти мгновенно, восстановить из них было нечего.

Обе беды - про одно и то же. Про то, кто и по какому признаку решает, что работа закончена. Через единый API provod.ai каждый день работают тысячи пользователей и команд, и в агентных пайплайнах картина повторяется: либо агент недорабатывает, либо перерабатывает до сожжённого баланса. Лечится это одним - правильно собранным циклом со стоп-условием, которое решает за агента, когда закончить. Я разберу все 4 типа loops для ИИ-агентов, которые есть в Claude Code, с дословными командами и дам рецепт первого цикла за полчаса. Отдельно покажу, где в цикле дешёвая модель делает механику, а дорогая судит результат: на этой связке экономится основной счёт.

Что такое loop и почему агент бросает задачу на полпути?

Главное. Loop - это агент, который повторяет циклы работы, пока не сработает условие остановки. Формула простая: собрал контекст, сделал шаг, проверил результат, повторил или остановился. Агент бросает задачу на полпути в обычном режиме, потому что там стоп-условие субъективное: модель сама судит, что «уже хватит». Цикл выносит это решение наружу и делает проверяемым.

Определение дала команда Claude Code в блоге Anthropic:

«Циклы (loops) - это агенты, повторяющие циклы работы, пока не выполнится условие остановки».

• Delba de Oliveira и Michael Segner, команда Claude Code, блог Anthropic, «Getting started with loops», 7 июля 2026, перевод с английского.

Разберём по-человечески. Представь термостат. Он мерит температуру, включает нагрев, снова мерит, и так по кругу, пока в комнате не станет 22 градуса. Как только цель достигнута, он выключается.

Агентный цикл устроен так же: контекст - действие - проверка - решение продолжать или стоп. Разница только в том, что вместо градусов у агента может стоять «тесты зелёные», «Lighthouse-скор 90», «очередь задач пуста».

Вот в чём корень боли. В самом простом режиме работы с Claude Code стоп-условие звучит так: «Claude решает, что задача выполнена или ему нужен дополнительный контекст». Модель сама себе судья. И её представление о «готово» постоянно не совпадает с твоим: она видит, что написала функцию, и считает дело сделанным, а ты ждал, что она ещё и прогонит тесты. Отсюда и «сдался на полпути» - агент не сдался, он просто по своему внутреннему критерию решил, что финиш уже здесь.

Цикл лечит это тем, что критерий выхода задаётся снаружи и проверяется объективно. «Остановись, когда Lighthouse-скор станет 90 или выше» - здесь критерий внешний: число либо достигнуто, либо нет. Ту же логику Anthropic формулировала ещё в 2024 году, когда разделяла воркфлоу и агентов:

«Агенты - системы, где LLM динамически управляют собственным процессом и использованием инструментов, сохраняя контроль над тем, как они решают задачи».

• Erik Schluntz и Barry Zhang, Anthropic, «Building Effective Agents», 19 декабря 2024, перевод с английского.

Ключевое слово тут - «динамически». Агент сам выбирает следующий шаг, и это его сила и его слабость одновременно. Сила - он адаптируется. Слабость - без внешней рамки он адаптируется куда попало, в том числе останавливается раньше времени или крутит один и тот же неудачный подход. Рамка и есть цикл: она оставляет агенту свободу в том, как решать, но забирает у него право решать, когда закончить. Дальше я покажу четыре способа задать эту рамку и то, чем они друг от друга отличаются.

Какие бывают loops: чем отличаются 4 типа?

Главное. Типов четыре, и различает их две вещи: чем цикл запускается и чем останавливается. Пошаговый цикл запускает твой промпт, останавливает - решение модели. Целевой /goal запускаешь ты, останавливает достигнутая цель или лимит попыток. Цикл по расписанию /loop запускает таймер, останавливает - завершённая работа. Проактивный запускает событие без тебя, а сама рутина работает, пока ты её не выключишь. Бери самый простой из тех, что закрывает задачу.

Команда Claude Code классифицирует loops для ИИ-агентов по четырём осям: чем запускается, чем останавливается, какой примитив Claude Code под этим лежит и под какой тип задач подходит. Свёл всё в одну таблицу.

Тип цикла	Чем запускается	Чем останавливается	Примитив / команда	Под какие задачи
Пошаговый (turn-based)	Обычный промпт пользователя	Модель сама судит, что задача решена или нужен контекст	Стандартный режим чата	Короткие разовые задачи вне регулярных процессов
Целевой (goal-based)	Ручной промпт в реальном времени	Цель достигнута ИЛИ исчерпан лимит ходов	Команда /goal	Задачи с проверяемым критерием выхода
По расписанию (time-based)	Заданный временной интервал	Ты отменяешь ИЛИ работа завершена (PR смёржен, очередь пуста)	Команды /loop, /schedule	Повторяющаяся работа, взаимодействие с внешними системами
Проактивный (proactive)	Событие или расписание, без человека в реальном времени	Каждая задача выходит по своей цели; сама рутина работает, пока не выключишь	Событие + расписание + цель	Потоки чётко определённой работы: баг-репорты, триаж, миграции, апгрейды зависимостей

Смотри на первые две колонки - в них вся суть. По мере движения сверху вниз у тебя всё меньше ручного контроля и всё больше автономии. Пошаговый цикл дёргаешь ты каждым сообщением. Целевой ты запускаешь один раз и ждёшь результата. Расписание крутится само по таймеру. Проактивный вообще живёт без тебя и реагирует на события в мире.

Как выбрать? Не усложняй раньше времени. Команда Claude Code прямо предупреждает: не всем задачам нужны сложные loops, начинай с простого решения и применяй эти паттерны выборочно. Тот же принцип из «Building Effective Agents»: «находите максимально простое решение и увеличивайте сложность только тогда, когда это необходимо». Пройди по дереву решений сверху вниз.

КАКОЙ LOOP ВЗЯТЬ - 4 вопроса

1. Задача разовая и решается за пару ходов?
   ├─ ДА  → пошаговый цикл (просто промпти, ничего не оборачивай)
   └─ НЕТ → вопрос 2

2. Есть ли у задачи проверяемый критерий выхода
   (число, зелёные тесты, булев признак)?
   ├─ ДА  → целевой цикл /goal (цель + лимит попыток)
   └─ НЕТ → сначала придумай критерий, иначе цикл не сойдётся

3. Работу надо повторять по времени или ждать
   внешнее событие (новый PR, письмо в очереди)?
   ├─ ДА  → цикл по расписанию /loop или /schedule
   └─ НЕТ → хватит /goal

4. Рутина должна работать без тебя в реальном времени
   и реагировать на поток событий?
   ├─ ДА  → проактивный цикл (но сначала обкатай на /goal)
   └─ НЕТ → остаёшься на /goal или /loop

Дерево читается за минуту, а экономит часы. Самая частая ошибка новичка - взять проактивный цикл под задачу, которой хватило бы одного /goal. Это как забивать гвоздь подъёмным краном. Разберём каждый тип по отдельности, начиная с самого простого.

Как работает turn-based цикл и когда его хватает?

Главное. Пошаговый цикл (turn-based) - это обычный режим чата с Claude Code, где каждый твой промпт запускает один «ход»: модель собирает контекст, действует, проверяет и решает, закончить или спросить тебя. Стоп-условие тут субъективное - модель судит сама. Этого хватает для коротких разовых задач. Чтобы не жечь лишние ходы, пиши конкретные промпты и выноси проверку в skills.

Ты уже пользуешься пошаговым циклом, даже если не называл его так. Каждый раз, когда ты пишешь Claude Code «почини этот баг» и он читает файлы, правит код и отвечает, - это один оборот цикла. Триггер - твой промпт. Стоп-условие - момент, когда «Claude решает, что задача выполнена или нужен дополнительный контекст».

Механика внутри одного хода повторяет термостат из первого раздела. Модель собирает контекст: читает нужные файлы, смотрит структуру проекта. Делает шаг: пишет или правит код, запускает команду. Проверяет: смотрит на вывод, на ошибки. И дальше решает - продолжить в этом же ходе, отдать управление тебе или объявить задачу закрытой. Ты остаёшься в петле как рулевой: направляешь каждый следующий ход своим сообщением.

Когда этого хватает? Когда задача короткая, разовая и не входит в регулярный процесс. Поправить опечатку в конфиге, объяснить кусок кода, набросать функцию по описанию - тут городить /goal или расписание незачем. Пошаговый режим выигрывает простотой: полный контроль на каждом шаге, ноль риска, что агент убежит и что-то сожжёт, пока ты отвернулся.

Есть один рычаг, который экономит деньги прямо здесь. Команда Claude Code советует: «писать конкретные промпты и улучшать верификацию через skills, чтобы сократить число ходов». Перевожу на практику.

Каждый лишний ход - это лишний прогон модели, а значит лишние токены. Расплывчатый промпт «сделай нормально» заставляет агента гадать, переспрашивать и переделывать - три хода вместо одного. Точный промпт с критерием приёмки укладывается в один. А skill (переиспользуемая инструкция-навык) забирает на себя рутинную проверку, чтобы модель не тратила ход на «а как мне это протестировать».

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

Как довести метрику до цели командой /goal?

Главное. Целевой цикл /goal запускаешь ты одним промптом, а останавливается он сам по двум условиям: цель достигнута ИЛИ исчерпан лимит попыток. Работает только с проверяемой целью - числом или булевым признаком, который можно измерить снаружи. После каждого хода отдельная лёгкая модель-судья сверяет результат с целью, потому что исполнитель не должен проверять сам себя.

Целевой цикл - первый шаг к настоящей автономии. Ты формулируешь цель и потолок попыток, жмёшь ввод и уходишь. Дальше агент сам крутит контекст-действие-проверку, пока не добьётся цели или не упрётся в лимит ходов. Дословный пример из блога Claude Code:

/goal get the homepage Lighthouse score to 90 or above, stop after 5 tries.

Перевод: «/goal подними Lighthouse-скор главной страницы до 90 или выше, остановись после 5 попыток». Разберём эту команду по косточкам, в ней вся философия целевого цикла.

Первое - цель проверяемая. «Lighthouse-скор 90 или выше» это число, которое инструмент либо показывает, либо нет. Спор невозможен. Сравни с «сделай главную побыстрее» - тут финиша не существует, агент будет «улучшать» вечно.

Второе - стоп-условие двойное: «цель достигнута ИЛИ достигнуто максимальное число ходов». Пять попыток - это страховка от бесконечного цикла. Не вышло за пять - агент честно останавливается и говорит, где застрял, вместо того чтобы жечь бюджет до утра.

Теперь ключевая механика, которую легко проглядеть. После каждого хода Claude Code берёт твоё условие и транскрипт работы и отправляет их отдельной, лёгкой и быстрой модели-судье. Именно она выносит вердикт «цель достигнута / нет». Исполнитель свой результат не оценивает. Почему так - лучше всех сформулировал Addy Osmani:

«Модель, написавшая код, слишком снисходительна, оценивая собственную домашку».

• Addy Osmani, инженерный лидер Google Chrome, личный блог, «Loop Engineering», 7 июня 2026, перевод с английского.

Дай модели самой судить свою работу - и она найдёт причину считать её отличной уже на втором ходе. Вынеси суд наружу, отдельной модели с чётким критерием, - и цикл начинает реально двигаться к цели, а не хвалить себя. Механику отдельного судьи я подробно разберу в разделе про evaluator-optimizer, она заслуживает отдельного захода.

Под что брать /goal? Под всё, у чего есть измеримый финиш. Поднять покрытие тестами до 80%. Убрать все ошибки линтера. Довести время сборки ниже 30 секунд. Прогнать миграцию, пока все записи не сойдутся.

Общее правило: если ты можешь написать команду, которая возвращает «да» или «нет», - задача годится для целевого цикла. Не можешь - сначала придумай такую команду.

Здесь стоит держать в голове цену вопроса: /goal гоняет модель по многу раз за один запуск, и на подписке это быстро упирается в лимиты. Оплата по факту за токены в такой механике ведёт себя предсказуемее - об этом чуть ниже, в разделе про бюджет. Если хочется гонять десятки прогонов без оглядки на 5-часовое окно подписки, это ровно та задача, под которую заточен provod.ai с оплатой за токены в рублях.

Как запустить агента по расписанию: /loop и /schedule?

Главное. Цикл по расписанию запускает таймер, а не твой промпт: /loop 5m крутит задачу каждые 5 минут. Останавливается он, когда ты отменяешь его вручную или когда работа объективно завершена - PR смёржен, очередь пуста. Берут его под повторяющуюся работу и общение с внешними системами: следить за PR, чинить упавший CI, разгребать входящую очередь.

Расписание снимает с тебя роль будильника. Целевой /goal ты всё равно запускаешь руками в нужный момент. Цикл по расписанию сам просыпается по таймеру и делает проход. Дословный пример из блога:

/loop 5m check my PR, address review comments, and fix failing CI

Перевод: «/loop каждые 5 минут проверяй мой PR, обрабатывай комментарии ревью и чини падающий CI». Разложим, что тут происходит. 5m - интервал: агент просыпается каждые пять минут. На каждом проходе он смотрит состояние PR, находит новые комментарии ревьюера, вносит правки, глядит на статус CI и чинит красные джобы. И засыпает до следующего тика.

Стоп-условие тут другое, чем у /goal. Цикл по расписанию останавливается, когда «ты отменяешь, или работа завершена (PR смёржен, очередь пуста)». То есть у него два выхода: твоя ручная отмена и объективное завершение работы. Смёржили PR - чинить больше нечего, цикл гаснет сам. Это удобно: не надо помнить, что где-то крутится фоновый агент, он закроется, когда закроется задача.

Под что брать расписание? Под всё, что повторяется во времени или зависит от внешних событий. Мониторить очередь задач и разбирать входящее. Следить за PR и подхватывать ревью. Раз в час прогонять проверку здоровья сервиса. Синхронизировать данные с внешним API.

Общий признак - работа не заканчивается одним заходом, её надо делать регулярно, пока не отпадёт повод.

У расписания есть ловушка, о которой стоит знать заранее. Терминал должен оставаться включённым непрерывно, а у сессий есть предел по длительности. Пользователь truelinux1 в обсуждении релиза на Hacker News (2026) сформулировал это так: «Помните, что терминал должен оставаться включённым непрерывно, а сессии ограничены (например, максимум 3 дня)». Проще говоря: закрыл ноутбук - фоновый агент встал. Для серьёзной фоновой работы это гонят на постоянно включённой машине или сервере, а не на рабочем ноуте.

⚠️ Внимание. Слишком частый интервал - прямой путь к сожжённому бюджету. /loop 1m на задаче, которой хватило бы прохода раз в 15 минут, гоняет модель в 15 раз чаще без всякой пользы. Anthropic прямо советует: «не запускайте рутины чаще, чем нужно». Прежде чем ставить интервал, прикинь, как часто реально появляется новая работа, и ставь чуть реже. Пять минут против одной - это пятикратная разница в счёте за тот же результат.

Что такое proactive loops и правда ли без человека?

Главное. Проактивный цикл запускает событие или расписание без человека в реальном времени, а сама рутина работает, пока ты её не выключишь. Под него идут потоки чётко определённой работы: триаж баг-репортов, миграции, апгрейды зависимостей. «Без человека» - про запуск, а не про ответственность: за дизайн стоп-условий и проверку результата отвечаешь ты. Полностью необслуживаемым цикл на практике пока не бывает.

Проактивный цикл - вершина автономии в этой классификации. Триггер - «событие или расписание, без человека в реальном времени». Стоп-условие двухуровневое: «каждая задача завершается по достижении цели, а сама рутина работает, пока вы её не выключите». То есть внутри крутятся маленькие целевые циклы, каждый со своим финишем, а обёртка вокруг них живёт постоянно и ловит новые события.

Под что это берут? Команда Claude Code перечисляет прямо: «повторяющиеся потоки чётко определённой работы: баг-репорты, триаж issues, миграции, апгрейды зависимостей». Пришёл новый баг-репорт - проактивный цикл его подхватил, классифицировал, повесил метки, при простом случае сразу предложил фикс. Вышла новая версия зависимости - цикл проверил, обновил, прогнал тесты. Человек в момент срабатывания не нужен.

Именно этот режим породил громкую фразу, которую любят цитировать в постах про «loop engineering»:

«Я больше не промптю Claude. У меня работают loops».

• Борис Черны, глава Claude Code, цитата в пересказе третьих лиц (the-ai-corner.com, база cocodedk/loop-engineering, июнь 2026), на первоисточнике не подтверждена, перевод с английского.

Звучит красиво, но тут нужна честная сноска, и я её поставлю жирно. Слова Черны гуляют по блогам и постам в пересказе - прямой стенограммы с его собственного канала я не нашёл. Держи это как вектор настроения индустрии, а не как проверенную цитату. И главное - «без человека» относится к запуску, а не к ответственности.

Вот тут начинается спор, который стоит знать до того, как ты доверишь агенту прод. Инженер Denis Stetskov, автор блога techtrenches.dev, в своём разборе утверждает: даже внутри самой Anthropic инженеры вручную следят за дашбордами и вмешиваются, когда автономные системы сбоят.

«Часть про "оставить работать без присмотра" никогда не была реальной даже у компании, которая это продаёт».

• Denis Stetskov, techtrenches.dev, «The slot machine that codes», 23 июня 2026, перевод с английского.

Я склоняюсь к его трезвой позиции. Проактивный цикл убирает человека из момента запуска, но не из контура ответственности. Ты по-прежнему проектируешь стоп-условия, читаешь, что он наделал, и вмешиваешься при сбое.

Osmani подводит под это итог одной строчкой: «Стройте цикл. Оставайтесь инженером». Автономия про то, что рутину запускает событие, а не твой палец. И точно не про то, что можно уйти и забыть.

Как собрать свой первый цикл за 30 минут?

Главное. Начни с целевого цикла /goal под задачу с проверяемым финишем - это самый безопасный вход. Рецепт из пяти шагов: сформулируй измеримую цель, задай лимит попыток, отдели проверку от исполнения, обкатай на пилоте, только потом запускай большой прогон. Полчаса на сборку окупаются тем, что дальше рутина едет сама.

Не строй проактивный пайплайн с первого раза. Возьми одну задачу с чётким числовым или булевым финишем и оберни её в /goal. Вот пошаговый рецепт, по которому я бы собирал первый цикл.

1. Выбери задачу с проверяемым финишем. Формулируй его числом или булевым признаком: «поднять покрытие тестами до 80%», «убрать все предупреждения линтера». Критерий должен возвращать «да» или «нет» без спора.
2. Сформулируй цель одной строкой и добавь потолок попыток. Потолок - твоя страховка от бесконечного цикла и от сожжённого бюджета.
3. Отдели проверку от исполнения. Убедись, что критерий проверяется командой или отдельной моделью, а не мнением самого исполнителя. Тесты, линтер, скрипт - что-то объективное.
4. Обкатай на пилоте. Прогони цикл на маленьком куске - один модуль, одна папка. Посмотри, сколько ходов и токенов он съедает, не убегает ли в сторону.
5. Запусти большой прогон. Только когда пилот показал вменяемое поведение, отпускай цикл на весь проект.

Копипаст-реди старт под первую задачу выглядит так - подставь свою цель и лимит:

/goal подними покрытие тестами в папке src/utils до 80% или выше,
запускай npm test после каждой правки, остановись после 6 попыток.

Три вещи, которые делают эту команду рабочей. Цель измерима - 80% покрытия видит инструмент. Есть встроенная проверка - npm test после каждой правки, то самое объективное стоп-условие. Есть потолок - шесть попыток, дальше агент честно остановится. Меняешь папку, число и тестовую команду под свой стек - и получаешь свой первый цикл.

Почему пилот перед большим прогоном - не бюрократия. Anthropic ставит это отдельным правилом: «пилотируйте перед большим прогоном». Смысл в том, что на маленьком куске ты за пару минут увидишь, сколько цикл ест и куда его заносит, и потеряешь копейки, если что-то пойдёт не так. Обкатал на одном модуле - понял цену прохода - умножил на масштаб - принял решение. Это дешёвая страховка от дорогого сюрприза.

Заземлю на живом примере. Наш редакционный конвейер живёт ровно на такой механике: черновик статьи гоняется по циклу QA-проверок, пока чекеры не вернут ноль нарушений. Каждый чекер тут - объективное стоп-условие: нашёл длинное тире или канцелярит - вернул провал, цикл делает ещё проход правок. Ноль нарушений - цикл выходит. Никто не судит статью «на глаз в процессе»: критерий вынесен в скрипты, и цикл сходится к чистому тексту сам. Ровно тот же принцип, что в /goal с тестами, только вместо npm test - набор редакционных проверок.

Evaluator-optimizer: зачем циклу вторая модель-судья?

Главное. Evaluator-optimizer - паттерн, где одна модель генерирует результат, а вторая, отдельная, его оценивает в цикле. Он нужен, потому что модель-исполнитель слишком снисходительна к своей работе и без внешнего суда цикл копит ошибки вместо того, чтобы сходиться. Работает паттерн только при чётких критериях оценки. Для расплывчатых задач вроде «сделай лучше» отдельный судья не спасает - у цикла просто нет финиша.

Паттерн описали Anthropic ещё в 2024-м под именем evaluator-optimizer, или «генератор - оценщик». Идея на одну фразу: одна LLM пишет ответ, другая LLM его критикует, и они гоняют это по кругу, пока оценщик не скажет «годится». Внутри целевого цикла /goal роль оценщика формализована как та самая отдельная лёгкая модель-судья, что проверяет стоп-условие после каждого хода.

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

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

Anthropic сразу очертила, когда паттерн реально работает:

«Особенно эффективен, когда у нас есть чёткие критерии оценки и когда итеративное уточнение даёт измеримую пользу».

• Erik Schluntz и Barry Zhang, Anthropic, «Building Effective Agents», 19 декабря 2024, перевод с английского.

Два условия, и оба обязательны. Первое - чёткие критерии оценки. Судья должен уметь сказать «да» или «нет» по объективному признаку, а не по вкусу. Второе - итеративное уточнение даёт измеримую пользу: каждый проход реально приближает к цели, а обратная связь судьи содержательна. Классические примеры от Anthropic - литературный перевод (есть по чему сверять точность) и многораундовый поиск информации (видно, полон ли ответ).

А теперь обратная сторона, про которую забывают в восторге от автоматизации. Если критерия нет, отдельный судья только вредит. Задача «улучши этот код» не имеет финиша: судья каждый раз найдёт, к чему придраться, генератор каждый раз что-то поменяет, и цикл будет крутиться, пока не кончатся токены.

Практики на ralphable.com описали этот сценарий точно: агент «пытается решить задачу, проваливается, переоценивает и снова пробует тот же ошибочный подход, до бесконечности». Диагностика простая: если агент «работает» над одним шагом дольше 5 минут без ощутимого прогресса, ты, скорее всего, в таком зависшем цикле. Мораль: сначала критерий, потом судья. Судья без критерия - это машина для сжигания токенов.

Как не сжечь бюджет: стоп-условия и цена цикла в токенах?

Главное. Цикл гоняет модель по многу раз за задачу, поэтому цена растёт быстрее, чем при обычном чате. Anthropic даёт 6 правил: правильный примитив и модель под задачу, чёткие критерии успеха и остановки, пилот перед большим прогоном, скрипты для детерминированной работы, не чаще нужного, регулярная проверка расхода. Реальный кейс: баг с рекурсивным спавном саб-агентов сжёг 4 млн токенов меньше чем за 5 минут.

Цикл - это множитель. Один и тот же промпт в пошаговом режиме - это один прогон. В /goal с шестью попытками - до шести прогонов плюс шесть вызовов судьи. В расписании /loop 5m за сутки - под 288 срабатываний. Поэтому первое правило экономии - вообще не запускать цикл там, где хватит одного хода.

Anthropic собрала управление токенами в шесть правил. Держи их как чек-лист перед каждым запуском.

1. Выбирай правильный примитив и модель под задачу. Не оборачивай разовую задачу в расписание, не гоняй флагман там, где справится лёгкая модель.
2. Задавай чёткие критерии успеха и остановки. Без стоп-условия цикл не знает, когда закончить.
3. Пилотируй перед большим прогоном. Померь цену на маленьком куске.
4. Используй скрипты для детерминированной работы. Там, где хватит обычного кода, не зови LLM - это дорого и лишнее.
5. Не запускай рутины чаще, чем нужно. Интервал ставь по реальной частоте появления работы.
6. Регулярно проверяй расход. Смотри в дашборд usage, а не жди сюрприза в конце месяца.

Четвёртое правило экономит больше всех, а игнорируют его чаще всех. Половина шагов в типичном цикле - простые действия без всякого рассуждения: переименовать файлы, прогнать линтер, скопировать шаблон. Гнать на это модель - значит платить за токены там, где хватило бы трёх строк bash. Детерминированную работу отдавай скриптам, а модели оставляй то, что требует суждения.

Теперь про цену в цифрах. Вот прайс API Claude на вход и выход за миллион токенов.

Модель Claude (API)	Вход, $/MTok	Выход, $/MTok	Batch вход	Batch выход
Opus 4.8	5	25	2.50	12.50
Sonnet 4.6	3	15	1.50	7.50
Haiku 4.5	1	5	0.50	2.50

Данные: Anthropic, страница цен platform.claude.com, слепок на 8 июля 2026. MTok - это миллион токенов. Отдельно про кэш: попадание в кэш (cache hit) стоит 0.1x от базовой цены входа, то есть в 10 раз дешевле обычного входного токена. Для цикла это золото.

Агент на старте каждой сессии перечитывает одни и те же файлы - progress-заметки, git-лог, системную инструкцию. Это идеальный кандидат на кэширование: повторяющийся префикс промпта попадает в кэш и обходится в десять раз дешевле. По расчёту из документации Anthropic, часовая сессия на Opus 4.8 с 50 000 входных и 15 000 выходных токенов без кэша стоит $0.705, а с кэшированием 40 000 из 50 000 входных - $0.525.

А вот к чему приводит цикл без страховки. В репозитории anthropics/claude-code есть открытый баг-репорт: у одного пользователя весь пятичасовой лимит токенов тарифа Max 20x сгорел меньше чем за 5 минут, 4 миллиона токенов. Другой отчитался, что рекурсивный спавн саб-агентов сжёг свыше 50% его недельного лимита Max 20x. Причина - баг, при котором саб-агенты рекурсивно плодят сами себя на десятки уровней вложенности, игнорируя флаг, который должен это запрещать. Хуже всего, что при прерывании такой разогнавшейся цепочки весь промежуточный результат теряется: потрачены миллионы токенов, а извлечь из них нечего. Атрибуция: баг-репорт в репозитории anthropics/claude-code, июнь 2026.

🚨 Критично. Цикл без потолка попыток и без верхней границы саб-агентов способен сжечь недельный лимит подписки за одну сессию. Это единственная красная зона статьи. Всегда ставь лимит ходов в /goal, не запускай проактивные цепочки без обкатанного пилота и держи открытым дашборд расхода при первых прогонах. Точные числа 5-часового и недельного окна Anthropic официально не публикует, но кейс с 4 млн токенов показывает порядок риска - это не гипотетика.

Про сами лимиты подписок - честно и без выдумок. Anthropic подтверждает только качественный факт: лимиты общие между Claude.ai и Claude Code. Точных чисел по 5-часовому и недельному окну для Pro и Max на официальных страницах нет, а цифры, что гуляют по агрегаторам, ничем не подтверждены, и я их приводить не буду.

История же такая: в июле 2025 Anthropic впервые ввела недельные рейт-лимиты именно из-за тех, кто гонял Claude Code круглосуточно. Представитель компании Amie Rotherham тогда объяснила это «беспрецедентным спросом с момента запуска». То есть категория пользователей, которых лимиты бьют больнее всего, - это ровно те, кто строит долгоживущие фоновые циклы.

7 ошибок, из-за которых цикл не сходится

Главное. Циклы разваливаются на предсказуемых вещах: нет стоп-условия, цель расплывчатая, взят не тот примитив, модель судит сама себя, агент лезет делать всё сразу, интервал слишком частый, нет пилота перед боевым прогоном. Ниже семь ошибок с парами «должно / не должно» - конкретные триггеры, из-за которых цикл крутится вечно или жжёт бюджет.

Ошибка 1. Запустить цикл без стоп-условия

Без потолка попыток и объективного критерия выхода цикл не знает, когда закончить, и крутится, пока не упрётся в лимит подписки. Разборы «loop engineering» формулируют жёстко: без ограничителей ты получаешь бесконечные циклы и биллинговые сюрпризы на порядки выше бюджета.
Не должно: запускать /goal или расписание без лимита ходов и проверяемого финиша.
Должно: задавать пару «критерий успеха + потолок попыток» до старта, всегда.

Ошибка 2. Расплывчатая цель для /goal

«Сделай код лучше» не имеет финиша - судья вечно найдёт, к чему придраться. Целевой цикл заточен под «tasks with verifiable exit criteria», задачи с проверяемым критерием выхода. Не зря пример из блога числовой: «Lighthouse-скор 90 или выше».
Не должно: формулировать цель словами без числа или булева признака.
Должно: переводить цель в измеримое условие, которое возвращает «да» или «нет».

Ошибка 3. Неправильный примитив под задачу

Вся классификация из четырёх типов построена вокруг подбора правильного примитива и модели под задачу (right primitive and model for the job). Обернуть разовую задачу в проактивный пайплайн - оверкилл; гонять регулярную фоновую работу вручную через пошаговый цикл - трата твоего времени.
Не должно: тянуть проактивный цикл туда, где хватит одного /goal.
Должно: пройти по дереву решений и взять самый простой подходящий тип.

Ошибка 4. Модель судит сама себя

Без отдельного этапа проверки цикл наращивает ошибки вместо того, чтобы сходиться. Osmani про это и говорил: «модель, написавшая код, слишком снисходительна, оценивая собственную домашку».
Не должно: оставлять оценку результата на той же модели, что его сделала.
Должно: выносить проверку в скрипт, тест, skill или отдельную модель-судью.

Ошибка 5. Пытаться сделать всё сразу

Агент склонен хватать слишком много за один заход и в итоге не доводит ничего. Инженеры Anthropic решили это правилом «работать только над одной фичей за раз» и назвали инкрементальность критически важной.
Не должно: давать циклу «перепиши весь модуль целиком» одним куском.
Должно: резать на маленькие шаги, по одной фиче или файлу за проход.

Ошибка 6. Слишком частый интервал в расписании

/loop 1m там, где работа появляется раз в полчаса, гоняет модель в 30 раз чаще без пользы. Anthropic прямо просит: «не запускайте рутины чаще, чем нужно».
Не должно: ставить минутный интервал «на всякий случай».
Должно: мерить реальную частоту появления работы и ставить интервал чуть реже неё.

Ошибка 7. Пропустить пилот перед боевым прогоном

Запустить непроверенный цикл сразу на всём проекте - значит узнать его цену и повадки на максимальном масштабе, когда откатывать дорого. Правило Anthropic: «пилотируйте перед большим прогоном».
Не должно: спускать свежесобранный цикл на весь репозиторий с первого раза.
Должно: обкатать на одном модуле, померить токены и поведение, потом масштабировать.

Как агент выживает между сессиями: progress-файл и git?

Главное. Долгоживущий агент работает дискретными сессиями, и каждая новая начинается без памяти о прошлой. Память ему заменяет харнесс - обвязка вокруг модели: файл claude-progress.txt с журналом сделанного плюс git-история. Сессия стартует с чтения этих заметок и логов, прогоняет базовый тест на старте и делает по одной фиче за заход. Это и превращает забывчивую модель в агента, который доводит большую задачу до конца.

Ключевую проблему назвал инженер Anthropic:

«Ключевая проблема долгоживущих агентов в том, что им приходится работать дискретными сессиями, и каждая новая сессия начинается без памяти о том, что было раньше».

• Justin Young, инженерный блог Anthropic, «Effective harnesses for long-running agents», 26 ноября 2025, перевод с английского.

Контекстное окно не бесконечно. Большую задачу нельзя сделать в один присест - агент упрётся в предел контекста, сессия кончится, и следующая начнётся с чистого листа. Модель не помнит, что делала вчера. Значит, память надо вынести наружу, в харнесс - обвязку вокруг модели из промптов, файлов состояния и скриптов.

Решение Anthropic держится на двух артефактах. Первый - файл claude-progress.txt, журнал того, что агенты уже сделали. Второй - git-история. Вместе они дают агенту способ быстро понять состояние работы, входя со свежим пустым контекстом. Заметки говорят «что и зачем», git-коммиты показывают «что именно изменилось в коде». Одно без другого работает хуже: заметки без коммитов - это слова без доказательств, коммиты без заметок - изменения без объяснения.

Настраивается это в самой первой сессии. Специальный промпт просит модель поднять начальное окружение: скрипт init.sh, файл claude-progress.txt под журнал и первый git-коммит. Дальше каждая рабочая сессия начинается одинаково - с фазы верификации:

СТАРТ КАЖДОЙ СЕССИИ АГЕНТА
1. Прочитать claude-progress.txt (что уже сделано и зачем)
2. Прочитать git log (какие изменения реально в коде)
3. Прогнать базовый тест на дев-сервере
   → поймать незадокументированные баги до начала работы
4. Взять СЛЕДУЮЩУЮ одну фичу из списка
5. Сделать её, закоммитить, дописать строку в progress-файл

Смысл фазы верификации - не поверить заметкам на слово. Агент начинает с чтения progress-файла и git-логов, а потом прогоняет базовый тест на дев-сервере, чтобы поймать баги, которые прошлая сессия не задокументировала. Реальность сверяется с записями до того, как агент начнёт что-то менять. Пропустишь этот шаг - агент построит новую работу поверх сломанного состояния и даже не заметит.

И последнее, самое важное правило этого харнесса - инкрементальность. Инженеры Anthropic попросили агента работать только над одной фичей за раз и назвали это критически важным для борьбы со склонностью модели делать слишком много за один заход. Одна фича - один коммит - одна строка в журнале. Так большая задача разбирается на цепочку маленьких проверяемых шагов, и каждый шаг оставляет след, по которому следующая сессия поднимет контекст. Забывчивая модель плюс аккуратный журнал плюс git дают в сумме агента, который помнит проект неделями.

Что loops НЕ решают: честные ограничения

Главное. Циклы не делают агента полностью автономным - бремя проверки результата остаётся на тебе. Они не помогают при расплывчатых задачах без критерия. Они не отменяют роста «долга понимания», когда код выпускается быстрее, чем ты успеваешь понять, что он делает. И они не бесплатны: чем больше автономии, тем выше риск неконтролируемых трат. Цикл - мощный инструмент, но инженера он не заменяет.

Первое ограничение - проверка. Osmani называет это прямо: «бремя верификации остаётся на тебе». Необслуживаемые циклы делают необслуживаемые ошибки. Цикл ускоряет производство результата, но кто-то всё равно должен смотреть, что он произвёл. Автоматизировать генерацию можно почти полностью, автоматизировать ответственность за результат - нет.

Второе - расплывчатые задачи. Цикл сходится только там, где есть проверяемый финиш. Дай ему «сделай красиво» или «улучши архитектуру» - и он либо остановится по своему субъективному ощущению (та самая исходная боль), либо будет бесконечно крутить один подход. Нет критерия - нет и пользы от цикла, как бы ты его ни настраивал.

Третье ограничение Osmani назвал «долгом понимания» - comprehension debt. Код выпускается быстрее, чем растёт твоё понимание того, что он делает. Ты запустил цикл, он за ночь наворотил тысячу строк, тесты зелёные - а разобраться, как оно устроено, ты не успел. Долг копится тихо и выстреливает, когда что-то ломается и надо чинить код, которого ты по сути не читал. Рядом стоит «когнитивная капитуляция» - опасность, когда циклы заменяют твоё суждение, а не дополняют его.

Четвёртое - деньги, и это не мелочь. Osmani предупреждает: «нужно обязательно следить за стоимостью токенов, паттерны расхода могут сильно различаться». Сам факт, что Anthropic отдельным правилом просит «проверять расход» и «пилотировать перед большим прогоном», говорит о реальном риске. Кейс с 4 млн токенов за 5 минут - иллюстрация того, во что обходится игнорирование этого риска.

И спорный вопрос напоследок, чтобы закрыть тему честно. Маркетинг вокруг проактивных циклов обгоняет собственную же рекомендацию Anthropic «начинать с простого и усложнять только когда это доказуемо улучшает результат». В 2026-м сложился целый жанр контента, где предлагают сразу строить многоагентные автономные пайплайны. Трезвая позиция проще: возьми /goal под одну проверяемую задачу, доведи до ума, и только потом думай про расписание и проактив. Osmani подводит черту: «Стройте цикл. Оставайтесь инженером».

Что дальше: где гонять циклы без лимитов подписки

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

Сделай прямо сейчас. Открой Claude Code, возьми одну задачу с измеримым финишем - поднять покрытие тестами, убрать предупреждения линтера, довести Lighthouse до 90 - и собери целевой цикл по рецепту из раздела про первый цикл за 30 минут:

/goal <твоя измеримая цель>, запускай <твою проверку> после каждой правки,
остановись после N попыток.

Обкатай на одном модуле, посмотри на расход, потом масштабируй. Полчаса - и у тебя первый рабочий цикл вместо агента, который бросает задачу на полпути.

Теперь про засаду, о которой я предупреждал весь текст. Цикл - это множитель: /goal с шестью попытками плюс шесть вызовов судьи, расписание /loop 5m под 288 срабатываний в сутки. Десятки прогонов модели за одну задачу упираются в 5-часовое и недельное окно подписки, и один разогнавшийся цикл способен сжечь недельный лимит за сессию. Оплата по факту за токены ведёт себя предсказуемее: платишь ровно за то, что прокрутил, без потолка, который обнуляется каждые пять часов.

Так работает provod.ai - российский аналог OpenRouter. Все флагманы (Claude Opus 4.8, GPT-5.5, Gemini 3.1 Pro, DeepSeek v4) в одном чате и через единый API, OpenAI- и Anthropic-совместимый. Claude Code, Cursor и n8n переезжают на него сменой baseURL и ключа, код проекта не трогаешь. Оплата по факту за токены в рублях, без недельных и 5-часовых лимитов, картой РФ, через СБП или по счёту с закрывающими документами для юрлица. Цены 1:1 с официалом, без наценки посредников.

И тут прячется главная экономия, ради которой стоит держать все модели на одном балансе. Первое правило Anthropic по токенам - «правильная модель под задачу». В цикле стадии разные по цене. Механическую работу - переписать по шаблону, разметить, прогнать простую правку - гони на дешёвой модели: deepseek-v4-flash стоит 0.011 ₽ на входе и 0.022 ₽ на выходе за 1000 токенов. А судью, который выносит вердикт по стоп-условию, ставь на тяжёлую: claude-opus-4.8 - 0.39 ₽ вход и 1.95 ₽ выход за те же 1000 токенов.

Модель	Роль в цикле	Вход, ₽/1000	Выход, ₽/1000
deepseek-v4-flash	механика, черновые проходы	0.011	0.022
claude-sonnet-4.6	генератор побольше	0.23	1.17
gemini-3.1-pro	средняя стадия	0.16	0.94
claude-opus-4.8	судья, тяжёлая проверка	0.39	1.95

Цены provod.ai, ₽ за 1000 токенов, 1:1 с официалом. Разница между дешёвой и дорогой моделью здесь в 35 раз на входе. Когда 90% ходов цикла - механика на flash, а на дорогого судью приходятся только финальные проверки, счёт за большой прогон падает в разы против варианта «гнать всё на флагмане». Переключается модель одним параметром в запросе - под каждую стадию цикла ставишь свою. Так правило «правильная модель под задачу» доводится до денег: собери первый цикл на provod.ai, раскидай стадии по моделям и плати по факту.

Была полезна статья? Да / Нет

Источники

1. Delba de Oliveira, Michael Segner, команда Claude Code - «Getting started with loops», блог Anthropic (определение loops, 4 типа, команды /goal и /loop, 6 правил по токенам) - 7 июля 2026
2. Justin Young - «Effective harnesses for long-running agents», инженерный блог Anthropic (дискретные сессии без памяти, progress-файл, git, инкрементальность) - 26 ноября 2025
3. Erik Schluntz, Barry Zhang - «Building Effective Agents», research Anthropic (агент vs воркфлоу, evaluator-optimizer, «start simple») - 19 декабря 2024
4. Anthropic - страница цен API platform.claude.com (Opus 4.8, Sonnet, Haiku, кэш 0.1x, пример расчёта сессии) - слепок на 8 июля 2026
5. support.claude.com - справка об использовании Claude Code с Pro/Max (лимиты общие между Claude.ai и Claude Code; точные числа окна не публикуются) - проверено 8 июля 2026
6. GitHub, репозиторий anthropics/claude-code, баг-репорт #68619 (4 млн токенов за 5 минут, >50% недельного лимита Max 20x, потеря промежуточного результата) - июнь 2026
7. Hacker News - обсуждение «Schedule tasks in a loop in Claude Code» (терминал должен быть включён, сессии ограничены) - 2026
8. Addy Osmani - «Loop Engineering», личный блог (снисходительность модели к своей работе, бремя верификации, долг понимания, «Build the loop. Stay the engineer.») - 7 июня 2026
9. Denis Stetskov - «The slot machine that codes», techtrenches.dev (критика «необслуживаемой» автономности) - 23 июня 2026
10. Ruben Dominguez, the-ai-corner.com, и база cocodedk/loop-engineering - цитата Бориса Черны в пересказе третьих лиц, на первоисточнике не подтверждена - июнь 2026
11. ralphable.com - практический гайд по диагностике зависших циклов (повтор одного подхода, признак «5 минут без прогресса») - март 2026
12. TechCrunch - о введении недельных рейт-лимитов Claude Code и комментарии Amie Rotherham - 28 июля 2025

Циклы гоняют модель десятки раз за задачу, и на подписке это первым делом бьёт по лимитам - поэтому механику дешевле держать на flash, а судью на opus, оплачивая по факту за токены. Все флагманы для этого лежат на одном балансе на provod.ai, с единым OpenAI- и Anthropic-совместимым API.

---

provod.ai — Russian LLM API aggregator. One OpenAI-compatible endpoint to all flagship models: OpenAI (GPT-5.6, GPT-5.5), Anthropic (Claude Opus 4.8, Sonnet 4.6), Google (Gemini 3.1 Pro, 3.5 Flash), DeepSeek V4 Pro, Qwen 3.6 Plus. Provider prices at the CBR rate, no token markup. Pay in rubles to a Russian legal entity with full closing documents.

Try: provod.ai · model catalog · docs