Loop Engineering: как создавать агентов, которые совершенствуют свою работу

От ручного промптинга к инженерным циклам

Большинство людей всё ещё управляют AI-агентами вручную

Они вводят одну задачу

Ждут один ответ

Сами проверяют результат

Сами исправляют ошибки

Затем отправляют новый промпт

Человек всё ещё выполняет цикл

Следующий этап выглядит иначе

Вы перестаёте шаг за шагом давать указания агенту

Вы строите цикл вокруг него

Цикл даёт инструкции

Проверяет результат

Выбирает следующее действие

И продолжает работу, пока результат не соответствует стандарту

Это и есть инженерия циклов

Идея проста

Перестаньте тратить время на ручной промптинг агентов

Начните проектировать системы, которые делают это за вас

«Вы больше не должны писать промпты для агентов кодинга. Вы должны проектировать циклы, которые промптят ваших агентов»

Борис Черни руководит Claude Code в Anthropic

Он описал этот же переход через свой собственный рабочий процесс:

«Я больше не промпчу Claude. У меня есть циклы, которые промптят Claude и решают, что делать. Моя задача — писать циклы»

Почему большинство до сих пор не строят настоящие циклы

Циклы звучат потрясающе, пока вы не увидите счёт за токены

Обычный цикл агента может потреблять контекст очень быстро:

• Средний цикл кодинга может использовать 50K–200K токенов
• Флот с оркестратором и специалистами может использовать 500K–2M токенов
• Цикл, запускаемый ежедневно, может потреблять миллионы токенов каждую неделю

Каждая повторная попытка стоит токенов

Каждое исправление стоит токенов

Каждый шаг верификации стоит токенов

Каждый сабагент добавляет новый счёт

Это скрытое ограничение, о котором редко говорят

Инженерия циклов сложна не потому, что концепцию трудно понять

Она сложна потому, что большинство пользователей не могут позволить себе бесконечные запуски агентов

Очевидная реакция:

«Легко тебе говорить, у тебя безлимитный доступ к OpenAI»

И эта критика справедлива

Вот почему дешёвые модели с большими контекстными окнами так важны

Чтобы запускать полезные циклы каждый день, вам нужно:

• Доступные входные токены
• Доступные выходные токены
• Большие контекстные окна
• Надёжный вызов инструментов
• Структурированный JSON-вывод
• Высокая степень параллелизма
• Достаточно контекста, чтобы помнить предыдущие шаги

Без этого циклы остаются дорогими экспериментами

С этим циклы становятся практическими системами, способными выполнять реальную работу

Старый рабочий процесс против нового

Последние два года большинство людей использовали агентов так:

Вы даёте промпт

Агент отвечает

Вы просматриваете ответ

Вы замечаете проблему

Вы снова даёте промпт

Это работает, но не масштабируется

Старый рабочий процесс:

• Вы пишете промпт
• Агент создаёт результат
• Вы проверяете результат
• Вы исправляете слабые места
• Вы вручную повторяете процесс

Новый рабочий процесс:

• Вы определяете результат
• Цикл выясняет, что требуется
• Цикл создаёт план
• Агент выполняет работу
• Проверяющий оценивает результат
• Цикл исправляет неудачи
• Система останавливается, когда цель достигнута

Промпт даёт агенту одну инструкцию

Цикл даёт агенту целую работу

Что на самом деле означает инженерия циклов

Инженерия циклов означает создание повторяемых циклов обратной связи вокруг AI-агентов

Цель проста:

Перейти от начальной попытки к проверенному результату

Без того, чтобы человек контролировал каждый шаг

Базовый цикл включает пять этапов:

1. Исследование
2. Планирование
3. Выполнение
4. Проверка
5. Итерация

Если результат проходит проверку — отправляем его

Если результат не проходит — возвращаем его в цикл

Это вся концепция

Вы не пытаетесь написать один безупречный промпт

Вы создаёте систему

Которая улучшает несовершенные результаты, пока они не удовлетворят требованиям

Одноагентные циклы

Циклы обычно бывают двух размеров

Меньшая версия использует одного агента для выполнения всего цикла

Он выясняет, что нужно сделать

Планирует работу

Выполняет задачу

Просматривает результат

И пытается снова, если что-то не получилось

Это похоже на человека, который редактирует свой собственный черновик, пока он не будет готов

Одноагентные циклы хорошо работают для:

• Сфокусированных задач
• Ограниченных областей
• Чётких целей
• Черновиков контента
• Исправления ошибок
• Исследовательских сводок

Один агент

Один цикл обратной связи

Непрерывное самосовершенствование

Флотские циклы

Флотский цикл работает в более крупном масштабе

Один оркестратор получает основную цель

Он делит цель на более мелкие части

