3,583 papers
arXiv:2601.21684 78 29 янв. 2026 г. FREE

RSE (Recycling Search Experience): накопительный поиск решений через переработку опыта попыток

КЛЮЧЕВАЯ СУТЬ
Обнаружено: LLM страдает системной потерей памяти — при генерации 100 попыток решения каждая изолирована, модель заново выводит одни и те же промежуточные шаги и наступает на те же грабли. Для задачи требующей вывести 5 шагов подряд (каждый с точностью 70%) вероятность успеха в одной попытке = 0.7⁵ ≈ 17%. Метод RSE превращает изолированные попытки в кумулятивный процесс: генерируешь батч → дистиллируешь опыт (доказанные блоки + тупики) → следующий батч стартует с этим банком. Модель собирает решение из фрагментированных частичных успехов вместо попыток вывести всю цепочку за раз — вероятность скачет с 17% до 70%.
Адаптировать под запрос

TL;DR

RSE — техника, которая превращает множественные попытки решения из изолированных бросков в накопительный процесс. Модель делает попытки партиями, после каждой партии извлекает что точно работает и какие подходы в тупик, добавляет в "банк опыта" и использует его в следующих партиях. Вместо того чтобы каждый раз начинать с нуля, модель строит решение из накопленных кусочков истины.

Стандартный подход к сложным задачам — сделать много независимых попыток и выбрать лучшую. Проблема: каждая попытка работает в вакууме. Модель заново выводит одни и те же промежуточные факты в разных ветках ("если X, то Y" выводится 10 раз) и наступает на те же грабли (пробует подход Z, который не работает, снова и снова). В сложных задачах вероятность вывести ВСЕ нужные шаги в одной попытке падает экспоненциально с ростом сложности — большинство попыток содержат правильные куски, но не всю картину целиком.

RSE работает циклами: партия попыток → модель сама извлекает позитивный опыт (проверенные промежуточные выводы, работающие подходы) и негативный опыт (найденные тупики, ошибочные стратегии) → записывает в общий банк → удаляет дубликаты → следующая партия стартует с этим банком в контексте. Позитивный опыт позволяет переиспользовать промежуточные выводы как готовые блоки ("Y уже доказан, можно использовать"). Негативный опыт отсекает тупиковые ветки ("подход Z не работает по причине W, не трать время"). Каждая партия сужает пространство поиска и накапливает истину.

🔬

Схема метода

[Цикл повторяется 3-6 раундов]

РАУНД 1: 
├─ Генерация → 8-32 попытки решения параллельно [один запрос]
├─ Извлечение опыта → из каждой попытки модель извлекает:
│  ├─ Позитивное: "Что точно верно" (факты, леммы, промежуточные выводы)
│  └─ Негативное: "Какие подходы не сработали и почему"
└─ Дедупликация → удаление семантически одинаковых пунктов опыта

РАУНД 2:
├─ Контекст = банк опыта из Раунда 1
├─ Генерация → новые попытки с учётом опыта
├─ Извлечение → новый опыт добавляется к старому
└─ Дедупликация

РАУНД 3+: повторение

Важно: Попытки внутри раунда делаются параллельно (быстро), опыт извлекается после завершения всей партии.

🚀

Пример применения

⚠️ Метод для сложных многоэтапных задач. Не подходит для простых вопросов с прямым ответом. Эффективен там, где нужно свести воедино много промежуточных выводов из разных углов.

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

Промпт (Раунд 1):

Задача: Оценить реалистичность запуска маркетплейса локальных продуктов с окупаемостью за 12 месяцев.

Constraints:
- Бюджет: 5 млн рублей
- Конкуренты: Wildberries, Ozon уже работают с локальными в регионе
- Регуляции: маркировка "Честный знак", онлайн-кассы, ЕГАИС для части товаров
- Команда: 3 человека (основатель + разработчик + маркетолог)
- Регион: Екатеринбург и область

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

Промпт (Извлечение опыта после Раунда 1):

Вот 10 попыток анализа. Извлеки из них:

ПОЗИТИВНЫЙ ОПЫТ (что точно установлено и можно использовать как факт):
- Проверенные цифры, расчёты
- Подтверждённые инсайты о рынке
- Работающие стратегические подходы

