3,583 papers
arXiv:2608.08254 70 8 авг. 2026 г. FREE

Schema vs Prompt: почему JSON-схема может тихо переписать ваши инструкции

КЛЮЧЕВАЯ СУТЬ
Обнаружено: у LLM два канала инструкций одновременно — текст промпта и текстовые описания полей внутри JSON-схемы. При конфликте между ними модель не складывает их вместе — она выбирает только один канал, и какой именно, зависит от конкретной модели. Метод позволяет находить этот скрытый конфликт и лечить его до того, как он тихо обрушит точность классификации — с 100% до 73% или с 52% до 7% без единой ошибки в логах. Фишка простая: добавь в схему поле «объясни рассуждение» перед полем с финальным ответом — модель перестаёт угадывать метку и начинает её обосновывать, отсюда +15-24 процентных пункта точности.
Адаптировать под запрос

TL;DR

Когда LLM заполняет структурированный JSON-ответ (structured output — формат, где модель обязана вернуть данные по строгой схеме полей), у неё появляется два канала инструкций одновременно: обычный текст промпта и текстовые описания внутри самой схемы (например, поле "category" может иметь описание "тип нарушения, если он есть"). Если эти два канала говорят разное — модель не складывает их вместе, а выбирает один источник, и какой именно — зависит от конкретной модели.

Проблема в том, что это выбор невидимый. Разработчик хранит правило классификации в промпте, потом обновляет описание поля в схеме — и точность может рухнуть с 100% до 73% или с 52% до 7%, при этом внешне выглядит так, будто модель просто "тупит" на задаче, хотя на деле она добросовестно выполняет инструкцию — только не ту, что ожидал автор.

Решение из исследования — два простых правила: держать определения правил в одном месте, а не дублировать между промптом и схемой (единый источник правды), и добавить в схему обязательное поле "объясни рассуждение" прямо перед полем с финальным ответом — это подняло точность на 15–24 процентных пункта там, где было куда расти.

🔬

Схема метода (два практических вывода)

ДИАГНОСТИКА КОНФЛИКТА:
Дай модели одинаковое правило в двух местах (промпт vs описание поля схемы) → 
сделай их слегка противоречащими → 
замерь, чья версия победила → 
узнаешь, какому каналу эта модель доверяет больше

ИНТЕРВЕНЦИЯ (даёт рост точности):
Добавь в схему поле "reasoning" (рассуждение) ПЕРЕД полем с финальным ответом →
модель обязана сначала написать объяснение →
только потом заполнить итоговое поле-ответ

Оба шага выполняются в одном запросе — это не многошаговый диалог, а структура самого JSON-запроса.


🚀

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

Задача: Вы настроили в Make или Zapier автоматическую классификацию заявок с сайта через OpenAI (Structured Outputs) — бот должен раскладывать входящие обращения на категории: "жалоба", "вопрос по оплате", "заявка на возврат", "прочее". Вы прописали правила категорий и в системном промпте, и (для надёжности) продублировали их в описании поля схемы. В какой-то момент вы обновили формулировку в промпте, но забыли поправить схему — и бот начал массово путать "жалобу" с "вопросом по оплате".

Промпт (система классификации, JSON schema, фрагмент):

Системный промпт:
"Классифицируй обращение клиента по категориям:
- жалоба: клиент недоволен качеством услуги
- вопрос_по_оплате: вопросы о счетах, платежах, тарифах
- возврат: явный запрос вернуть деньги
- прочее: всё остальное"

JSON-схема (передаётся отдельно, через параметр response_format):
{
  "reasoning": "Опиши шаг за шагом, к какой категории относится обращение и почему, прежде чем указать финальную категорию",
  "category": "одна из: жалоба, вопрос_по_оплате, возврат, прочее"
}

