Преемник Loop Engineering и рабочий процесс, который расширяет возможности ваших агентов в 10 раз...
Большинство людей, создающих многошагового агента, в итоге получают прямую линию
шаг первый, шаг второй, шаг третий. Каждый ждёт завершения предыдущего, прежде чем начать
Вот что почти никто не проверяет:
половине этих шагов никогда не нужно было ждать
Они просто выстраиваются в очередь, по одной задаче за раз, пока контекстное окно не заполнится и агент не забудет, что делал
- Это было медленно не потому, что модель слабая
- Это было медленно, потому что вы нарисовали линию там, где работа была графом
Это руководство проведёт вас от этой линии к графу, который расходится веером по целому флоту и проверяет сам себя
Пять шагов. К шагу 2 вы уже построите один —
Вы получите рабочий граф и узнаете ловушки, которые ломают настоящие. Я укажу, где начинаются сложности
до альфы — подпишитесь на мой подкаст, чтобы получать больше свежей альфы ↓
Глава 0 — Что такое графовая инженерия на самом деле
Месяц назад в этой области говорили о циклах.
Питер Штайнбергер выразил это в девяти словах:
https://x.com/steipete/status/2078277297791189132
Цикл — это один виток улучшения:
попробовать что-то → проверить результат → скорректировать → повторить
Это атом: один агент, улучшающий одну вещь повторно
(Если вы читали мою статью Loop Engineering, это то самое)
https://x.com/0xCodila/status/2072329149520232639
Но у одиночного цикла есть известная ошибка — команда поддержки привязывает обратную связь к одной метрике: проценту решённых тикетов
Число растёт месяцами, а удовлетворённость падает. Бот научился быстро закрывать тикеты вместо того, чтобы решать проблемы
Это закон Гудхарта. Цикл видит только свою метрику. Он не может спросить, верна ли цель, или заметить, что его собственное измерение дрейфует
Ответ — не лучший цикл. А граф циклов — сеть, где циклы следят друг за другом и корректируют друг друга
Для агентов это означает одно:
Перестаньте писать одного агента, который делает всё подряд — спроектируйте
форму
работы — что выполняется до чего, что одновременно, что ждёт.
Узлы думают. Рёбра переносят результаты
И Claude Code выпустил инструменты для создания таких графов напрямую: динамические рабочие процессы
Шаг 1 — Увидьте рёбра, которых нет
У графа две части:
- Узел — это одна единица работы: один агент, одна задача, один вход, один выход
- Ребро — это зависимость: выход этого узла питает вход того узла
Ошибка, которую совершают все, — считать «а затем» ребром.
"Суммируй этот файл
а затем
скажи мне погоду"
Погоде не нужно читать саммари.
Это две независимые задачи, которые линейный скрипт связывает без причины. Каждая ждёт предыдущую просто так
Привычка, с которой всё начинается:
Для каждого «а затем» спросите: действительно ли следующий шаг читает вывод предыдущего?
- Если да → настоящее ребро. Сохраняйте порядок.
- Если нет → ребра нет. Ожидание впустую. Запускайте их параллельно.
Если между двумя блоками не передаются данные, они независимы.
Именно эту независимость вы будете использовать в оставшейся части руководства
Ваш простой агент "делай А, затем Б, затем В" — это уже граф — просто самый унылый: единственная цепочка, где если В зависает, Г никогда не наступит.
Шаг 2 — Постройте свой первый граф (от начала до конца)
Хватит теории. Постройте один и посмотрите, как он работает.
Перед началом:
- Claude Code v2.1.154+ (проверьте через claude --version)
- Платный план. На Max, Team или Enterprise рабочие процессы включены по умолчанию. На Pro включите строку Dynamic workflows в /config
1. Откройте знакомый репозиторий.
Настоящий, чтобы результат имел смысл.
2. Вставьте этот промпт (от Anthropic):
1Создайте рабочий процесс для аудита каждого файла маршрутов в src/routes/ на предмет отсутствующих проверок аутентификации. Запустите по одному агенту на файл, затем запустите независимый верификатор для каждой находки перед составлением отчёта. Для начала проанализируйте максимум 20 файлов.
Замените src/routes/ на путь к вашим файлам. Строка «макс 20» сохранит первый запуск дёшевым.
3. Наблюдайте, как загорается «рабочий процесс».
Claude Code подсвечивает это: «Dynamic workflow requested.» Это сигнал, что строится граф, а не обычный чат.
4. Одобрите план.
Claude пишет скрипт оркестрации на JavaScript и сначала показывает фазы. Прочитайте их, выберите «Yes, run it.»
5. Запустите флот.
Один агент на файл, параллельно, пока ваша сессия остаётся свободной.
Введите /workflows, чтобы наблюдать вживую: размах, разветвление, проверка, синтез.
6. Прочитайте один ответ.
Не двадцать отдельных чатов. Один отчёт — потому что промежуточные результаты жили в переменных скрипта, а не в вашем контексте.
Это и есть граф.
Дюжина агентов из одного предложения.
О заявлении «ноль токенов», которое вы услышите
Скрипт координации — это код
Поэтому передача результатов между агентами не тратит контекст заново, как при передаче в чате.
Но агенты всё равно потребляют ресурсы. Рабочий процесс стоит значительно дороже, чем обычная сессия.
Экономия — в координации, а не в самой работе. Начинайте с малого, следите за расходом, затем расширяйте.
- Сделайте его своим
Когда запуск удался, нажмите s.
Он сохранится в ~/.claude/workflows и будет доступен для повторного запуска по имени.
Теперь измените задачу, сохранив форму. Замените «отсутствующие проверки аутентификации» на «необработанные промисы» или «функции длиннее 100 строк»
Насколько это масштабируется (название статьи)
Один запуск рабочего процесса может разветвиться на 1 000 агентов, при этом до 16 работают одновременно
Вот откуда берётся «1000+ циклов в одном окне» — не метафора, фактический потолок функции.
- И масштаб — это суть Тысяча агентов означает задачу, которую ни один контекст никогда не смог бы вместить — целая кодовая база, проверенная за раз, миграция, затрагивающая каждый файл, поиск, запускающий тысячу направлений параллельно
Ограничение в 16 одновременно работающих агентов означает лишь то, что флот движется волнами, перерабатывая все тысячу, пока вы не сидите и не следите за каждым
Начните с 20, чтобы увидеть, как ведёт себя запуск и сколько он стоит — затем расширяйтесь — потому что это потолок, против которого никто больше не строит
Шаг 3 — Что на самом деле ломается
Вы построили граф. Вот где настоящие ломаются.
Два сбоя имеют наибольшее значение
- Сбой первый: граф соглашается сам с собой
Когда агент проверяет свою собственную работу, он относится к себе снисходительно. Модели предпочитают свои собственные результаты
Поэтому вы ставите верификатор на ребро — отдельный узел, который подтверждает находку, прежде чем она отправится дальше.
Подвох, которого никто не называет: верификатору нужен чистый контекст
Передайте ему тот же разговор, что был у исполнителя, и он не проверяет. Он соглашается с собой другим шрифтом
Граф агентов, разделяющих один контекст, — это одиночный цикл в маскарадном костюме. Он терпит неудачу так же — позже, дороже, с большим количеством зелёных сигналов на пути вниз
Поэтому верификатор — это новый узел — Собственный контекст — Проверяет реальный сигнал — не «сказал ли агент, что готово», а «проходит ли тест на самом деле»
- Сбой второй: агенты мешают друг другу
Это не гипотетика
Когда команда Bun впервые развернула крупный порт на множество агентов, запуск провалился операционно — агенты использовали общие git-команды в одном рабочем пространстве и перезаписывали друг друга
Исправление было структурным, а не хитрым промптингом. Они запретили небезопасные команды и дали каждой группе собственное изолированное рабочее дерево
Вот настоящий урок параллелизма — два агента, пишущие в один файл, соревнуются
Прежде чем разветвляться, ответьте на три вопроса:
- Где работает каждый агент?
- Как объединяются результаты?
- Что происходит, когда двое не согласны?
Граф без такого плана не масштабируется — он терпит неудачу быстрее
Шаг 4 — Шесть графов, которые можно построить на этой неделе
Метод: найдите настоящие рёбра → разветвитесь → проверьте в независимом контексте → изолируйте работников
///
Каждый из них — та же форма, нацеленная на новую задачу. Измените строку задачи и вперёд:
- Проверка безопасности — один агент на файл, ищущий отсутствующую аутентификацию, верификатор, подтверждающий каждую находку (тот, который вы построили)
- Цитируемый отчёт с /deep-research — уже работает: разбивает ваш вопрос на направления, ищет параллельно, агенты опровергают друг друга перед написанием
- Порт модуля — файл за файлом, тесты как шлюз, неудачи возвращаются в цикл
- Состязательное ревью диффа — маршрутизация по размеру: маленькое изменение → один проход; большое — полный параллельный аудит
- Запланированное сканирование экосистемы — сохраните один раз, запускайте по имени
- Обнаружение неизвестного размера — искатели работают параллельно, каждый результат проверяется на всё, что уже видели, цикл повторяется, пока два раунда не найдут ничего нового
///
Как выглядит потолок https://simonwillison.net/2026/Jul/8/rewriting-bun-in-rust/
Порт Bun с Zig на Rust работал именно на этом механизме.
Около 50 рабочих процессов, пик — 64 агента параллельно. Примерно 535 000 строк Zig превратились в более чем миллион строк Rust за 11 дней.
Это также обошлось примерно в $165 000 использования. Потребовался человек, проектирующий и контролирующий всё это.
И это вызвало публичную критику: можно ли безопасно ревьюить такой объём кода, написанного ИИ.
Масштаб реален. Как и цена, и необходимость надзора.
Шаг 5 — Якоря, которые удерживают граф честным
Одна топология не даёт истины
Сеть агентов, которые подтверждают друг друга, но ни один не касается ничего реального, терпит неудачу точно так же, как и одиночный цикл — только с большим количеством движущихся частей
Графу нужны якоря: узлы, с которыми нельзя спорить
- Тесты, которые действительно прошли — не «должны пройти», прошли
- Верификатор на основе доказательств, а не ощущений
- Замороженные правила, которые агентам никогда не разрешается настраивать — потому что именно их оптимизатор попытался бы ослабить
Граф настолько честен, насколько честны вещи в нём, которые отказываются двигаться
Когда граф — неправильный выбор
Большинство задач — не графы. Использовать граф, когда он не нужен, — просто жечь деньги и добавлять пути к ошибкам.
Пропустите граф, когда:
- Задача мала или изолирована. Добавление функции, исправление одного бага. Рабочий процесс здесь — чистый оверхед; один агент быстрее и дешевле.
- Нужен жёсткий контроль. Если вы хотите читать и одобрять каждый шаг перед выполнением следующего, вся суть графа (работа вширь без вас) работает против вас.
- Вы ещё не знаете, что ищете. Исследовательская работа требует одного агента, которым можно управлять, а не флота, приверженного плану до того, как вы поймёте проблему.
- Шаги действительно зависят друг от друга. Если каждый шаг читает вывод предыдущего, это настоящая цепочка. Параллелизму не за что зацепиться. Принудительное наложение графа на истинно последовательную задачу добавляет только затраты на координацию при нулевом ускорении.
Подсказка — Шаг 1. Если вы не можете найти два блока без стрелки между ними, нечего строить. Это цикл, и цикл — это нормально.
Граф — это инструмент для ширины — независимой работы, выполняемой одновременно
Когда работа неширокая, линия никогда не была проблемой...
Сдвиг
Промптер задаёт вопрос. Архитектор рисует граф.
Линейный агент никогда не был потолком.
Это была первая форма — та, которую все используют, потому что она соответствует тому, как мы печатаем: одна строка, одно действие за раз.
Как только вы увидите узлы и рёбра, вы перестанете просить агента делать больше и начнёте просить граф делать это шире:
- Разветвляйтесь там, где работа независима
- Ставьте шлюзы на рёбрах там, где важна уверенность
- Замораживайте узлы, которые содержат истину
Большинство людей будут продолжать выстраивать шаги в линию.
Те немногие, кто научится рисовать граф и уважать то, что его ломает, будут управлять флотом.
Рисуйте граф. Оставайтесь архитектором.
Начните с предварительного условия:
- одиночный цикл, на котором это построено