НЕГАТИВНЫЙ ОПЫТ (какие подходы точно не работают и почему):
- Тупиковые стратегии
- Критические ошибки в рассуждениях
- Нереалистичные допущения

[вставить 10 анализов из Раунда 1]

Промпт (Раунд 2):

[тот же контекст задачи]

БАНК ОПЫТА из предыдущего раунда:

ПОЗИТИВНОЕ:
[извлечённые факты и выводы]

НЕГАТИВНОЕ:
[найденные тупики]

Теперь сгенерируй ещё 10 анализов, используя накопленный опыт. Не повторяй отвергнутые подходы, используй установленные факты как базу.

Результат: Модель покажет прогресс через раунды. Раунд 1: разнообразные попытки с повторяющимися базовыми расчётами и несколькими тупиковыми стратегиями (например, "конкурировать ценами с WB" отвергается во всех ветках). Раунд 2: опираясь на банк опыта, новые попытки уже не пересчитывают базовую экономику (CAC, средний чек) — используют проверенные цифры из банка. Тупиковая "ценовая война" больше не рассматривается. Исследуются более тонкие стратегии (партнёрство с фермерами, модель подписки). Раунд 3: консолидация в итоговый план с реалистичными цифрами, собранный из лучших кусков всех веток.

🧠

Почему это работает

Проблема независимых попыток: LLM генерирует текст слева направо, последовательно. В сложной задаче нужно вывести цепочку из 10+ промежуточных шагов. Вероятность "угадать" все правильные шаги в одной попытке падает экспоненциально. Результат: из 50 попыток большинство содержат правильные куски, но почти ни одна не собирает всю картину целиком. Стандартное голосование (majority voting) берёт финальные ответы и выбирает самый частый — но если правильный ответ в меньшинстве, метод ломается.

Сильная сторона: LLM хорошо критикует собственные рассуждения и вычленяет проверенные утверждения из траектории. Может сказать "вот это точно верно, а это под вопросом". Хорошо работает с явными инструкциями структуры — если попросить "найди тупики", модель найдёт их лучше, чем если просто генерировать снова.

Механика RSE: Партии попыток + извлечение опыта между партиями превращает задачу из "вывести всё правильно за один раз" в "собрать пазл из проверенных кусочков истины". Позитивный опыт работает как чекпоинты прогресса — промежуточные выводы, которые многие ветки подтвердили, становятся "аксиомами" для следующего раунда. Негативный опыт отсекает повторяющиеся ошибки — если 5 веток пробовали подход X и все упёрлись в стену, зачем пробовать снова?

Рычаги управления: - Размер партии (8-32 попытки): больше → выше шанс найти редкий инсайт, но дороже. Меньше → быстрее, но может пропустить важные углы. - Число раундов (3-6): больше → глубже консолидация, но есть риск сойтись к неправильному консенсусу. Меньше → экономия, но может не хватить для сложных задач. - Критерии извлечения опыта: можно настроить что считать "проверенным фактом" (согласие в нескольких ветках? явное доказательство?) — влияет на качество банка опыта. - Порог дедупликации: строгий → меньше повторов, но можно потерять нюансы. Мягкий → больше контекста, но риск раздуть банк опыта.

📋

Шаблон промпта

📌

Для ручного применения (упрощённая версия)

ШАГ 1 — Партия попыток:

Задача: {опиши задачу подробно}

Constraints:
{перечисли все ограничения и требования}

Сгенерируй {N} независимых попыток решения этой задачи. 
Каждая попытка должна рассмотреть проблему под своим углом.
Пронумеруй попытки.

ШАГ 2 — Извлечение опыта [отдельный запрос]:

Вот {N} попыток решения задачи:

[вставь все попытки из Шага 1]

Проанализируй их и извлеки:

ПОЗИТИВНЫЙ ОПЫТ — что точно установлено:
- Проверенные факты и расчёты
- Подтверждённые выводы (встречаются в нескольких ветках)
- Работающие подходы

НЕГАТИВНЫЙ ОПЫТ — что точно не работает:
- Стратегии, которые упираются в тупик
- Нереалистичные допущения
- Критические ошибки в рассуждениях

Группируй семантически одинаковые пункты — не дублируй.

ШАГ 3 — Следующая партия с опытом [отдельный запрос]:

Задача: {та же задача}

Constraints: {те же}