Результат: Если правила в промпте и в описании схемы совпадают — модель классифицирует стабильно. Если они расходятся (например, схема осталась со старой формулировкой) — часть моделей проигнорирует промпт и последует именно тексту в схеме, и точность резко упадёт без видимой причины в логах. Добавление поля "reasoning" перед "category" заставляет модель сначала выписать логику, что заметно поднимает точность именно в схемной части — это и есть рабочий фикс, а не просто отладочная мера.


🧠

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

LLM не хранит инструкции в единой "памяти важности" — она обрабатывает текст промпта и текст описаний полей схемы как разные потоки входных данных, и то, какой поток "весит больше", — это свойство конкретной модели, не универсальное правило. Одни модели (GPT-4.1, GPT-5.4 без режима рассуждений) больше доверяют системному промпту, другие (Claude Haiku, GPT-5.5) — сильно завязаны на схему и легко теряют точность при конфликте.

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

Рычаги управления: - Дублирование правил в промпте и схеме → убери, оставь один источник правды — иначе рискуешь тихим конфликтом при любом будущем редактировании. - Порядок полей в схеме → поле-рассуждение должно стоять ДО поля-ответа, иначе эффекта не будет (модель уже "закоммитила" ответ). - Проверка на конфликт → быстрый тест (дать заведомо разные версии правила в двух местах и посмотреть, что победит) занимает меньше 100 запросов и сразу показывает, какому каналу доверяет ваша модель.


📋

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

Для тех, кто настраивает structured output через API, Custom GPT Actions или no-code сервисы (Make, Zapier, n8n) с JSON-схемой:

Системный промпт:
"{правила_и_определения_категорий}
Не дублируй эти правила в других местах — это единственный источник истины."

JSON-схема:
{
  "{поле_рассуждения}": "Опиши шаг за шагом свою логику классификации, прежде чем указывать финальный ответ.",
  "{поле_ответа}": "{допустимые_значения_категорий}"
}

Подставь: {правила_и_определения_категорий} — точные критерии для каждой категории; {поле_рассуждения} и {поле_ответа} — названия полей в вашей схеме, важно чтобы рассуждение шло раньше ответа; {допустимые_значения_категорий} — список меток.

🚀 Быстрый старт — вставь в чат (если работаешь через API/no-code с structured output):

Вот принцип из исследования про structured output: правила классификации нужно хранить в одном месте (не дублировать между промптом и JSON-схемой), а в схему нужно добавить поле для рассуждения перед полем с финальным ответом. 
Помоги мне применить это к моей задаче: {твоя задача}.
Задавай вопросы, чтобы понять мои категории и текущую схему.

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


⚠️

Ограничения

⚠️ Только для structured output: метод касается ситуаций, где модель заполняет JSON-схему через API, Custom GPT Actions или no-code интеграции. В обычном чате ChatGPT/Claude без JSON-схемы этот механизм не проявляется буквально — но принцип "не дублируй противоречащие инструкции" переносится и туда.

⚠️ Нет эффекта на потолке: если модель уже даёт 100% точность без интервенции, добавление поля-рассуждения ничего не даст — проверяй, есть ли "запас роста", прежде чем внедрять.

⚠️ Поведение модель-специфично: нельзя один раз выяснить "моя модель доверяет схеме больше промпта" и считать это универсальным правилом навсегда — при обновлении модели поведение может измениться, нужно перепроверять.


🔍

Как исследовали

Автор взяла задачу классификации коротких рабочих сообщений на 4 категории и специально дала категориям бессмысленные названия (tomil, varek, selmo, drava) — чтобы модель не могла угадать смысл категории по названию и полагалась только на данные ей определения. Затем один и тот же текст с правилами перемещался между системным промптом, пользовательским промптом и описанием поля схемы — на 10 конфигурациях моделей от OpenAI и Anthropic, каждый тест прогонялся 5 раз для надёжности.

