TL;DR
NPO — это способ улучшать промпт, который просто раз за разом прогоняет его, собирает реальные результаты (что получилось, что нет) и отдаёт всё это сильной модели с просьбой переписать промпт. Никакого дерева вариантов, никакого отбора "лучшего из десяти" — один промпт, который на каждом шаге правится с учётом свежих ошибок.
Все современные системы автооптимизации промптов усложняют себе жизнь: генерируют пул кандидатов, сравнивают их между собой, отбирают лучших через сложные алгоритмы — как будто чем изощрённее перебор, тем лучше результат. Но если "редактор" промпта (модель, которая его переписывает) достаточно умная, вся эта сложность оказывается лишней тратой: разница между "простым переписыванием" и "сложным перебором вариантов" почти исчезает, а иногда простой способ даже выигрывает.
Метод работает в три шага: прогнать текущий промпт на пачке примеров → собрать результаты и оценки за последние несколько попыток (окно) → отдать всё сильной модели с просьбой переписать промпт, учитывая эти провалы и удачи. Повторить несколько раз.
Схема метода
ШАГ 1: Прогнать текущий промпт на N примерах задачи → собрать ответы + оценку (сработало/не сработало)
ШАГ 2: Взять окно из последних W таких прогонов (промпт + результаты + оценки) →
показать сильной модели-редактору → она переписывает промпт целиком
ШАГ 3: Повторить с новым промптом Y раз, каждый раз сдвигая окно вперёд
Все шаги выполняются как отдельные обращения к модели (нужно несколько запросов, не один).
Пример применения
Задача: У вас Telegram-бот поддержки для интернет-магазина (условно как у продавца на Ozon), который отвечает клиентам по правилам возврата и доставки. Бот иногда путается: то забывает про исключения для акционных товаров, то неправильно называет сроки.
Промпт:
Ты — эксперт по промпт-инжинирингу. Твоя задача — улучшить системный промпт для чат-бота поддержки.
Текущий промпт бота:
---
{текущий_промпт_бота}
---
Вот 6 реальных диалогов за последнюю неделю, где бот ошибся или сработал хорошо:
Диалог 1:
Клиент: {вопрос_1}
Ответ бота: {ответ_1}
Что не так: {ошибка_1}
Диалог 2:
Клиент: {вопрос_2}
Ответ бота: {ответ_2}
Что не так: {ошибка_2}
... (остальные диалоги)
Перепиши промпт так, чтобы устранить повторяющиеся ошибки. Не убирай рабочие инструкции без причины. Выдай полную новую версию промпта.
Результат: Модель выдаст переписанную версию промпта — обычно с добавленными явными правилами-исключениями и уточнениями формулировок в тех местах, где бот путался. Дальше вы ставите новый промпт в бота, через несколько дней собираете новую пачку диалогов и повторяете цикл — с каждым разом промпт становится точнее.
Почему это работает
Промпт, написанный "на глаз", не учитывает реальные пограничные случаи — автор просто не может предугадать все ситуации, где модель споткнётся. Сложные алгоритмы перебора вариантов пытаются решить это генерацией множества версий и отбором лучшей, но если модель-редактор сама по себе сильная, все её варианты получаются примерно одного уровня — перебор не добавляет пользы.
Сильная модель, глядя на конкретные провалы (реальные диалоги, а не абстрактное "плохо работает"), точно видит причину ошибки и правит инструкцию прицельно — как хороший редактор с комментариями на полях, а не как человек, гадающий вслепую.
Рычаги управления: - Размер окна (сколько последних попыток показываем модели) — больше окно = больше контекста для правки, но упирается в лимит контекста модели - Количество примеров за раз — больше примеров даёт стабильнее сигнал, но дороже по токенам - Сила модели-редактора — чем умнее модель, тем меньше нужно итераций для того же результата - Явная оценка каждого примера (не просто "ошибка", а "1-10, почему") — помогает редактору точнее понимать, что менять
Шаблон промпта
Ты — опытный промпт-инженер. Твоя задача — улучшить промпт на основе реальных результатов его работы.
Текущий промпт:
---
{текущий_промпт}
---
Вот результаты последних {число} попыток использования этого промпта:
Попытка 1:
Вход: {вход_1}
Ответ модели: {ответ_1}
Оценка: {что_сработало_или_не_сработало_1}
Попытка 2:
Вход: {вход_2}
Ответ модели: {ответ_2}
Оценка: {что_сработало_или_не_сработало_2}
(добавь остальные попытки по этому же шаблону)
Перепиши промпт так, чтобы:
1. Устранить повторяющиеся ошибки
2. Сохранить то, что уже работает хорошо
Выдай полную новую версию промпта.
Подставляй: {текущий_промпт} — версия, которую хочешь улучшить; {вход_N} и {ответ_N} — реальные примеры использования; {что_сработало_или_не_сработало_N} — твоя оценка (можно словами, можно баллом).
🚀 Быстрый старт — вставь в чат:
Вот шаблон итеративной оптимизации промпта. Адаптируй под мою задачу: {твоя задача}.
Задавай вопросы, чтобы заполнить поля.
[вставить шаблон выше]
LLM спросит, какой у тебя текущий промпт и есть ли примеры его реальной работы — потому что без конкретных провалов и удач метод не имеет материала для правки, а без этого он превращается в гадание "на глаз", то есть в то, от чего метод и должен избавить.
Ограничения
⚠️ Нужны проверяемые примеры провалов: метод требует реальных прогонов промпта с оценкой результата. Если у тебя нет ни одного диалога/ответа, где промпт сработал не так — метод не с чем работать.
⚠️ Слабее для полностью субъективных задач: там где нет чёткого критерия "правильно/неправильно" (творческий текст, стиль, вкус) — эффект от такой правки менее предсказуем, чем на задачах с ясным правилом.
⚠️ Не заменяет глубокое дообучение для сложных многошаговых задач: в задачах, где модели нужно "выучить" долгую стратегию (например, сложная многоходовая игра или процесс с долгой памятью), дообучение самой модели иногда даёт больше, чем любая правка инструкции.
Как исследовали
Исследователи сравнили простую линейную правку промпта (NPO) со сложным методом GEPA (который держит целое дерево вариантов промпта и отбирает лучшие через сложный алгоритм) и с дообучением весов модели через RL (GRPO). Тестировали на задачах на соблюдение инструкций, многошаговых вопросах-ответах и 22 стратегических играх. Чтобы сравнение было честным, все методы прогоняли на одинаковых сгенерированных случайных задачах — не разных, а идентичных — и жёстко следили, чтобы ошибки формата ответа не портили сравнение.
Главный сюрприз: простой метод с сильным "редактором" (GPT-5.5) обгонял сложный алгоритм перебора, используя меньше попыток — и разрыв рос вместе с силой редактора. При этом сложный метод почти не выигрывал от более сильного редактора — как будто вся его сложность съедала преимущество умной модели. В стратегических играх картина смешанная: там, где нужна долгая память и адаптация поведения, дообучение весов модели иногда обгоняло любую правку промпта. Отдельно проверили перенос: промпт, доведённый до ума на маленькой модели, почти без потерь работал и на других моделях, даже из другого семейства — то есть один раз улучшенный промпт можно переиспользовать.