БАНК ОПЫТА из предыдущей партии:

ПОЗИТИВНЫЙ ОПЫТ:
{вставь из Шага 2}

НЕГАТИВНЫЙ ОПЫТ:
{вставь из Шага 2}

Сгенерируй ещё {N} попыток решения, используя накопленный опыт:
- Используй проверенные факты как базу
- Не повторяй отвергнутые подходы
- Фокусируйся на неисследованных углах

Пронумеруй попытки.

Повтори Шаги 2-3 ещё 2-4 раза (новая партия → извлечение опыта → следующая партия).

Плейсхолдеры: - {опиши задачу подробно} — твоя сложная многоэтапная задача - {перечисли все ограничения и требования} — бюджет, регуляции, конкуренты, команда и т.д. - {N} — размер партии, начни с 8-10 для баланса скорости и качества

🚀 Быстрый старт — вставь в чат:

Если схема кажется сложной, упрости через LLM:

Вот шаблон RSE для накопительного решения сложных задач. 
Адаптируй под мою задачу: [твоя задача]. 

Задавай вопросы: какие constraints важны, сколько попыток делать в партии, 
сколько раундов нужно для такой сложности.

[вставить шаблон выше]

LLM спросит про специфику задачи (какие ограничения критичны?), бюджет токенов (сколько попыток можешь позволить?), критерии качества опыта (что считать "проверенным фактом"?) — это нужно чтобы настроить размер партий и число раундов под твою ситуацию. Она возьмёт паттерн "партии → опыт → новые партии с опытом" и адаптирует под задачу.

🧠

Почему это работает

Геометрия вероятности в сложных задачах: Если задача требует 10 правильных промежуточных шагов, и модель делает каждый верно с вероятностью 60%, то шанс идеальной попытки = 0.6^10 ≈ 0.6%. Из 100 попыток в среднем только одна будет полностью правильной. Но! Каждая попытка содержит правильные куски — одна вывела шаги 1-4 верно, другая шаги 3-7, третья 6-10. Информация есть, но размазана по попыткам.

Стандартное голосование работает на уровне финальных ответов — если правильный ответ в меньшинстве (а в сложных задачах так и есть), метод выбирает популярный неправильный. Последовательное улучшение (Self-Refine) работает только с одной веткой — улучшает её итеративно, но застревает в локальном оптимуме этой ветки, не видя инсайтов из параллельных попыток.

RSE использует популяционный интеллект: Извлечение опыта — это голосование на уровне промежуточных выводов, не финальных ответов. Если факт F появился в 6 из 10 веток и во всех прошёл проверку — он с высокой вероятностью верен. Если подход X пробовали 4 ветки и все упёрлись — он скорее всего тупиковый. Модель собирает консенсус по кусочкам, а не по целому решению.

Дедупликация решает проблему раздутого контекста. В параллельных попытках базовые шаги повторяются — все ветки выводят "2+2=4", "средний чек = выручка/клиенты" и т.д. Без фильтрации банк опыта переполняется тривиальными повторами, вытесняя редкие инсайты. Семантическая дедупликация сжимает банк — оставляет один экземпляр каждого уникального инсайта, максимизируя плотность информации в ограниченном контексте.

Накопительный эффект через раунды: Раунд 1 находит очевидные факты и грубые тупики. Раунд 2, опираясь на них, не тратит токены на повторный вывод базы и исследует более тонкие стратегии. К Раунду 3-4 модель работает с высокоуровневой картой задачи — проверенные блоки истины + карта мёртвых зон. Вместо случайного блуждания в пространстве решений получается направленное сужение к работающим областям.

⚠️

Ограничения

⚠️ Сложность задачи: На простых задачах с прямым ответом введёт избыточность. Эффективен на многоэтапных задачах где одна попытка редко выдаёт полное решение (сложная аналитика, многофакторные решения, задачи требующие синтеза из разных областей). Если стандартное голосование даёт правильный ответ — RSE избыточен.

⚠️ Стоимость: Требует 3-6 раундов по 8-32 попытки = 24-192 запуска на задачу + запросы извлечения опыта. Дорого по токенам. Оправдано только когда правильное решение критично и стоит затрат (важные бизнес-решения, сложный анализ, исследовательские задачи). Для рутины неэкономично.