Отдельно проверили конфликт: в промпте — правильные правила, в схеме — специально перепутанные (не случайный мусор, а определения других категорий, чтобы текст выглядел логично, но был неверным). Оказалось, что у Claude Haiku точность упала с 52,5% до 7% — модель почти полностью подчинилась неправильной схеме, игнорируя верный промпт. Это и удивило исследователей больше всего: интуитивно кажется, что системный промпт должен быть "главным", но эмпирически это не так для всех моделей.

Третий эксперимент — добавление обязательного поля "рассуждение" перед полем ответа прямо в схему, без изменения самих правил. Эффект оказался устойчивым и большим (+15–24 п.п.) там, где был запас роста, причём даже у модели с собственным встроенным режимом "размышления" — то есть выигрыш пришёл не просто от лишних вычислений, а от того, как схема организует порядок работы модели.


🔗

Ресурсы

Sin-Ying (Alina) Lin, Your Prompt Is Not the Only Prompt: How Much Do LLMs Weight Structured-Output Schema Descriptions? — Independent Researcher, препринт.


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

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

Обнаружено: у LLM два канала инструкций одновременно — текст промпта и текстовые описания полей внутри JSON-схемы. При конфликте между ними модель не складывает их вместе — она выбирает только один канал, и какой именно, зависит от конкретной модели. Метод позволяет находить этот скрытый конфликт и лечить его до того, как он тихо обрушит точность классификации — с 100% до 73% или с 52% до 7% без единой ошибки в логах. Фишка простая: добавь в схему поле «объясни рассуждение» перед полем с финальным ответом — модель перестаёт угадывать метку и начинает её обосновывать, отсюда +15-24 процентных пункта точности.

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

Правило простое: structured output — это не один текст, а два потока инструкций, которые модель читает раздельно. Суть в одной фразе: не дублируй правило в промпте и в схеме — выбери один источник правды. Продублировал — рано или поздно один канал победит другой, а ты даже не узнаешь об этом из логов. GPT-4.1 обычно слушает промпт, Claude Haiku и GPT-5.5 сильно завязаны на схему — и это свойство конкретной модели, не универсальный закон.

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

LLM не хранит инструкции в общей памяти важности — промпт и описание поля схемы для неё это просто два разных потока данных на входе. Модель не взвешивает их поровну, она берёт один поток целиком, как будто второго не было. Поле «рассуждение» перед полем-ответом меняет расклад: модель уже не может молча угадать метку, ей нужно сначала написать логику — а значит реально прочитать и использовать текст описания поля, а не проскочить его. Вот почему это работает: модель обязана обосновать выбор, а не выдать его — и это подняло точность на 15-24 процентных пункта там, где был запас роста.

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

Structured output через API (параметр response_format у OpenAI), Custom GPT Actions или no-code интеграции типа Make, Zapier, n8n → конкретно для задач классификации с чёткими категориями → особенно когда правила категорий продублированы и в системном промпте, и в описании полей схемы. НЕ подходит, если модель уже выдаёт 100% точности без вмешательства — расти там уже некуда.

Мини-рецепт

1. Найди дублирование: Проверь, хранится ли одно и то же правило классификации и в системном промпте, и в описании полей JSON-схемы.
2. Оставь один источник правды: Удали правило из одного места — либо только промпт, либо только схема, без копий.
3. Добавь поле-рассуждение: Вставь в схему поле reasoning СТРОГО перед полем с финальным ответом, иначе эффекта не будет.
4. Проверь, кому доверяет твоя модель: Дай в промпте и в схеме заведомо разные версии одного правила, прогони до 100 запросов, посмотри чья версия победила.
5. Перепроверяй при смене модели: Поведение модель-специфично — обновил модель, тестируй заново, старые выводы не гарантированы.

Примеры

[ПЛОХО] : правило в system-промпте "жалоба: клиент недоволен качеством услуги" и другое правило в описании поля схемы "category": "тип нарушения, если клиент возмущён" — два разных описания одной категории в разных местах
[ХОРОШО] : правило живёт только в промпте, а схема выглядит так: {"reasoning": "Опиши шаг за шагом, к какой категории относится обращение и почему, прежде чем указать финальный ответ", "category": "жалоба | вопрос_по_оплате | возврат | прочее"}
Источник: YourPromptIs Not the OnlyPrompt: How Much Do LLMs Weight Structured-Output Schema Descriptions?
ArXiv ID: 2608.08254 | Сгенерировано: 2026-08-11 05:37

