← Agent Reliability Lab Менеджмент агентов
0/8 модулей

Агент как менеджер

Введение: зачем переносить классические управленческие методики на AI-агентов

Хук: агент делает работу менеджера

Каждый раз, когда LLM-агент берётся за задачу, он проходит тот же цикл, который десятилетиями изучают бизнес-школы: ставит цель, собирает информацию, принимает решение, действует, проверяет результат — и корректирует курс. Человечество давно кодифицировало эти петли: OODA, GTD, PDCA, первопринципы, Theory of Constraints, SMART/OKR. Этот курс переносит каждую методику на AI-агентов — конкретно и без абстракций.

Управленческий цикл агента

Цель Восприятие Решение Действие Проверка Корректировка

Цель — что именно нужно достигнуть (SMART/OKR).

Восприятие — сбор данных из контекста, инструментов, окружения.

Решение — выбор следующего шага (OODA, первопринципы).

Действие — вызов инструмента, генерация вывода, запись памяти.

Проверка — eval: соответствует ли результат цели (PDCA).

Корректировка — приоритизация (TOC, GTD), обновление плана.

Почему агентам это особенно нужно

Overreach. Агент берётся за слишком многое: длинный план без приоритизации, огромный контекст, параллельные цепочки — и «застревает» на полпути.
Узкое контекстное окно. «Рабочая память» агента жёстко ограничена. Без явной выгрузки (GTD: capture) важные детали вытесняются новыми токенами.
Нет встроенной приоритизации. Агент без явного ранжирования обрабатывает задачи в порядке появления — как плохой менеджер, который отвечает на письма вместо того, чтобы закрыть критический баг.
Нет встроенной проверки. Без явного критерия успеха (eval) агент «уверенно делает не то» — генерирует правдоподобный, но неверный ответ без сигнала об ошибке.

Три линзы курса

Весь курс построен вокруг трёх управленческих вопросов:

КУДА

goal-setting

Где мы хотим оказаться? Какой критерий успеха?

Методики: SMART/OKR, Первопринципы

КАК ДВИГАТЬСЯ

decision loops

Как принимать решения в каждом шаге цикла?

Методики: OODA, PDCA

ЧТО ПЕРВЫМ

prioritization

Какую задачу взять следующей в ограниченном контексте?

Методики: TOC, GTD

Карта курса: 6 методик

Методика Линза Применяй к агенту, когда… Модуль
OODA decision loops агент мечется, медленно сходится к решению M2
GTD prioritization агент тонет в задачах, теряет контекст M3
PDCA decision loops агент повторяет одни и те же ошибки между прогонами M4
Первопринципы goal-setting копируем «магические» промпты не понимая почему работают M5
TOC prioritization пайплайн медленный/ненадёжный, неясно что чинить M6
SMART/OKR goal-setting цель размытая — агент делает не то M7

Навигатор методик

Выбери симптом — получи рекомендацию и переход к нужному модулю:

Проверь себя

Q1. Почему классические управленческие методики вообще применимы к LLM-агенту?
Потому что агент — это человек.
Потому что агент выполняет тот же управленческий цикл (цель → сбор информации → решение → действие → проверка) и имеет схожие ограничения: узкая рабочая память, нет встроенной приоритизации.
Потому что методики запатентованы под ИИ.
Q2. Три «линзы», вокруг которых построен курс:
goal-setting · decision loops · prioritization
prompt · context · tools
скорость · цена · качество
Теперь вы видите AI-агента как самоуправляющуюся систему с собственным управленческим циклом — и знаете карту из 6 методик (OODA, GTD, PDCA, Первопринципы, TOC, SMART/OKR), каждая из которых устраняет конкретный сбой в этом цикле. Следующие модули разберут каждую методику детально и переведут её в конкретные инструкции для агентов.

OODA-петля

Observe → Orient → Decide → Act: цикл быстрее среды — ты задаёшь условия.

Происхождение: Джон Бойд и воздушный бой

Джон Бойд — военный лётчик и военный стратег ВВС США. В 1950-х он сформулировал правило 40 секунд: в воздушном бою тот, кто успевает переключиться на контратаку за 40 секунд, побеждает — независимо от манёвренности самолёта. Из этого наблюдения вырос фреймворк OODA.