⚠️ Консенсус ≠ истина: Метод ищет согласие между ветками, не абсолютную истину. Если модель систематически ошибается в определённом аспекте, все ветки могут прийти к одинаковому неправильному выводу — он попадёт в банк опыта как "проверенный факт". Особенно опасно в задачах где у модели есть слепые пятна (неизвестная специфика индустрии, свежие данные после даты обучения, тонкие юридические нюансы). Критические выводы стоит проверять внешними источниками.

⚠️ Ручное применение — workflow: Описанный шаблон требует копировать между запросами, запускать несколько раундов, следить за структурой. Автоматизация через API проще, но для применения в чате это активный процесс, не одноразовый запрос. Подходит для задач где готов потратить время на итерации.

⚠️ Размер контекста: Банк опыта растет с раундами. После 4-6 раундов может упереться в лимит контекста модели, особенно если задача сложная и опыт объёмный. Дедупликация помогает, но не безгранично. Может потребоваться ручная чистка банка опыта между раундами (оставить только самое ценное) или остановиться раньше.

🔗

Ресурсы

"Do Not Waste Your Rollouts: Recycling Search Experience for Efficient Test-Time Scaling" - Arxiv preprint, January 2026 - Код и данные: https://github.com/WangXinglin/RSE - Авторы: Xinglin Wang, Jiayi Shi, Shaoxiong Feng и др. (Beijing Institute of Technology, Xiaohongshu Inc.) - См. также связанную работу PaCoRe (Hu et al., 2026) — альтернативный подход к переиспользованию истории поиска


📋 Дайджест исследования

Ключевая суть

Обнаружено: LLM страдает системной потерей памяти — при генерации 100 попыток решения каждая изолирована, модель заново выводит одни и те же промежуточные шаги и наступает на те же грабли. Для задачи требующей вывести 5 шагов подряд (каждый с точностью 70%) вероятность успеха в одной попытке = 0.7⁵ ≈ 17%. Метод RSE превращает изолированные попытки в кумулятивный процесс: генерируешь батч → дистиллируешь опыт (доказанные блоки + тупики) → следующий батч стартует с этим банком. Модель собирает решение из фрагментированных частичных успехов вместо попыток вывести всю цепочку за раз — вероятность скачет с 17% до 70%.

Принцип работы

Работа раундами вместо одного большого батча. Каждый раунд обогащает следующий через явный банк опыта в промпте. Раунд 1: генерация батча попыток (3-10 вариантов). Раунд 2: дистилляция — модель сама критикует свои попытки, извлекает доказанные утверждения (готовые блоки) и тупиковые пути (критические ошибки). Раунд 3: генерация нового батча с банком в контексте — "используй доказанное как аксиомы, не выводи заново; избегай тупиков, прунь эти пути". Повтор 2-4 цикла пока прирост не остановится. Модель как детектив без блокнота — каждое утро начинает расследование с нуля. RSE даёт блокнот: "вот что вчера выяснили, вот куда не ходи".

Почему работает

Стандартные методы проваливаются на экспоненциально сложных задачах. Majority Voting генерирует 128 изолированных попыток — если правильный ответ требует 5 последовательных шагов, он может вообще не появиться, голосование выберет популярную ошибку. Self-Refine итеративно улучшает одну ветку — если зашла в тупик на шаге 2, последующие итерации крутятся вокруг этой же ловушки. RSE превращает implicit опыт (скрытый в сырых траекториях) в explicit инструкции (явный банк в промпте). После первого батча модель уже знает: "УТП через сервис доказано" — все следующие попытки строятся на этом чекпоинте, не тратят токены на повторный вывод. Негативный recycling прунит пространство поиска — модель перестаёт генерировать варианты "конкуренция ценой", потому что путь явно помечен как тупик. Вероятность успеха растёт экспоненциально: модель собирает решение из частей, а не требует одной идеальной попытки.

Когда применять

Сложные многошаговые задачи → стратегии запуска проектов, многофакторный анализ, планирование где много зависимостей, исследовательские задачи с несколькими промежуточными выводами. Особенно когда стандартные "попробуй ещё раз" дают хаос из разрозненных попыток без прогресса. НЕ подходит для простых задач ("столица Франции") — там RSE избыточен, стандартная генерация даст ответ сразу.

Мини-рецепт