Проблемы LLM

ПроблемаСутьКак обойти
Скрытый конфликт между промптом и структурой ответаКогда модель заполняет JSON по схеме, у неё два источника правил: текст промпта и текстовые описания полей в самой схеме. Если правила там разные — модель не смешивает их. Она выбирает один источник целиком. Какой именно — зависит от конкретной модели, а не от логики задачи. Внешне это выглядит как "модель тупит", хотя она честно выполняет инструкцию — просто не ту, что вы имели в виду. Точность может рухнуть на десятки процентов без единой ошибки в логахДержи правила в ОДНОМ месте. Не дублируй определения категорий и условия одновременно в системном промпте и в описании поля схемы. Если правило меняется — меняй его только там, где оно хранится

Методы

МетодСуть
Единый источник правилПиши правила классификации только в одном месте — либо в промпте, либо в описании поля схемы, не в обоих. Явно укажи в промпте: "это единственный источник правил, не дублируй". Почему работает: у модели нет двух конфликтующих потоков текста, поэтому нет скрытого выбора "какому верить". Работает всегда, когда используешь structured output через API или no-code сервисы с JSON-схемой. Бесполезен, если правила и так не дублируются
Поле-рассуждение перед полем-ответомВ JSON-схему добавь поле типа "объясни свою логику шаг за шагом", и поставь его ПЕРЕД финальным полем-ответом. {"reasoning": "...", "answer": "..."}. Модель обязана сначала написать объяснение, и только потом заполнить итоговый ответ. Почему работает: модель не может "проскочить" описание поля и угадать метку — ей нужно явно объяснить логику, а это заставляет её реально прочитать и использовать инструкцию, а не просто скопировать паттерн. Порядок полей критичен: если рассуждение стоит ПОСЛЕ ответа — эффекта нет, ответ уже "зафиксирован". Не работает, если модель уже даёт максимальную точность без этого — там расти нечему
📖 Простыми словами

YourPromptIs Not the OnlyPrompt: How Much DoLLMsWeight Structured-Output Schema Descriptions?

arXiv: 2608.08254

Когда ты заставляешь нейронку выдавать данные в строгом формате, например в виде JSON-таблицы, ты фактически даешь ей две инструкции одновременно. Первая — это твой обычный промпт, а вторая — это описания полей внутри самой структуры, которую ты от нее требуешь. Проблема в том, что LLM не умеет «усреднять» эти указания. Если в промпте ты просишь одно, а в описании поля схемы — чуть-чуть другое, модель не пытается найти компромисс. Она просто выбирает одного «хозяина» и игнорирует второго, причем делает это абсолютно непредсказуемо.

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

Исследователи выяснили, что у каждой модели свои «любимчики». Например, GPT-4o или старые версии GPT-4 чаще слушают системный промпт и забивают на то, что написано в схеме. А вот Claude 3 Haiku или новые модели с жестким контролем структуры могут намертво вцепиться в описание поля и полностью проигнорировать твои слезные просьбы в основном тексте задания. Это называется конфликтом весов, и это главная причина, почему боты на ровном месте начинают тупить и путать категории заявок.

Этот принцип универсален для любой автоматизации, будь то классификация писем в Make или сложная аналитика через API. Тестировали это на JSON-схемах, но логика работает везде, где есть разделение на «суть задания» и «формат ответа». Если ты обновил логику работы в одном месте, но забыл поправить описание переменной в коде или конструкторе — жди беды. SEO для промптов теперь требует идеальной синхронизации: любая лишняя строчка в схеме может перечеркнуть килобайты текста в системных инструкциях.

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

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

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

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