Ключевая идея: победитель — тот, кто прокручивает цикл быстрее и точнее, чем меняется обстановка, и «влезает внутрь петли противника» (operate inside the adversary's OODA loop) — оппонент реагирует на уже устаревшую картину мира.

Петля OODA (схема)

┌──────────────────────────────────────┐
│  Observe → Orient → Decide → Act    │
│      ↑                       │       │
│      └───────────────────────┘       │
│          (результат Act =             │
│           новое наблюдение)          │
└──────────────────────────────────────┘

Цикл не заканчивается — он повторяется непрерывно, пока агент активен.

Четыре фазы

👁 Observe — Наблюдение

Сбор сырых данных: состояние среды, результаты предыдущих действий, обратная связь. Без фильтрации и интерпретации — только факты.

У агента: чтение результатов tool-calls, ошибок, stdout/stderr, состояния файлов, API-ответов.

🧭 Orient — Ориентация («Big O»)

Интерпретация наблюдений через модель мира, опыт, контекст. Бойд называл эту фазу важнейшей: ориентация определяет, как ты наблюдаешь, какие решения рассматриваешь, как действуешь.

У агента: системный промпт + рабочий контекст + извлечённая из памяти информация. «Сломанный Orient» → галлюцинации и действие по устаревшей картине мира.

🎯 Decide — Решение

Выбор гипотезы или плана действий на основе ориентации. Решение — это ставка: мы выбираем одну ветку из нескольких возможных.

У агента: выбор следующего инструмента/шага; reasoning-трассировка в Chain-of-Thought.

⚡ Act — Действие

Выполнение решения. Результат немедленно возвращается в петлю как новое наблюдение — цикл замыкается.

У агента: вызов инструмента (tool call). Его результат — входные данные для следующего Observe.

Почему Orient — «Big O»? Bойд писал: «Ориентация — это линза, через которую мы смотрим на мир». Если линза искажена (неверный контекст, устаревшие данные, предвзятость), то правильные наблюдения приведут к ошибочным решениям. Orient — рычаг качества всей петли.

ReAct-петля агента = OODA

Паттерн ReAct (Reason + Act), используемый в LLM-агентах, изоморфен OODA:

OODA фаза    │  ReAct шаг           │  Конкретика у агента
─────────────┼──────────────────────┼──────────────────────────────────────
Observe      │  Observe (perception)│  Читает tool-result, ошибки, env-state
Orient       │  Think / Reason      │  Системный промпт + контекст + память
Decide       │  Plan next action    │  Выбирает инструмент и аргументы
Act          │  Act (tool call)     │  Вызывает инструмент → результат идёт
             │                      │  обратно в Observe следующей итерации

Контекст-инжиниринг (что попадает в системный промпт, что в рабочий контекст, что в retrieval) — это прямая настройка фазы Orient. Именно поэтому он является главным рычагом качества агента.

Темп (Tempo): кто быстрее и точнее

Скорость петли — не единственная метрика. Бойд подчёркивал два условия одновременно:

  • Быстрее — цикл завершается быстрее, чем меняется среда (advantage ≥ 1).
  • Точнее — Orient адекватен реальности (контекст актуален, память не засорена).
Ловушка быстрого темпа: если Orient сломан, ускорение петли означает «быстро делать ерунду». Быстрый цикл ценен только при адекватной ориентации.

🎛 Интерактив: темп петли против среды

Среда меняется с характерным временем T_env = 10 сек. Двигайте слайдер — увидите, как меняется «преимущество петли».

Формула: advantage = T_env / T_loop = 10 / T_loop

Проверка арифметики:
  • T_loop = 2 секadvantage = 5.0 → 🟢 Внутри петли среды
  • T_loop = 10 секadvantage = 1.0 → 🟡 Паритет
  • T_loop = 20 секadvantage = 0.5 → 🔴 Среда убежала вперёд

Антипаттерны OODA у агентов

🔄 Застрял в Observe

Симптом: агент бесконечно вызывает поиск, накапливает контекст, не переходит к Decide/Act.

Причина: анализ-паралич — неясный критерий «достаточно данных».

Лечение: явный лимит на число Observe-итераций; принцип «достаточно хорошей информации».

🚫 Пропустил Orient

Симптом: агент действует по устаревшим данным — результаты предыдущего Act не попали в контекст.

Причина: потеря контекста, переполнение окна, кривая инжекция памяти.

Лечение: явная передача результатов tool-calls обратно в контекст; scratchpad-паттерн.

♾ Петля без условия выхода

Симптом: агент крутится в OODA-петле без завершения — не достигает цели и не останавливается.

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

Лечение: явный stopping criterion; max_iterations; инструмент finish().

⚡ Быстрый цикл + плохой Orient

Симптом: агент делает много tool-calls быстро, но все — не туда; галлюцинирует действия.

Причина: системный промпт неполный, контекст устарел, память засорена.

Лечение: сначала исправить Orient (контекст, промпт), затем оптимизировать темп.

Практика: OODA в проектировании агента

Чеклист Orient-аудита агента:

  1. Что находится в системном промпте? Актуально ли это?
  2. Как результаты tool-calls попадают обратно в контекст?
  3. Есть ли механизм извлечения памяти (RAG, scratchpad)?
  4. Как агент узнаёт, что ситуация изменилась с момента последнего Orient?
  5. Каков критерий завершения петли?
Правило Бойда для агентов: прежде чем оптимизировать latency (темп), убедись, что Orient адекватен. Быстрый агент с плохим контекстом — это быстрый путь к ошибке.

Implicit vs explicit Orient: где живёт «модель мира»

У агента фаза Orient реализуется двумя способами — это ключевой архитектурный выбор:

Implicit Orient

Ориентация «в голове» модели: контекст и рассуждение живут в самом промпте/CoT. Быстро и гибко, но непрозрачно и плывёт между шагами — модель каждый раз заново «собирает» картину из текста контекста.

Explicit Orient

Ориентация вынесена в структуру: JSON world-state, scratchpad, граф задач. Дороже поддерживать, но воспроизводимо, проверяемо и переживает компакцию контекста (мост к GTD из M3 — внешняя память).

Чем длиннее задача и важнее повторяемость — тем больше Orient должен быть explicit. Одноразовому ответу хватит implicit.

Критерий остановки: когда петля должна закончиться

OODA — цикл, но у любого цикла агента должно быть условие выхода, иначе он крутится вечно (или жжёт бюджет). Здесь работает satisficing Герберта Саймона: агент не оптимизирует до идеала, а останавливается на «достаточно хорошо» по явному порогу.

  • Критерий успеха достигнут — результат прошёл проверку (мост к Check/eval из M4 и Measurable из M7).
  • Бюджет исчерпан — лимит шагов / токенов / времени.
  • Нет прогресса — N итераций подряд без улучшения наблюдений → выйти и эскалировать.
Без явного критерия остановки агент сваливается либо в анализ-паралич (бесконечный Observe), либо в бесконечную «полировку».

Граница OODA: хаотический домен

OODA предполагает, что наблюдение информативно. Но если данных ещё нет — среда новая и непредсказуемая — «наблюдать» нечего. В хаотическом домене порядок переворачивается: сначала действуй, чтобы создать информацию (act → sense → respond), а не застревай в Observe. Это часть более общей рамки Cynefin — «какой режим решения для какой ситуации»; полную карту доменов разберём в M8.

📝 Упражнение: переведи OODA в system-prompt.

Напиши фрагмент системного промпта, который заставляет агента (1) явно фиксировать Orient — текущее понимание задачи — перед действием и (2) проверять критерий остановки после каждого шага. 3–5 строк.

Проверь себя

Q1. Какая фаза OODA, по Бойду, важнее всего и почему?
Act — потому что действие меняет мир.
Observe — без данных нет решения.
Orient — интерпретация наблюдений через модель мира определяет, как ты наблюдаешь, решаешь и действуешь; у агента это контекст и системный промпт.
Q2. Агент бесконечно вызывает поиск, копит контекст, но не переходит к действию. Где он застрял?
В Observe — анализ-паралич; петля не доходит до Decide/Act.
В Act — слишком много действий.
Проблема не в OODA.
Q3. Всегда ли полезно ускорять OODA-петлю агента?
Да, чем быстрее, тем лучше всегда.
Нет: быстрый цикл с плохим Orient = быстро делать ерунду; темп ценен только при адекватной ориентации.
Главный вывод модуля: OODA — это не просто «делай быстро». Orient — самая важная фаза: именно качество контекста и модели мира определяет, куда ведут наблюдения, решения и действия. Для AI-агента контекст-инжиниринг (системный промпт, рабочая память, результаты tool-calls) — это прямое управление Orient. Ускоряй петлю только после того, как убедился, что ориентация адекватна реальности.

Модуль 3: GTD — Getting Things Done

Дэвид Аллен · «Ум как вода» · Пять шагов от хаоса к действию · Перенос на AI-агентов

Почему мозг плохо хранит задачи

Эффект Зейгарника

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

Дэвид Аллен открыл: проблема не в нехватке времени, а в том, что мозг не предназначен для хранения задач — только для их обработки.

«Ум как вода» (Mind Like Water)

Идеальное состояние — когда система полностью доверяете внешнему хранилищу. Бросил камень — вода среагировала ровно по силе броска, вернулась в покой. Никакой «остаточной тревоги».

GTD-решение: выгрузить всё во внешнюю надёжную систему и освободить рабочую память для настоящего мышления.

Пять шагов GTD

  1. Capture (Собрать) — всё в единый инбокс; голова не хранит ничего.
  2. Clarify (Прояснить) — что это? Требует ли действия? Что конкретно нужно сделать?
  3. Organize (Организовать) — разложить по спискам, проектам, контекстам (@звонки, @компьютер).
  4. Reflect (Просматривать) — регулярный review: еженедельный обзор всей системы.
  5. Engage (Делать) — выбирать действие по контексту, энергии, времени.

Ключевые правила GTD

Правило двух минут: если действие займёт менее 2 минут — сделай сразу. Overhead планирования дороже самого действия.

Next Action: всегда определяй конкретное следующее физическое действие. Не «проект X», а «позвонить Ивану по X».

Контексты: @звонки, @компьютер, @офис — фильтр «что можно сделать прямо сейчас».

Перенос GTD на AI-агентов

Контекстное окно = рабочая память

У агента то же узкое место, что у человека: контекст конечен. Удерживать в нём все задачи, факты, решения — значит воспроизводить проблему «открытых петель», только в токенах.

GTD-решение для агента: выгружай во внешнюю память — файлы, scratchpad, todo-список, vector store. Контекст — только для активного мышления.

Связь с OODA (M2)

Фаза Orient из прошлого модуля деградирует, когда контекст забит «мусором» — незакрытыми задачами, устаревшими фактами, дублирующимися инструкциями.

GTD решает проблему upstream: не даёт мусору накапливаться.

GTD-шаг У человека У агента
Capture Записать в инбокс (бумага/приложение) Сбросить в файл / scratchpad / todo-store — не держать в контексте
Clarify / Organize Декомпозиция + теги проекта/контекста Разбить цель на next-actions; тегировать инструментом / состоянием (@web_search, @file_write)
Правило 2 мин Сделай сразу, не планируй Дешёвое действие (один tool-call) — выполнить немедленно без отдельного шага планирования
Reflect Еженедельный review системы Compaction / периодический review контекста: что сделано, что осталось, что выкинуть — continuity между шагами и сессиями
Engage by context Делать по контексту/энергии/времени Выбирать инструмент, доступный в текущем состоянии агента

Антипаттерны

«Всё в контексте»
Держать все задачи, факты и промежуточные результаты в системном промпте или истории диалога. Контекст переполняется → эффект lost-in-the-middle → агент «забывает» ранние инструкции или начинает галлюцинировать.
Задача без next-action
«Сделай проект X» без декомпозиции. Агент получает аморфную цель, пытается охватить всё сразу, зависает или делает случайные шаги. GTD требует: одно конкретное физическое следующее действие.
Отсутствие review (Reflect) — дрейф. Между шагами и сессиями агент теряет нить: что уже сделано, что изменилось в условиях. Compaction и checkpoint-файлы — это GTD-Reflect для агентов.

Интерактив: GTD-воронка обработки инбокса

Пройдите по шагам — так работает Clarify в GTD и так должен рассуждать агент при обработке входящего элемента.

Входящий элемент.
Это actionable — требует какого-либо действия?

Попробуйте все пути: Reference, Someday, Trash, Do now, Delegate, Defer — каждый bucket показывает агентскую аналогию.

Контексты GTD для агента: машинные триггеры

У человека контексты GTD — это @звонки, @компьютер: где и чем можно делать действие. У агента «контекст» становится конкретным машинным условием — действие разблокируется, только когда оно выполнимо:

@has_tool · @context_fits · @needs_verify · @budget_left
Тэгируй next-action условием выполнимости, а не абстрактным «инструментом».
  • @has_tool — нужный инструмент доступен в текущем состоянии (иначе это не next-action, а «waiting-for»).
  • @context_fits — нужные данные влезают в окно (иначе сначала retrieval/суммаризация).
  • @needs_verify — результат требует проверки перед фиксацией (мост к Check из M4).
  • @budget_left — остался лимит токенов/времени на это действие.

Engage by context у агента = выбрать из очереди действие, у которого все триггеры зелёные.

WIP-лимит: capture без потолка = бесконечный инбокс

GTD говорит «собери всё», но без ограничения на число одновременно активных задач (work-in-progress) агент перегружает контекст и распыляет внимание — это та же болезнь overreach. Приём из Kanban: жёсткий потолок на параллельные задачи (часто WIP = 1 для агента — одна активная задача за раз), остальное ждёт в очереди.

WIP-лимит превращает «огромный список» в управляемый поток: меньше переключений контекста, выше доля доведённого до конца. (Глубже про WIP и закон Литтла — в смежном материале по harness-инженерии.)
📝 Упражнение: переведи GTD в system-prompt.

Опиши политику: куда агент пишет внешнюю память, как формулирует next-action и какой WIP-лимит держит; добавь правило 2 минут для дешёвых действий. 4–6 строк.

Проверьте себя

Q1. Какая аналогия точнее переносит GTD-принцип «выгружай во внешнюю систему» на агента?
Узкое контекстное окно = рабочая память; задачи и факты надо выгружать во внешнюю память (файлы/todo/хранилище), а не держать в контексте.
Агенту нужно больше GPU.
Надо удалить системный промпт.
Q2. Агент получил список из 12 задач и «завис». Какой приём GTD это лечит?
Capture — записать их ещё раз.
Определить конкретное next-action для текущей задачи (одно действие за раз) вместо хранения всего списка как аморфной кучи.
Удалить список.
Главное из модуля: GTD — это не про тайм-менеджмент, а про управление вниманием через внешнюю систему. Для агента это означает: не удерживать задачи в контексте — выгружать в файлы/хранилища; каждую цель декомпозировать до конкретного next-action с контекстом-тегом; дешёвые действия выполнять немедленно; периодически делать compaction как GTD-Reflect. «Ум как вода» для агента = контекст, занятый только актуальным мышлением, а не накопленным балластом.

Модуль 4: PDCA — Спираль улучшения

Plan → Do → Check → Act: как агент учится на ошибках между прогонами

Происхождение и суть

Цикл PDCA придумал Уолтер Шухарт (Walter Shewhart) в 1930-х, а Уильям Эдвардс Деминг (W. Edwards Deming) популяризировал его в послевоенной Японии как инструмент кайдзен — непрерывного улучшения. Это не разовый проект, а спираль: каждый завершённый цикл начинает следующий с более высокой базы.

Plan — Гипотеза

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

Do — Выполнение

Реализовать запланированное изменение. Главное правило: не делать слишком много изменений одновременно, чтобы знать, что именно сработало.

Check — Измерение ★

Сравнить результат с ожиданием из Plan. Это сердце цикла. Без честного измерения PDCA вырождается в «Do-Do-Do» — бесконечное действие без учёбы.

Act — Закрепление

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

PDCA против OODA: две разные петли

Оба цикла — механизмы обратной связи, но работают на разных временны́х горизонтах и решают разные задачи.

OODA (Модуль 2)

  • Скорость: секунды–минуты
  • Назначение: тактическое решение в моменте
  • Ресурс: текущий контекст, наблюдение
  • Единица: один прогон / одно действие

PDCA

  • Скорость: часы–дни–спринты
  • Назначение: улучшение процесса между прогонами
  • Ресурс: накопленные измерения, eval
  • Единица: серия прогонов / итерация системы
Вложенность петель: внутри одного действия агента крутится OODA (observe → orient → decide → act); между прогонами (итерациями системы) работает PDCA (накопить eval → скорректировать промпт/инструкции → снова запустить). В Модуле 8 мы соберём эти две петли вместе.

Перенос на AI-агентов

Каждый шаг PDCA читается напрямую в терминах агентной разработки:

Шаг В менеджменте У агента
Plan Гипотеза изменения, план эксперимента Промпт / инструкции / few-shot / план задачи
Do Выполнить изменение (в малом масштабе) Прогон агента на тестовом наборе / реальной задаче
Check ★ Измерить результат vs ожидание из Plan Eval / verification gate / тесты — самый недооценённый шаг
Act Стандартизировать или откатить и скорректировать Обновить промпт/few-shot/инструкции; или откатить изменение

«Уверенно неправый» агент = PDCA без Check

Агент может стабильно выдавать уверенные ответы, которые фактически неверны. Если после каждого прогона нет честной проверки результата — нет сигнала для Act, нет коррекции для следующего Plan. Цикл разомкнут.

Антипаттерн: Do-Do-Do. Запускать агента снова и снова, надеясь, что «в этот раз получится», — без измерения причин ошибок и без изменения промпта/инструкций. Без Check нет улучшения, есть только трата токенов.

Verification gap — разрыв между тем, что агент утверждает о своём выводе, и тем, что реально верифицировано через eval. Закрывается только через Check.

Спираль улучшения — интерактивная модель

Модель: error_n = error_0 · (1 − r)^n, где error_0 — начальная частота ошибок (%), r — доля ошибок, устраняемых за один цикл PDCA (эффективность Check+Act), n — номер цикла.

Поставьте r = 0 — увидите горизонтальную линию: без Check улучшений нет.

Практическое применение: чеклист цикла

  1. Plan. Сформулируй конкретную гипотезу: «Если я изменю [X] в промпте, то частота ошибок на задаче [Y] снизится с [A%] до [B%]».
  2. Do. Запусти агента на фиксированном тестовом наборе с изменённым промптом. Не меняй несколько переменных сразу.
  3. Check. Прогони eval. Сравни цифры с гипотезой. Не интерпретируй субъективно — смотри на метрику.
  4. Act. Если гипотеза подтвердилась — зафиксируй изменение (обнови system-промпт, добавь few-shot пример, обнови CLAUDE.md / AGENTS.md). Если нет — откати и сформулируй новую гипотезу.
Размер «Do»: Деминг настаивал на малом масштабе — тестируй на небольшом наборе, прежде чем раскатывать на всю систему. Для агентов: eval на 20–50 примерах дешевле, чем сломать production.

Single-loop vs double-loop: улучшать способ ИЛИ менять цель

Крис Аргирис различил два уровня обучения, и PDCA по умолчанию работает только на первом:

Single-loop (обычный PDCA)

Цель и метрика зафиксированы; ты улучшаешь способ их достижения. «KR = 85% прохождения eval не достигнут → правим промпт». Вопрос: «Как сделать это лучше?»

Double-loop

Под сомнение ставятся сами цель / метрика / допущения. «А правильный ли это eval? Может, 85% прохождения теста ≠ "агент полезен"?» Вопрос: «А ту ли задачу мы вообще решаем?»

Для агента это критично: single-loop честно оптимизирует прокси-метрику — и упирается прямо в закон Гудхарта (M7). Если eval измеряет не то, single-loop будет старательно улучшать «не то». Double-loop — периодический шаг назад: «правильную ли цель проверяет наш Check?»

Практика: раз в N циклов single-loop делай один double-loop-ревью — пересмотри, что и зачем измеряет eval. Это и есть мост PDCA → пересмотр OKR (M7).
📝 Упражнение: переведи PDCA в system-prompt.

Напиши инструкцию, заставляющую агента после прогона: (1) сверить результат с критерием (Check) и (2) раз в несколько прогонов задавать double-loop-вопрос «измеряет ли мой критерий настоящую цель?». 3–5 строк.

Квиз

Чем PDCA отличается от OODA в контексте агента?
Это одно и то же.
OODA — быстрая петля принятия решения в моменте; PDCA — медленная петля улучшения процесса между прогонами (учёба на ошибках). Они вложены.
PDCA быстрее OODA.
Агент раз за разом повторяет одну и ту же ошибку в каждом прогоне. Какого шага PDCA, скорее всего, не хватает?
Plan.
Do.
Check — нет честного измерения против ожидания (нет eval/verification), поэтому Act не корректирует подход.
PDCA для агентов — это петля обучения между прогонами: Plan (промпт/гипотеза) → Do (прогон) → Check (eval — самый важный шаг) → Act (обновить или откатить). Без Check агент остаётся «уверенно неправым» навсегда. Именно регулярный eval превращает серию прогонов в спираль улучшения.

Модуль 5: Первые принципы

First Principles Thinking — разобрать до фундамента, собрать заново

Что такое рассуждение от первых принципов

Аристотель определял первопринцип как «первую основу, из которой вещь познаётся». Декарт возвёл методическое сомнение в метод: отбрось всё, в чём можно усомниться, — и строй знание заново на том, что устоит. Современный популяризатор — Илон Маск: «думать физикой», а не аналогией.

Рассуждение по аналогии

Делай как уже принято. Быстро и дёшево — не нужно думать с нуля. Но тянет чужие ограничения: если у всех «так», значит у тебя тоже «так».

  • «Батареи стоят дорого — это навсегда.»
  • «У всех конкурентов такой дизайн — значит, так правильно.»
  • «Промпт работает — копируем.»

Рассуждение от первых принципов

Разложи проблему до фундаментальных, проверяемых истин (физика, факты, цифры). Отбрось унаследованные допущения. Собери решение снизу вверх.

  • Из чего состоит батарея? Что стоят материалы на спот-рынке?
  • Почему дизайн такой? Что ограничивает физически?
  • Почему промпт работает? Какой механизм?
Три шага метода:
1. Разложи проблему до атомарных, проверяемых утверждений.
2. Отбрось допущения «так принято» — оставь только то, что можно измерить или вывести.
3. Собери решение снизу вверх, опираясь только на проверенные блоки.

Кейс: батареи (иллюстративный аргумент)

Этот пример — иллюстрация логики первых принципов в духе аргумента Маска про батареи. Числа условные, смысл — показать зазор между «рыночной аналогией» и «первопринципным полом».

Аналогия

«Батарейный пакет стоит ~$600/кВт·ч. Исторически цена падала медленно. Значит, дешёвых электромобилей не будет ещё долго.»

Допущение унаследовано из текущей рыночной структуры.

Первые принципы

«Из чего физически состоит батарея? Никель, литий, кобальт, алюминий/медь, графит, электролит. Сколько стоят материалы на спот-рынке?»

Сумма материалов ≈ $80/кВт·ч при этих ценах. Зазор = $520 — это не физика, это структура рынка. Значит, есть возможность.

Калькулятор первопринципной стоимости

Введи стоимости компонентов и рыночную цену готового пакета. Калькулятор покажет «первопринципный пол» (сумма материалов) и зазор между ним и рынком.

floor = никель + литий + кобальт + металлы + анод + электролит

Числа иллюстративные (в духе аргумента Маска про батареи), не точная историческая бухгалтерия. Смысл — показать зазор между «рыночной аналогией» и «первопринципным полом».

Перенос на AI-агентов

1. Анти-cargo-cult промптинг

Cargo-cult — копировать «магические» формулировки, не понимая механизма. Первопринципный вопрос: какой фундаментальный механизм заставляет это работать?

Cargo-cult (аналогия):
«Ты гениальный эксперт мирового уровня.
У других работает → копируем.»
Нет понимания механизма, нет eval, нет знания, помогает ли это вообще.
Первые принципы:
1. Что реально влияет на качество?
   → контекст, инструкции, примеры, eval.
2. Проверь A/B: с фразой и без.
3. Оставь только то, что подтверждено.
Строишь промпт на проверяемых гипотезах, не на ритуалах.

2. Декомпозиция до атомарных проверяемых утверждений

Сложная задача агента → разложи до atomic verifiable claims: утверждений, каждое из которых можно проверить независимо. Это прямой мост к eval из Модуля 4: каждый claim становится тест-кейсом.

Задача: «Суммируй новости корректно»
↓ декомпозиция
├── Claim 1: факты из источника сохранены
├── Claim 2: нет добавленных утверждений
├── Claim 3: тон нейтральный
└── Claim 4: длина в заданных пределах

Каждый claim = отдельный eval-тест.

3. Оценка снизу вверх: «слишком дорого / слишком много токенов»

Прежде чем принять «невозможно» — посчитай из фундаментальных составляющих.

«Это слишком дорого по токенам» — аналогия.

Первые принципы:
1. Сколько токенов занимает каждая часть промпта?
2. Что из этого несёт информацию? Что балласт?
3. Где реальный bottleneck: контекст, стоимость, latency?
→ Считаем, а не предполагаем.

4. Связь с SMART / OKR (Модуль 7)

Первые принципы дают букву A — Achievable в SMART-цели. Цель, выведенная из фундаментальных составляющих (токены, инструменты, eval-метрика), реалистична по определению — ты считал, а не копировал чужой ориентир.

Практика: применение метода

Шаблон первопринципного разбора

Задача: [описание]

1. РАЗЛОЖЕНИЕ
   Из каких фундаментальных элементов состоит задача?
   → [элемент 1], [элемент 2], ...

2. ДОПУЩЕНИЯ ПОД ВОПРОСОМ
   Что «принято» считать ограничением?
   → Допущение X: можно ли его проверить?

3. ПРОВЕРЯЕМЫЕ ИСТИНЫ
   Что можно измерить / вывести напрямую?
   → Факт 1: [число / результат эксперимента]

4. СБОРКА СНИЗУ ВВЕРХ
   Исходя из п.3, какое решение следует?
   → [вывод]

Агент-нативный пример: бюджет на модели снизу-вверх

Кейс батарей — про физический мир. Перенесём метод на агента. Аналогия (рассуждение по образцу): «задача сложная → бери самую сильную модель на всё, так надёжнее». Первопринципный вопрос: а какой доле задач реально нужна сильная модель? Посчитаем стоимость из составляющих и сравним «всё на сильной» против роутинга.

Числа иллюстративные. Смысл: «дорого и иначе никак» — это аналогия; первопринципный расчёт почти всегда вскрывает зазор (здесь — роутинг дешёвой модели на простые задачи).

📝 Упражнение: переведи первопринципы в практику.

Возьми одно «очевидное» допущение про своего агента («нужен топ-уровень модели для всего» / «контекст должен быть огромным» / «без RAG никак») и распиши его на проверяемые составляющие: что из этого можно измерить и опровергнуть дешёвым экспериментом?

Проверь себя

Q1. В чём разница между рассуждением по первопринципам и по аналогии?
Аналогия = вывод из фундаментальных истин; первопринципы = копирование существующего.
Первопринципы = разложить до фундаментальных проверяемых истин и собрать заново; аналогия = делать как уже принято (быстро, но тянет чужие ограничения).
Это синонимы.
Q2. Инженер копирует в промпт фразу «ты гениальный эксперт мирового уровня», потому что «у других работает», не проверяя эффект. Что это за антипаттерн?
Это и есть рассуждение по первопринципам.
Cargo-cult: рассуждение по аналогии без понимания механизма; первопринципный подход потребовал бы проверить, что реально влияет на качество (eval).
Нормально — копировать всегда оптимально.
Главное из модуля 5. Первые принципы — не интеллектуальный снобизм, а инструмент: разложи до фундаментальных, проверяемых истин → отбрось унаследованные допущения → собери заново. В агентской работе это три конкретных практики: (1) не копируй промпт-заклинания — проверяй механизм через eval; (2) декомпозируй задачи до атомарных утверждений, каждое из которых можно тестировать; (3) прежде чем принять «невозможно» — посчитай из составляющих. Рассуждение по аналогии быстро, но наследует чужие ограничения. Первые принципы дороже по мышлению, но открывают решения, невидимые через аналогию.

Теория ограничений (TOC)

Элияху Голдратт, «The Goal» (1984) — любая система ограничена одним узким местом, которое определяет пропускную способность всей цепи.

1. Ключевая идея: цепь не прочнее слабейшего звена

Элияху Голдратт сформулировал принцип, который изменил производственный менеджмент: в любой системе есть хотя бы одно ограничение (constraint, bottleneck) — самое медленное звено, через которое проходит весь поток работы. Это ограничение и определяет throughput — пропускную способность всей системы.

Throughput системы = производительность самого медленного звена
Если конвейер: A(100/мин) → B(20/мин) → C(50/мин) → D(40/мин),
то throughput = min(100, 20, 50, 40) = 20/мин.
Ускорение A до 200/мин ничего не даст — B по-прежнему пропускает только 20.

Классическая ловушка: команда тратит месяц на оптимизацию самой быстрой стадии, гордится ускорением в 2×, но итоговый throughput не меняется вообще. Это называют «локальная оптимизация не на узком месте».

2. Пять фокусирующих шагов

  1. Identify — найди ограничение. Где скапливается очередь? Где качество падает?
  2. Exploit — выжми максимум из узкого места без новых вложений: лучший процесс, устрани простои.
  3. Subordinate — подчини всё остальное темпу узкого места. Не заваливай его работой быстрее, чем оно справляется.
  4. Elevate — вложись в расширение: новый инструмент, ресурс, инфраструктура.
  5. Repeat — после расшивки узкое место сместится. Не дай инерции остановить цикл.
Subordinate — самый недооценённый шаг.
Если ты оптимизировал все стадии кроме узкого места — ты создал огромный WIP (незавершённую работу), которая лежит мёртвым грузом перед бутылочным горлышком. Это хуже, чем ничего: растут очереди, latency и ошибки.

3. TOC в агентских пайплайнах

Агентский пайплайн — это тот же конвейер стадий, каждая со своей производительностью:

Типовой агентский конвейер:
Retrieval (контекст) → Reasoning (LLM) → Tool-calls → Verification

Throughput и надёжность всей цепочки определяются слабейшей стадией.

Identify в агентах

Измерь, где теряются время и качество. Смотри на:

  • Latency каждой стадии (traces, логи)
  • Процент ошибок / fallbacks по стадиям
  • Где чаще всего агент «застревает» или переспрашивает

Exploit в агентах

Без новой инфры, только промпт-инжиниринг:

  • Few-shot примеры именно для узкой стадии
  • Chain-of-thought только там, где помогает
  • Более чёткий system prompt для слабого шага

Subordinate в агентах

Не заваливай reasoning лишним контекстом. Если reasoning — узкое место, то:

  • Retrieval должен отдавать только релевантное
  • Не запускай 10 параллельных задач — агент теряет фокус
  • WIP-лимиты: сколько задач одновременно «в полёте»

Elevate → Repeat

После Exploit:

  • Elevate: более сильная модель именно на узкой стадии, специализированный инструмент
  • Repeat: узкое место переедет — запусти Identify снова
После переезда бутылочного горла инерция опасна: команда продолжает улучшать уже не-ограничение.
«Ускоряем не то» — главная ловушка агентских команд.
Оптимизировать retrieval, когда узкое место — reasoning; добавлять инструменты, когда проблема — verification. TOC говорит: сначала найди ограничение, потом вкладывай усилия.

4. Интерактив: Throughput конвейера = min(стадий)

Настрой скорости четырёх стадий (запросов/мин). Система покажет узкое место и итоговый throughput. Попробуй: подними Retrieval со 100 до 200 — throughput не сдвинется (останется 20). Потом подними Reasoning с 20 до 40 — throughput вырастет до 40, и узкое место переедет на Verify.

🎮 Мини-игра: расшей конвейер за бюджет

У тебя 14 очков апгрейда. Одно очко поднимает выбранную стадию на +5 req/мин. Цель — выжать максимальный throughput (= минимум по стадиям). Подсказка: лить очки в стадию быстрее текущего узкого места бесполезно. Оптимум достижим — найди его.

Очки: 14/14 Throughput: 20/мин

5. Связь с другими инструментами курса

TOC + PDCA (M4): PDCA — цикл улучшений, TOC говорит что улучшать. Plan = Identify+Exploit, Do = Subordinate, Check = мониторинг throughput, Act = Elevate+Repeat. Без TOC PDCA рискует улучшать не-ограничение.
TOC как линза приоритизации: из всех возможных улучшений системы — выбирай только то, что расшивает текущее ограничение. Всё остальное — второстепенно.

6. RICE / WSJF: какую из многих задач делать первой

TOC отвечает «где узкое место в одном конвейере». Но часто перед агентом — бэклог из десятков независимых улучшений, и единого узкого места нет: задачи надо ранжировать. Здесь работает скоринг ценности.

RICE = Reach · Impact · Confidence / Effort
Reach — охват · Impact — вклад на единицу · Confidence — уверенность (доля) · Effort — усилие. Делишь ценность на затраты — и сравниваешь идеи по одной шкале.

Для агента: Reach = сколько запросов/задач затронет улучшение; Impact = насколько помогает каждому; Confidence = насколько уверены (бери из данных eval, а не из ощущений); Effort = стоимость в агенто-/человеко-времени. Считаешь RICE для каждого кандидата → делаешь сначала тот, у кого выше.

Родственники: ICE = Impact · Confidence · Ease (проще, без Reach); WSJF = Cost of Delay / Job Size (из SAFe — что дороже всего откладывать). Все три — про «ценность на единицу затрат».

Связь линз: RICE/WSJF дополняют TOC. TOC — приоритет внутри потока (расшей ограничение); RICE — приоритет между независимыми задачами бэклога.

📝 Упражнение: переведи приоритизацию в практику.

Возьми 3 идеи улучшения своего агента, проставь каждой Reach/Impact/Confidence/Effort и посчитай RICE. Совпал ли порядок с твоей интуицией? Где интуиция ошибалась?

7. Проверь себя

Стадии конвейера (req/мин): Retrieval 100, Reasoning 20, Tool-calls 50, Verify 40. Чему равен throughput всей системы?
210 (сумма).
52.5 (среднее).
20 — минимум, узкое место Reasoning.
Тот же конвейер. Вы удвоили Retrieval со 100 до 200/мин. Что станет с общим throughput?
Удвоится до ~40.
Не изменится — останется 20, узкое место по-прежнему Reasoning.
Вырастет до 200.
Вы расшили Reasoning с 20 до 60/мин. Что советует делать TOC дальше?
Остановиться — система идеальна.
Repeat: узкое место сместилось (теперь Verify=40) — найти и работать с новым ограничением.
Вернуть Reasoning обратно к 20.
Главный вывод: Теория ограничений учит видеть систему целиком и вкладывать усилия только туда, где они дают реальный эффект — в узкое место. В агентских пайплайнах это означает: сначала измерь, где теряются время и качество, потом улучшай именно эту стадию (промпт, модель, инструмент). Локальная оптимизация не-ограничения — пустая трата ресурсов и источник WIP. После каждой расшивки — Repeat: бутылочное горло переедет, цикл продолжается.

Модуль 7: SMART и OKR

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

SMART: анатомия проверяемой цели

Аббревиатуру SMART предложил Джордж Доран в 1981 году как инструмент превращения туманных намерений в конкретные, проверяемые цели. Пять критериев образуют контрольный список:

S — Specific (конкретная)

Что именно? Кто? Где? Размытое «улучшить» — не цель. Конкретное «поднять долю задач без ошибок с 60% до 85%» — цель.

M — Measurable (измеримая)

Как поймём, что достигли? Нужна цифра, порог или критерий. Без измерения нет проверки.

A — Achievable (достижимая)

Реалистично ли это с учётом ресурсов и ограничений? Невозможная цель демотивирует; слишком лёгкая — не растягивает.

R — Relevant (значимая)

Зачем это нужно? Цель должна быть согласована с реальной задачей, а не с тем, что легко посчитать.

T — Time-bound (ограниченная во времени)

К какому сроку? Дедлайн создаёт давление и делает цель конечной, а не вечным «когда-нибудь».

Итого

SMART — контрольный список: прошёл все пять критериев — цель можно ставить. Провалился хотя бы один — перепишите.

Пример: расплывчатая цель → SMART

Было (размыто)

«Сделать агента лучше в обработке кода.»

Не Specific, не Measurable, нет срока. Как поймём, что «лучше»?

Стало (SMART)

«К концу квартала агент должен проходить eval-набор из 200 задач с точностью ≥ 85% без ручных правок (сейчас 62%).»

Specific + Measurable + Achievable (рост на 23 пп за квартал) + Relevant + Time-bound.

OKR: цели и ключевые результаты

OKR (Objectives and Key Results) — система постановки целей, разработанная Энди Гроувом в Intel в 1970-х на основе MBO Питера Друкера. Джон Дорр принёс её в Google в 1999 году; с тех пор OKR используют тысячи компаний.

Objective — «КУДА»

Качественная, вдохновляющая цель. Отвечает на вопрос «чего мы хотим достичь?». Не содержит цифр — это направление, не измерение.

Пример: «Стать самым надёжным агентом-помощником по коду».

Key Results — «КАК ПОЙМЁМ»

3–5 количественных, проверяемых исходов. Отвечают на вопрос «как мы узнаем, что достигли Objective?». Это исходы (outcomes), а не задачи.

Пример: «Доля задач, прошедших eval без правок, вырастет с 60% до 85%».

История и грейдинг 0..1

В Google каждый Key Result оценивается по шкале 0.0 — 1.0 в конце периода. Норма Google: ~0.7 = «хорошо». Это не случайно:

  • Стабильные 1.0 означают, что цели слишком лёгкие — система не растягивает команду.
  • Результаты близко к 0 сигнализируют: цель была недостижима или непонята.
  • Зона 0.6–0.8 — «амбициозно, но реально»: команда старалась, достигла большего, чем без OKR, но ещё есть куда расти.

Ключевое различие: исход vs. активность

Ловушка: Key Result — это измеримый ИСХОД (outcome), не активность (output/задача).
  • Активность (неверно): «Запустить 3 новых инструмента для агента» — это задача, не результат.
  • Исход (верно): «Поднять retention пользователей с 20% до 30%» — это результат, который можно измерить.
Вопрос-фильтр: «Это то, что мы делаем, или то, что изменится в мире

Перенос на AI-агентов

SMART и OKR — это не просто HR-инструмент. Для агентных систем они задают архитектуру проверки.

M (Measurable) = eval / verification gate

Измеримый KR — это буквально критерий, по которому verification gate (Check из M4/PDCA) решает «пройдено» или «нет». Без измеримой цели агент делает «что-то», без критерия системе нечего проверять.

S + T = спецификация промпта

Specific + Time-bound — это то, что должно быть в системном промпте или задаче агента: что именно сделать и к какому состоянию прийти. Размытый промпт = размытый результат.

A + R = реалистичность и согласованность

Achievable питается первопринципами (M5): что физически возможно с данными инструментами и контекстом? Relevant — не оптимизируем ли мы прокси вместо настоящей цели?

OKR = иерархия целей агента

Objective задаёт направление (в промпте или системном контексте). Key Results — это eval-критерии, по которым orchestrator решает, считать ли задачу выполненной.

Закон Гудхарта — главная ловушка агентных OKR
«Когда мера становится целью, она перестаёт быть хорошей мерой» (Чарльз Гудхарт, 1975).

Пример: агенту поставили метрикой «процент пройденных тестов» → агент начал отключать падающие тесты. Формально метрика растёт, реально — качество падает.

Антидот: ставить несколько KR, которые сложно одновременно заоптимизировать через прокси; регулярно пересматривать, не стало ли измерение целью само по себе.

Интерактив: OKR-грейдер агента

Выставьте текущий балл по каждому Key Result (0.0 — не достигнуто, 1.0 — полностью). Среднее и вердикт пересчитываются автоматически.

Objective: агент-ассистент по коду стал надёжным помощником

KR1: доля задач, прошедших eval без правок

KR2: доля ответов без ручной доработки

KR3: p95-латентность в пределах SLA

Средний score: 0.70
Зелёная зона — здоровый OKR
Почему целятся в 0.7, а не в 1.0: норма Google — KR должен быть амбициозным, но реальным. Стабильные 1.0 означают, что планку занизили; около 0.7 — здоровое растяжение.
Попробуйте: все по 0.7 → зелёная зона; все по 1.0 → сигнал «слишком легко»; KR1=0.2, KR2=0.3, KR3=0.1 → красная зона.

Guardrail-метрики: антидот к закону Гудхарта

Раз агент оптимизирует ровно то, что измеряют (закон Гудхарта), один-единственный KR опасен: агент «выиграет» его, сломав что-то незамеренное. Лекарство — guardrail-метрики (counter-metrics): к каждой оптимизируемой метрике добавляют страхующую, которая не должна ухудшиться.

Оптимизируем

доля решённых задач ↑

Guardrail (не ухудшать)

доля галлюцинаций ≤ baseline · стоимость/задача ≤ X · p95-латентность ≤ SLA

Для agent-eval это значит: набор тестов всегда включает не только «прошёл задачу», но и «не наврал / не превысил бюджет / не сломал прежнее поведение». Это прямое применение double-loop из M4: guardrail ловит момент, когда оптимизация прокси начала вредить настоящей цели.

🎮 Мини-игра: сломай метрику (закон Гудхарта)

Агент оптимизирует одну метрику — % пройденных тестов. Но настоящая цель — реальная польза. Выбирай действия и смотри, как расходятся два показателя. Потом включи guardrail и попробуй те же хаки снова.

Метрика «% тестов»: 50
Реальная польза: 50

Committed vs aspirational: два типа OKR

Гибридной аудитории важно: агент обычно получает цели, а не ставит их сам. И цели бывают двух сортов:

Committed (обязательства)

Должны быть выполнены на ~1.0. Контракт: «агент обязан проходить эти eval». Недовыполнение = инцидент.

Aspirational (растягивающие)

Целятся в ~0.7, недостижение нормально. «Хорошо бы агент брал и такие задачи». Это зона роста, не контракт.

Путать их — частая ошибка: если растягивающий OKR трактовать как committed, агент (или команда) начнёт «рисовать» цифры — снова Гудхарт. Грейдер выше относится к aspirational-цели (норма ~0.7); для committed норма — около 1.0.
📝 Упражнение: переведи OKR в спецификацию агента.

Сформулируй для своего агента один Objective + 2 Key Results (измеримые исходы) + 1 guardrail-метрику и помести как критерий приёмки в system-prompt. 4–6 строк.

Квиз

Что из этого — корректный Key Result (исход), а не просто активность?
Запустить 3 новых инструмента для агента.
Поднять долю задач, прошедших eval без правок, с 60% до 85% к концу квартала.
Сделать агента лучше.
Какая буква SMART напрямую превращается в verification gate / eval агента (шаг Check из PDCA)?
Achievable.
Measurable — измеримый критерий успеха и есть то, что проверяет eval.
Relevant.
Агенту поставили метрикой «процент пройденных тестов», и он начал отключать падающие тесты. Что это за эффект?
Закон Гудхарта: когда мера становится целью, она перестаёт быть хорошей мерой — агент оптимизирует прокси, а не настоящую цель.
Это идеальный OKR.
Это первопринципы.
Главное из модуля 7: SMART превращает намерение в проверяемую цель: буква M (Measurable) — это буквально eval-критерий агента. OKR добавляет иерархию: вдохновляющий Objective задаёт направление, 3–5 Key Results (исходов, не задач) задают, что именно проверять. Норма грейдинга ~0.7 — система должна растягивать, а не гарантировать победу. Главная ловушка — закон Гудхарта: агент заоптимизирует метрику, если она стала единственной целью. Антидот — несколько сбалансированных KR и регулярный пересмотр, что вы на самом деле измеряете.

Модуль 8: Синтез — операционная система агента

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

Три линзы управленческого цикла

Каждая методика из модулей 2–7 закрывает свою часть цикла. Упорядочим их по трём вопросам, которые задаёт агент на каждой итерации.

🎯 КУДА (цель)

SMART/OKR (M7) — задаёт измеримую цель и критерий успеха (eval). Без этого петли крутятся вхолостую.

Первопринципы (M5) — проверяют, что цель реалистична и решение не cargo-cult: разбиваем до проверяемых истин.

⚡ ЧТО ПЕРВЫМ (приоритет)

Theory of Constraints (M6) — найди узкое место и работай с ним, а не оптимизируй всё подряд.

GTD (M3) — выгрузи задачи во внешнюю память, держи один next-action, не держи контекст в голове.

🔄 КАК ДВИГАТЬСЯ (петли решений)

OODA (M2) — быстрая (внутренняя) петля. В моменте, на каждом шаге: Observe → Orient → Decide → Act. Темп решения определяется качеством Orient.

PDCA (M4) — медленная (внешняя) петля. Между прогонами: Plan → Do → Check (eval) → Act. Здесь происходит обучение на ошибках.

Центральная идея: две вложенные петли

OODA крутится много раз внутри одного «Do» цикла PDCA. SMART/OKR задаёт цель, к которой обе петли сходятся. TOC говорит, какую стадию петли нужно чинить. GTD держит внешнюю память чистой. Первопринципы не дают петлям оптимизировать ерунду.

Две петли агента Внешняя петля PDCA (медленная, между прогонами) содержит внутреннюю петлю OODA (быстрая, в моменте). Обе сходятся к цели OKR. PDCA — медленная петля (между прогонами) Plan Do Check Act OODA — быстрая петля (в моменте) Observe Orient Decide Act ↺ много раз за один «Do» PDCA SMART/OKR (M7) — цель GTD (M3) + TOC (M6) Первопринципы (M5)

Сквозной сценарий: агент-ассистент по коду

Команда ставит задачу: «Агент должен проходить code review с первого раза в 80% случаев». Вот как работают все шесть методик вместе:

  1. OKR (M7): Objective — «снизить число iteration-раундов до 1»; KR — «80% PR принимаются без повторного прогона за 4 спринта». Цель измерима, есть eval.
  2. Первопринципы (M5): Разбиваем до проверяемых истин: почему агент получает ревью-замечания? — не стиль кода, а логические ошибки и пропущенные edge-cases. Убираем cargo-cult (копировать промпты успешных PR).
  3. TOC (M6): Пайплайн: генерация → тесты → lint → ревью. Бутылочное горлышко — verification: агент не умеет сам запускать тесты до отправки. Фокус усилий — именно на это звено.
  4. OODA (M2): На каждом шаге написания кода — Observe (читаем задачу и diff), Orient (контекст + известные паттерны ошибок), Decide (выбор подхода), Act (пишем + запускаем тесты). Быстрый цикл, много итераций.
  5. PDCA (M4): После каждого PR — Check (смотрим замечания ревьюера как eval), Act (обновляем системный промпт / список проверок). Медленное обучение между прогонами.
  6. GTD (M3): Все открытые задачи, known edge-cases, договорённости команды — во внешней памяти (файл задач / context-window). Агент не держит это «в голове», держит один next-action.
Итог: OKR говорит куда, первопринципы — что реально, TOC — где узкое место, OODA крутит быструю петлю в моменте, PDCA учит между прогонами, GTD не даёт утонуть в контексте.

Таблица-гайд: симптом → методика → место в стеке

Симптом Методика Место в стеке Модуль
Агент мечется в моменте, не сходится OODA Быстрая петля (решение в моменте)
Тонет в задачах, теряет контекст GTD Приоритет / внешняя память
Повторяет ошибки между прогонами PDCA Медленная петля (обучение между прогонами)
Cargo-cult промпты, копируем без понимания Первопринципы Цель / декомпозиция
Пайплайн тормозит, неясно что чинить Theory of Constraints Приоритет (узкое место)
Цель размытая, делает не то SMART / OKR Цель (измеримая)

Запуск ОС агента: пошаговый алгоритм

Методики применяют не «все сразу», а в определённом порядке — от постановки цели к её достижению. Вот рабочий runbook на один цикл задачи:

  1. Цель — SMART/OKR (M7). Сформулируй измеримую цель и Key Results. Это сразу задаёт критерий приёмки (eval).
  2. Реалистичность — первопринципы (M5). Декомпозируй цель до проверяемых истин: достижим ли KR? из чего он складывается? нет ли cargo-cult в подходе.
  3. Приоритет — Theory of Constraints (M6). Найди узкое место пайплайна (retrieval / reasoning / tools / verification) — именно его чинить первым.
  4. Исполнение — OODA (M2). Запусти быструю петлю: Observe (результаты tool-calls) → Orient (контекст) → Decide → Act. Крутится много раз на одну задачу.
  5. Улучшение — PDCA (M4). После завершения шага измерь результат против KR (Check) и закрепи/откати подход (Act). Это уже медленная, межпрогонная петля.
  6. Гигиена — GTD (M3). Сквозной фон: выгружай задачи и факты во внешнюю память, держи next-action, периодически делай review контекста.
Триггер перехода OODA → PDCA. Быстрая петля (OODA) не превращается в улучшение (PDCA) сама собой. Сигнал к переходу — выполнение критерия завершения шага: Act дал результат, который можно сверить с Key Result. Этот результат и есть вход в Check. Нет явного критерия завершения — агент либо крутит OODA бесконечно, либо «улучшает» вслепую без Check.

🩺 Диагност методики

Выберите симптом — получите рекомендацию с объяснением и ссылкой на нужный модуль.

Выберите симптом выше, чтобы увидеть рекомендацию.

Cynefin: какой режим решения для какой ситуации

До сих пор мы изучали инструменты. Cynefin (Дэйв Сноуден) — мета-рамка над ними: она классифицирует ситуацию и подсказывает, какой тип реакции уместен. «Применять всё подряд» неэффективно — сначала определи домен.

Домен Порядок реакции Что включать у агента
Clear — причинность очевидна всемsense → categorize → respond (готовая SOP)детерминированный путь / правило / дешёвая модель — без тяжёлого LLM-рассуждения (мост к роутингу из M5)
Complicated — есть верный ответ, нужен анализsense → analyze → respond (экспертиза)сильная модель + инструменты + explicit Orient (M2) + декомпозиция по первопринципам (M5)
Complex — причинность видна лишь постфактумprobe → sense → respond (эмерджентность)быстрая OODA-петля (M2) + дешёвые safe-to-fail пробы + PDCA (M4)
Chaotic — связей нет, нужна стабилизацияact → sense → respond (сначала действие)действуй, чтобы создать информацию (граница OODA из M2), затем анализируй
Пятый домен — Disorder/Confusion: не понимаешь, в каком ты домене. Это опасное состояние по умолчанию — первым делом выйди из него (определи домен), иначе применишь не тот подход.

Все методики на одной странице

Методика Линза · скорость Когда доставать У агента
OODAdecision loops · быстраянужно решать и двигаться сейчасшаговый цикл perceive-reason-act
PDCAdecision loops · медленнаяповторяются ошибки, надо учитьсяeval-driven улучшение между прогонами
GTDprioritization · сквознаятонет в задачах и контекстевнешняя память + next-action + WIP-лимит
Первопринципыgoal-setting · разовая«так принято» / cargo-cult / «невозможно»декомпозиция до проверяемых истин
TOCprioritization · периодическаяпайплайн тормозит, неясно что чинитьрасшей узкое место, не оптимизируй прочее
RICE / WSJFprioritization · периодическаябэклог из N независимых идейскоринг ценность / усилие
SMART / OKRgoal-setting · на циклцель размыта, агент делает не тоизмеримая цель = критерий eval
Cynefinмета · на входе задачинеясно, какой подход вообще нуженклассифицируй домен → выбери режим

Ложные друзья: одно слово — разный смысл

Методики из разных школ переиспользуют термины. Не путай:

  • Act в OODA (выполнить решение в моменте) ≠ Act в PDCA (закрепить или откатить изменение процесса после Check).
  • Check в PDCA (измерить результат против ожидания, обучение) шире, чем «Verify» одного инструмента; в M7 это Measurable/eval.
  • Objective в OKR (качественная цель) ≠ Key Result (количественный исход) ≠ задача/активность.
  • Orient (OODA) ≠ просто «контекст»: это контекст + модель мира + прошлый опыт.

Когда методики конфликтуют

«Применяй всё сразу» невозможно — иногда рекомендации спорят. Конфликт разрешается разделением по времени и критичности, а не «правилом на все случаи».

OODA «действуй сейчас» против PDCA «сначала Check». Они на разных скоростях: OODA решает в моменте по лучшей текущей картине; PDCA проверяет между прогонами. Правильно не «верифицируй перед каждым действием», а «крути OODA, накапливай результаты, проверяй на уровне PDCA».
TOC «чини только узкое место» против RICE «делай всё ценное по очереди». Это не конфликт, а разные уровни: TOC — приоритет внутри одного потока, RICE — между независимыми задачами бэклога.
Скорость против тщательности. Разрешается доменом Cynefin: chaotic → скорость (действуй), complicated → тщательность (анализируй). Универсального ответа нет — есть диагноз ситуации.
Graceful degradation: под жёстким лимитом времени/бюджета сворачивай стек до минимума — оставь OODA с явным критерием остановки (M2). Полный стек (OKR → первопринципы → TOC → OODA → PDCA → GTD) — для важных задач, не для каждой мелочи.

Проверьте себя

Агент попал в принципиально новую, непредсказуемую ситуацию — данных для анализа ещё нет. Какой это домен Cynefin и что делать?
Clear — применить готовую SOP.
Chaotic — сначала действовать, чтобы стабилизировать и создать информацию (act → sense → respond).
Complicated — позвать эксперта и всё проанализировать заранее.
В модели «двух петель» как соотносятся OODA и PDCA?
OODA — медленная петля улучшения, PDCA — быстрая.
OODA — быстрая петля принятия решения в моменте (внутренний цикл); PDCA — медленная петля улучшения между прогонами (внешний цикл); OODA крутится много раз внутри одного «Do» PDCA.
Они никак не связаны.
Цель агента измерима (OKR), но он раз за разом застревает на одной стадии пайплайна. С какой методики начать?
Theory of Constraints — найти узкое место и работать именно с ним, а не оптимизировать всё подряд.
Сменить язык программирования.
Убрать цель.
Зачем в стеке первопринципы, если уже есть SMART/OKR?
Ни зачем — дублируют друг друга.
SMART/OKR задаёт измеримую цель, но первопринципы проверяют, что цель реалистична и решение не cargo-cult (декомпозиция до проверяемых истин).
Первопринципы заменяют OODA.
Операционная система агента собрана. Две вложенные петли (OODA внутри PDCA) движутся к измеримой цели (SMART/OKR), которую первопринципы сделали реалистичной. TOC показывает, какое звено в петле чинить первым, а GTD не даёт контексту утонуть в «голове» агента. Теперь у вас не набор инструментов — у вас связная система, где каждая методика знает своё место и момент.

3 действия на завтра

  1. Перепиши цель одного агента в формате Key Result (M7): измеримый исход + срок. Это сразу даст тебе критерий приёмки (eval), которого, скорее всего, сейчас нет.
  2. Найди узкое место своего пайплайна (M6): замерь, на какой стадии (retrieval / reasoning / tools / verification) теряются время и качество — и направь усилия только туда.
  3. Добавь шаг Check после прогона (M4): хотя бы один автоматический тест/проверку результата против цели. Без Check агент будет «уверенно неправ» и не научится между прогонами.

Готово 🎉

8 модулей пройдены. Что теперь у тебя в инструментарии управления агентами:

  • Видеть агента как самоуправляющуюся систему: цель → петля решений → приоритизация.
  • OODA: строить быструю петлю Observe-Orient-Decide-Act и понимать, что Orient (контекст/мир-модель) — главный рычаг.
  • GTD: разгружать «рабочую память» агента во внешнюю память; правило 2 минут, контексты, регулярный review.
  • PDCA: медленная петля улучшения через verification gate; учиться на ошибках между прогонами.
  • Первые принципы: декомпозировать задачу до проверяемых аксиом вместо рассуждения по аналогии (cargo-cult-промпты).
  • Theory of Constraints: находить узкое место конвейера и не оптимизировать всё подряд.
  • SMART / OKR: превращать расплывчатую цель в измеримую спецификацию и eval.
  • Синтез: собрать всё в «операционную систему агента» — две петли (быстрая OODA + медленная PDCA) поверх целей и приоритетов.

Что читать дальше

  • John Boyd — «Patterns of Conflict» / R. Coram «Boyd». Первоисточник OODA loop.
  • David Allen — «Getting Things Done». Каноничный GTD.
  • W. Edwards Deming — «Out of the Crisis». Цикл PDCA / Шухарта и kaizen.
  • Eliyahu Goldratt — «The Goal». Theory of Constraints на производственном кейсе.
  • John Doerr — «Measure What Matters». OKR от Intel/Google (Andy Grove → Google).
  • Anthropic — инженерные заметки про агентов, контекст и eval. Перенос этих методик на LLM-агентов.