1. Батч попыток: Промпт с задачей + "предложи 3-10 независимых решений с обоснованием". Сохрани все варианты.

2. Дистилляция опыта: Скопируй все варианты в новый промпт + "Извлеки: ✅ ДОКАЗАННОЕ (что проверено, можно использовать как готовые блоки) / ❌ ТУПИКИ (где зашли в тупик, критические ошибки) / 🔍 СПОРНОЕ (требует проверки). Убери дубликаты".

3. Новый батч с банком: Промпт = "Задача + ИСПОЛЬЗУЙ КАК ГОТОВЫЕ БЛОКИ: [✅] + НЕ ХОДИ СЮДА: [❌] + ПРОВЕРЬ: [🔍]. Предложи 3-10 НОВЫХ решений которые строятся на доказанных блоках и обходят тупики".

4. Цикл: Повтори дистилляцию новых вариантов (шаг 2), обнови банк, генерируй следующий батч. Останови когда прирост качества замедлился (обычно 2-4 раунда).

5. Финальный выбор: Из последнего батча выбери лучший вариант или попроси модель синтезировать итоговое решение на основе всего банка опыта.

Примеры

[ПЛОХО] : Разработай стратегию запуска сервиса аренды строительного оборудования для малого бизнеса в России. Учти ценообразование, логистику, конкуренцию, юридику, сезонность, привлечение клиентов → получаешь ответ → не нравится → попробуй ещё раз по-другому → получаешь другой ответ → снова не то → цикл из изолированных попыток без прогресса.
[ХОРОШО] : Раунд 1: Разработай стратегию... Предложи 3 независимых варианта с обоснованием → получаешь 3 стратегии. Раунд 2 (дистилляция): Вот 3 варианта: [вставить]. Извлеки: ✅ ДОКАЗАННОЕ / ❌ ТУПИКИ / 🔍 СПОРНОЕ → модель выдаёт "✅ малому бизнесу критичен быстрый возврат залога / ❌ конкуренция ценой нереальна из-за логистики / 🔍 партнёрство с маркетплейсами". Раунд 3: Разработай НОВЫЕ стратегии. ИСПОЛЬЗУЙ: [✅]. НЕ ХОДИ: [❌]. ПРОВЕРЬ: [🔍]. Предложи 3 новых → новые варианты уже не наступают на грабль демпинга цен, строятся на автоматизированных залогах, исследуют партнёрства.
Источник: Do Not Waste Your Rollouts: Recycling Search Experience for Efficient Test-Time Scaling
ArXiv ID: 2601.21684 | Сгенерировано: 2026-01-31 09:44

Проблемы LLM

ПроблемаСутьКак обойти
Модель не помнит между попыткамиПросишь модель "попробуй ещё 10 раз". Получаешь 10 изолированных попыток. Модель каждый раз начинает с нуля. Выводит одни и те же промежуточные шаги заново. Наступает на одни и те же грабли. Не использует находки из прошлых попыток. Для сложных задач это критично — правильное решение может требовать собрать кусочки из разных попытокРаботай раундами: генерируй батч попыток извлеки из них доказанное и тупики дай модели этот список как готовые блоки генерируй новый батч. Модель будет строить на найденном, а не начинать каждый раз с нуля
Экспоненциальное падение шанса успеха в цепочках выводовЗадача требует вывести 5 шагов подряд. Модель выводит каждый с вероятностью 70%. Итоговая вероятность успеха = 0.7 × 0.7 × 0.7 × 0.7 × 0.7 17%. Даже 100 попыток дадут ~17 правильных. Для длинных цепочек (7-10 шагов) вероятность падает до единиц процентовНе требуй вывести всю цепочку за раз. Разбивай: первый батч попыток найди кто вывел шаги 1-3 правильно дай эти шаги как готовые второй батч выводит шаги 4-5. Вероятность скачет с экспоненциальной к линейной

Методы