Эти части назначаются агентам-специалистам

Каждый специалист также может делегировать узкие задачи более мелким сабагентам

Пример:

1Цель: Создать продуктивное приложение
2
3Оркестратор владеет миссией
4        ↓              ↓              ↓
5    Исследователь    Инженер        QA
6    Специалист      Специалист     Специалист
7        ↓              ↓              ↓
8 Веб-исследователь  Писатель кода  Писатель тестов
9                  + Отладчик      + Трекер ошибок

Это уже не один агент, работающий сам по себе

Это больше похоже на небольшую автономную команду, выполняющую проект от начала до конца

Открытые циклы vs закрытые циклы

Это самое важное практическое различие

Не все циклы работают одинаково

Открытые циклы

Открытые циклы являются исследовательскими

Вы ставите широкую цель и позволяете агенту самому найти путь

Агент может обнаружить полезные вещи, которые вы никогда не указывали

Но это также может быть дорого и хаотично

Открытые циклы могут:

• Исследовать слишком много направлений
• Тратить большое количество токенов
• Генерировать низкокачественную работу с высокой скоростью
• Отклоняться от реальной цели
• Стать трудноуправляемыми

Открытые циклы захватывают

Но обычно они не лучшая отправная точка

Закрытые циклы

Закрытые циклы имеют чёткие границы

Человек сначала определяет путь

Цикл всё ещё работает независимо, но остаётся в рамках явных правил

Закрытый цикл включает:

• Чёткую цель
• Определённые этапы
• Оценку после каждого этапа
• Условие остановки
• Передачу человеку, если система застряла

Это версия, которая создаёт ценность сегодня

Она стоит меньше

Ей легче доверять

Она даёт более чистые результаты

Начинайте с закрытых циклов

Делайте их более открытыми только после того, как ваши проверки станут достаточно надёжными

6 строительных блоков эффективного цикла

Каждый цикл концептуально следует одному и тому же пятиэтапному циклу

На практике шесть строительных блоков делают этот цикл полезным

1. Автоматизации

Автоматизация — это сердце цикла

Она запускает процесс без необходимости помнить о ручном запуске

Примеры:

• Запускать каждое утро
• Запускать при открытии PR
• Запускать после изменения файла
• Запускать при появлении нового тикета
• Продолжать, пока все тесты не пройдут

Если вы всё ещё запускаете каждое действие сами, цикл делает недостаточно

2. Worktrees (рабочие деревья)

Worktrees становятся важными, когда несколько агентов одновременно редактируют код

Без изоляции агенты сталкиваются

Два агента могут изменить один и тот же файл

Один агент может перезаписать работу другого

Worktree даёт каждому агенту отдельное рабочее пространство и ветку

Это позволяет нескольким агентам работать параллельно

Не превращая репозиторий в беспорядок

3. Навыки (Skills)

Навыки хранят многократно используемые знания о проекте

Перестаньте объяснять один и тот же контекст при каждом запуске

Запишите важную информацию один раз

Пусть каждый будущий цикл использует её повторно

Полезные файлы навыков могут содержать:

• Видение продукта
• Архитектуру
• Правила проекта
• Инструкции по сборке
• Инструкции по тестированию
• Действия, которые агент никогда не должен выполнять

Без навыков каждый цикл начинается с холодного старта

С навыками каждый запуск начинается со знаний, накопленных в предыдущей работе

4. Плагины и коннекторы

Цикл, который может читать только локальные файлы, имеет ограниченную ценность

Коннекторы позволяют ему взаимодействовать с инструментами, где происходит ваша реальная работа

Примеры:

• GitHub
• Slack
• Linear
• Jira
• Gmail
• Google Диск
• Базы данных
• Staging API

Это разница между:

«Вот возможное исправление»

И:

«Я открыл PR и привязал его к тикету»

«Затем я отследил CI и опубликовал финальное обновление»

5. Сабагенты

Создатель и проверяющий не всегда должны быть одним и тем же агентом

Агент, написавший код, может быть слишком снисходителен при его проверке

Агент, написавший черновик статьи, может дважды пропустить одни и те же слабые места

Используйте отдельных агентов для:

• Исследования
• Реализации
• Ревью
• Тестирования
• Фактчекинга
• Итоговых сводок

Качество повышается, когда рецензент независим

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

6. Память

Память позволяет циклу продолжаться в течение нескольких запусков

Модель забывает

Репозиторий — нет

Заметки — нет

Журнал проекта — нет

Память может храниться в:

• Markdown-файлах
• Журналах проекта
• Тикетах Linear
• Issues GitHub
• Хранилищах Obsidian
• Базах данных
• Проектах Claude

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

Что сработало

Что не сработало

И что ещё нужно сделать

Без постоянной памяти цикл каждый раз начинается с нуля

Реальные примеры циклов

Эти рабочие процессы делают идею конкретной

Цикл кодинга

1Прочитать VISION.md + ARCHITECTURE.md
2↓
3Спланировать следующее изменение
4↓
5Отредактировать код
6↓
7Запустить тесты
8↓
9Если тесты не пройдены → изучить ошибку → исправить → протестировать снова
10↓
11Если тесты пройдены → подготовить сводку изменений
12↓
13Остановиться

Человеку не нужно управлять каждым этапом

Агент пишет, тестирует, исправляет и проверяет свою собственную работу

Исследовательский цикл

1Определить исследовательский вопрос
2↓
3Найти релевантные источники
4↓
5Обобщить доказательства
6↓
7Проверить каждое утверждение по источникам
8↓
9Сравнить противоречивую информацию
10↓
11Создать финальный синтез
12↓
13Остановиться при достижении порога уверенности

Это даёт гораздо более сильный результат, чем запрос одного быстрого резюме

Контент-цикл

1Определить тему + аудиторию + цель
2↓
3Создать первый черновик
4↓
5Отправить его агенту-критику
6↓
7Переписать с учётом критики
8↓
9Оценить по критериям успеха
10↓
11Если проходит → опубликовать
12↓
13Если не проходит → переписать снова

Цикл превращает одну идею в повторяемую контент-систему

Цикл продаж (outreach)

1Определить ICP
2↓
3Найти лидов, соответствующих профилю
4↓
5Обогатить каждого лида данными о компании
6↓
7Квалифицировать их по критериям
8↓
9Персонализировать сообщение
10↓
11Провести проверку качества
12↓
13Отправить или передать человеку

Каждый пример использует один и тот же скелет:

Цель

Действие

Проверка

Исправление

Повторять, пока задача не выполнена

Промпт-инженер vs инженер циклов

Это новый разрыв в навыках, открывающийся в 2026 году

Промпт-инженер

Промпт-инженер сосредоточен на улучшении инструкций

Он улучшает формулировки

Он получает более сильный единичный ответ

Но после того, как агент закончил, человек всё ещё должен всё проверить

Человек остаётся циклом обратной связи

Инженер циклов

Инженер циклов строит саму систему обратной связи

Он определяет:

• Что запускает цикл
• Какой контекст получает агент
• К каким инструментам он может получить доступ
• Что считается успехом
• Кто проверяет результат
• Когда процесс должен остановиться
• Где хранится конечный результат

Промпт-инженер говорит:

«Напиши мне функцию»

Инженер циклов говорит:

«Напиши функцию»

«Протестируй её и исправляй, пока все тесты не пройдут»

«Затем подготовь сводку изменений»

Инструменты могут быть одинаковыми

Мышление совершенно разное

Самые эффективные строители AI переходят от лучших инструкций

Они создают системы, которые исследуют и планируют

Выполняют и проверяют

Затем останавливаются в нужный момент

Краткое содержание

Инженерия циклов — это переход от ручных промптов к автоматизированным циклам обратной связи

Сдвиг:

• Старый способ: давать агенту по одной задаче за раз
• Новый способ: построить цикл, который управляет всем процессом

6 вещей, которые вы строите:

• Автоматизации: запускают цикл автоматически
• Worktrees: позволяют агентам работать параллельно без конфликтов файлов
• Навыки: повторно используют знания о проекте в каждом запуске
• Плагины и коннекторы: дают циклу доступ к реальным инструментам
• Сабагенты: разделяют создателей и рецензентов
• Память: сохраняют знания между запусками

2 размера:

• Одноагентный цикл: один агент многократно улучшает свою собственную работу
• Флотский цикл: оркестратор координирует специалистов и сабагентов

2 типа:

• Открытый цикл: гибкий, исследовательский и дорогой
• Закрытый цикл: ограниченный, надёжный и доступный

5 этапов:

1. Исследование
2. Планирование
3. Выполнение
4. Проверка
5. Итерация

Реальная проблема стоимости:

• Циклы быстро потребляют токены
• Дешёвые модели с длинным контекстом делают их практичными
• Без доступных токенов большинство пользователей никогда не выходят за рамки экспериментов

Смена мышления:

• Промпт-инженеры запрашивают результаты от AI
• Инженеры циклов строят системы, которые доставляют проверенные результаты

Вот в чём настоящий прорыв

Перестаньте искать один идеальный промпт

Постройте цикл, который постоянно делает несовершенные результаты лучше

Надёжный цикл победит идеальный промпт

Если вы дочитали до этого места

Подпишитесь на [@elune0x](https://x.com/@elune0x) и сохраните эту статью в закладки

Возвращайтесь к ней, когда будете готовы строить свои собственные циклы