МетодСуть
Циклы генерация-дистилляция — накопление опыта между попыткамиРаунд 1: Генерируй батч попыток (3-10 вариантов решения). Раунд 2: Дистилляция — попроси модель извлечь из этих попыток: ✅ доказанные утверждения (что точно работает, можно использовать как готовые блоки), ❌ тупики (где зашли в тупик, критические ошибки). Убери дубликаты. Раунд 3: Генерируй новый батч с промптом "используй доказанное как готовые блоки, избегай тупиков". Повторяй цикл 2-4 раза. Почему работает: Модель собирает решение из фрагментированных частичных успехов (в попытке №3 доказали A, в попытке №7 доказали B новый батч стартует с готовых A и B вместо повторного вывода). Превращаешь implicit опыт (скрытый в сырых попытках) в explicit инструкции (явный банк в промпте). Когда: сложные многошаговые задачи (стратегии, планирование, анализ), где одна попытка редко успешна. Не работает: простые задачи с однозначным ответом — избыточно

Тезисы

ТезисКомментарий
Переиспользование промежуточных инсайтов экспоненциально эффективнее повторной генерацииВместо 100 попыток вывести всю цепочку ABCDE за раз, собираешь решение из фрагментов: первый батч даёт A и B (найденные в разных попытках), второй батч с готовыми A и B выводит C и D, третий батч финиширует E. Вероятность успеха скачет с 0.7⁵ (17%) до 0.7 (70%) — потому что не требуешь идеальной попытки, чекпоинтишь валидные промежуточные шаги. Применяй: Для задач где нужно вывести 5+ зависимых утверждений, работай раундами — не надейся на одну идеальную попытку
Явный банк опыта работает сильнее чем сырые попытки в контекстеМодель лучше использует "✅ ДОКАЗАННОЕ: A, B, C — используй как готовые блоки" чем если A, B, C закопаны внутри 50 попыток в контексте. Explicit инструкции ("используй это") направляют генерацию. Implicit опыт (сырые траектории) модель может не заметить или не применить. Применяй: После батча попыток не просто показывай их все в контексте — извлеки структурированный список "что доказано, что не работает" и дай как явные инструкции
📖 Простыми словами

Do Not Waste Your Rollouts: Recycling Search Experience for Efficient Test-Time Scaling

arXiv: 2601.21684

Современные LLM в сложных задачах напоминают талантливых, но дико рассеянных профессоров: они могут выдать гениальный кусок решения, но споткнуться на финише и все испортить. Проблема в том, что стандартный метод Scaling Law — это просто попытка взять задачу измором, заставляя модель генерировать сотни независимых ответов в надежде, что хоть один окажется верным. Но если вероятность ошибки на каждом шаге высока, то шансы собрать идеальную цепочку из десяти звеньев стремятся к нулю. Метод Recycling Search Experience (RSE) меняет саму логику: он перестает выбрасывать неудачные попытки в корзину и начинает вытаскивать из них крупицы смысла.

Это как если бы ты собирал сложнейший пазл на 5000 деталей не в одиночку, а нанял толпу людей, которые по очереди подходят к столу, пробуют соединить пару штук и уходят. В обычном подходе каждый новый человек начинает с пустой доски, игнорируя то, что сделал предыдущий — это тупо и неэффективно. RSE же заставляет каждого следующего участника смотреть на наработки предшественников: «Так, вот этот угол уже собран, а здесь детали явно не подходят». Вместо того чтобы бесконечно гадать, модель строит решение на фундаменте из уже проверенных «кусков истины».

Технически это работает через цикличный банк опыта: модель делает пачку попыток, анализирует, какие промежуточные выводы повторяются и выглядят логично, а какие ведут в тупик. Эти данные упаковываются в контекст для следующей итерации. Получается накопительный эффект: с каждым раундом (обычно их 3–6) у модели все меньше шансов свернуть не туда, потому что «шпаргалка» перед глазами становится все подробнее. Мы не просто масштабируем вычисления, мы заставляем модель учиться на своих же черновиках в режиме реального времени.

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

Короче, хватит надеяться на случайный «идеальный прогон». Будущее за умной фильтрацией опыта, где каждый неудачный дубль приближает нас к правильному ответу. RSE доказывает, что 10 попыток с памятью работают лучше, чем 100 попыток с чистого листа. Если твоя модель лажает на длинных дистанциях, перестань заставлять её бегать быстрее — научи её смотреть под ноги и запоминать дорогу.

Работа с исследованием

Адаптируйте исследование под ваши задачи или создайте готовый промпт на основе техник из исследования.

0 / 2000
~0.5-2 N-токенов ~10-30с
~0.3-1 N-токенов ~5-15с