Вы собрали чатбота. Прикрутили пару инструментов, может даже ReAct-цикл. На демо всё блестит. Запускаете в production — и начинается: модель «забывает» контекст, вызовы инструментов падают без внятной ошибки, контекстное окно превращается в свалку. Знакомая картина.

И почти всегда проблема не в самой модели. Проблема в том, что её окружает — в инфраструктуре, которая превращает голую LLM в автономного агента. У этой инфраструктуры есть имя: agent harness, агентный харнесс. И именно она, а не модель, чаще всего определяет, взлетит продукт или нет.

Цифры это подтверждают. LangChain, поменяв только обвязку вокруг LLM (модель и веса — те же), поднялся с позиции вне топ-30 на 5-е место в TerminalBench 2.0. В другом эксперименте LLM сам оптимизировал свою инфраструктуру и достиг 76,4% pass rate, обогнав вручную спроектированные системы.

Дальше — что именно входит в харнесс, из каких компонентов он состоит и почему он стал главным полем конкуренции для тех, кто строит агентные системы.

Что это

Agent harness — это вся программная обвязка вокруг языковой модели. Термин обрёл формальное определение в начале 2026 года, но сама концепция стара́. В харнесс входят: цикл оркестрации, набор инструментов, подсистема памяти, управление контекстным окном, сохранение состояния, обработка сбоев и ограничения безопасности.

Anthropic в документации Claude Code говорит прямо: их SDK — это «агентный харнесс, на котором работает Claude Code». Команда Codex в OpenAI приравнивает «agent» и «harness» к не-модельной инфраструктуре, которая делает LLM полезной для реальных задач.

Удачная формулировка Vivek Trivedy из LangChain: «Если ты не модель — ты харнесс».

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

Beren Millidge ещё в 2023 году предложил точную аналогию. Голая LLM — это процессор без оперативной памяти, без диска и без устройств ввода-вывода. Контекстное окно — та самая оперативная память: быстрое, но маленькое. Внешние базы — жёсткий диск: вместительный, но медленный. Интеграции с инструментами — драйверы устройств. А харнесс — операционная система. Millidge написал: «Мы заново изобрели архитектуру фон Неймана» — потому что это естественная абстракция для любой вычислительной системы.

Три уровня инжиниринга

Модель окружают три концентрических слоя:

  • Prompt engineering — какие инструкции модель получает на вход.
  • Context engineering — что именно модель видит и в какой момент.
  • Harness engineering — оба предыдущих плюс вся прикладная инфраструктура: оркестрация инструментов, сохранение состояния между запусками, восстановление после сбоев, циклы проверки, безопасность, управление жизненным циклом.

Харнесс шире промпта. Это полноценная система, без которой автономное агентное поведение просто не возникает.

Двенадцать компонентов production-харнесса

Если разобрать подходы Anthropic, OpenAI, LangChain и практиков сообщества, вырисовывается дюжина отдельных слоёв. Разберём их по порядку.

1. Оркестрационный цикл

Сердце системы. Реализует петлю «мысль — действие — наблюдение» (Thought-Action-Observation, она же ReAct loop). Схема проста: собрать промпт, вызвать LLM, разобрать ответ, выполнить запрошенные вызовы, вернуть результаты, повторить.

Технически это часто обычный while-цикл. Вся сложность — не в нём, а в том, чем он управляет. Anthropic характеризует свой runtime как «тупой цикл»: интеллектуальность живёт в модели, харнесс лишь крутит итерации.

2. Инструменты (Tools)

Инструменты — руки агента. Каждый инструмент описан схемой: имя, описание, типы параметров. Эти схемы попадают в контекст LLM, чтобы модель знала, чем может воспользоваться. Слой инструментов отвечает за регистрацию, проверку схем, извлечение аргументов, изолированное выполнение, захват результата и форматирование его в наблюдение, которое модель сможет прочитать.

В Claude Code инструменты разбиты на шесть категорий: работа с файлами, поиск, выполнение команд, веб-доступ, анализ кода и запуск субагентов. В Agents SDK OpenAI поддержаны function tools (через декоратор @function_tool), hosted tools (WebSearch, CodeInterpreter, FileSearch) и MCP-инструменты.

3. Память (Memory)

Память работает в нескольких временных масштабах. Краткосрочная — история диалога внутри одной сессии. Долгосрочная — то, что сохраняется между запусками. Anthropic использует файлы CLAUDE.md и автогенерируемые MEMORY.md. LangGraph работает с JSON-хранилищами, организованными по namespace. OpenAI держит Sessions поверх SQLite или Redis.

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

4. Управление контекстом (Context Management)

Здесь тихо деградируют многие агенты. Главная проблема — context rot, деградация контекста: если ключевая информация оказывается в середине окна, качество ответа падает на 30% и больше. Это показало исследование Chroma, и то же подтвердила работа Stanford «Lost in the Middle». Даже контекстные окна на миллион токенов не спасают — качество следования инструкциям ухудшается по мере роста заполнения.

Что применяют в production:

  • Compaction — суммаризация истории при приближении к лимиту. Claude Code сохраняет архитектурные решения и открытые баги, отбрасывая избыточные выводы инструментов.
  • Observation masking — JetBrains Junie прячет старые выводы инструментов, но оставляет сами вызовы видимыми.
  • Just-in-time retrieval — лёгкие идентификаторы вместо тяжёлых данных, подгрузка по необходимости. Claude Code использует grep, glob, head, tail вместо загрузки файлов целиком.
  • Sub-agent delegation — субагент исследует задачу широко, но возвращает сжатое саммари на 1000-2000 токенов.

Цель, как формулирует Anthropic в руководстве по context engineering: найти минимальный набор максимально информативных токенов, который максимизирует вероятность нужного результата.

5. Конструирование промпта (Prompt Construction)

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

В Codex OpenAI — строгий стек приоритетов: системное сообщение под контролем сервера (высший приоритет), затем определения инструментов, инструкции разработчика, инструкции пользователя (каскадные файлы AGENTS.md с лимитом 32 KiB), и только потом история диалога.

6. Парсинг вывода (Output Parsing)

Современные харнессы используют native tool calling: модель возвращает структурированные объекты tool_calls, а не свободный текст, который надо разбирать регулярками. Логика проста: есть вызовы — выполнить и продолжить; нет вызовов — это финальный ответ.

Для структурированных ответов OpenAI и LangChain поддерживают constrained responses на базе Pydantic-моделей. Устаревшие подходы вроде RetryWithErrorOutputParser (передача промпта, неудачного ответа и ошибки парсинга обратно в модель) остаются для edge cases.

7. Управление состоянием (State Management)

LangGraph описывает состояние как типизированные словари, проходящие через узлы графа; редьюсеры сливают обновления. Чекпоинты ставятся на границах super-step — это даёт возобновление после прерываний и time-travel debugging. OpenAI предлагает четыре взаимоисключающих стратегии: application memory, SDK sessions, server-side Conversations API и легковесное chaining через previous_response_id. Claude Code пошёл иначе: git-коммиты как чекпоинты, progress-файлы как структурированные черновики.

8. Обработка ошибок (Error Handling)

Цифра для размышления: процесс из 10 шагов, где каждый успешен в 99% случаев, даёт сквозной успех лишь ~90,4%. Ошибки накапливаются быстрее, чем ожидает интуиция.

LangGraph делит ошибки на четыре категории: транзиентные (retry с backoff), исправляемые моделью (ошибка возвращается как ToolMessage — модель может скорректироваться), исправляемые человеком (пауза для ввода) и неожиданные (проброс наружу для отладки). Anthropic перехватывает сбои в обработчиках инструментов и возвращает их как результаты с ошибкой, не прерывая цикл. В production-харнессе Stripe retry ограничен двумя попытками.

9. Ограничители и безопасность (Guardrails and Safety)

SDK OpenAI — три уровня: input guardrails (на входе первого агента), output guardrails (на финальном выводе) и tool guardrails (на каждом вызове инструмента). Механизм tripwire мгновенно останавливает агента при срабатывании.

Anthropic архитектурно разводит enforcement и reasoning. Модель решает, что попытаться сделать; система инструментов решает, что разрешено. Claude Code контролирует около 40 дискретных разрешений в три стадии: установление доверия при загрузке проекта, проверка перед каждым вызовом инструмента и явное подтверждение пользователя для высокорисковых операций.

10. Циклы верификации (Verification Loops)

Тот самый водораздел между демо и production. Anthropic рекомендует три подхода: rules-based feedback (тесты, линтеры, тайп-чекеры), visual feedback (скриншоты через Playwright для UI-задач) и LLM-as-judge (субагент оценивает результат отдельно.

Boris Cherny, создатель Claude Code, заметил: способность верифицировать собственную работу поднимает качество модели в 2-3 раза.

11. Оркестрация субагентов (Subagent Orchestration)

Claude Code — три модели: Fork (байт-идентичная копия родительского контекста), Teammate (отдельная панель терминала, коммуникация через файловый mailbox) и Worktree (отдельный git worktree, изолированная ветка). Agents SDK OpenAI — agents-as-tools (специалист решает подзадачу) и handoffs (специалист перехватывает управление). LangGraph — субагенты как вложенные графы состояний.

Цикл в действии: пошаговый разбор

Теперь соединим компоненты и проследим, как они работают вместе в одной итерации.

Шаг 1: сборка промпта

Харнесс собирает полный ввод: системный промпт, схемы инструментов, файлы памяти, история диалога, текущее сообщение пользователя. Важный контекст ставится в начало и конец промпта — следствие из «Lost in the Middle».

Шаг 2: инференс LLM

Собранный промпт уходит в model API. Модель генерирует токены: текст, запросы на вызов инструментов, или оба варианта.

Шаг 3: классификация вывода

Текст без вызовов — цикл завершён, это финальный ответ. Есть вызовы — переходим к выполнению. Запрошен handoff — текущий агент меняется, цикл перезапускается.

Шаг 4: выполнение инструментов

Для каждого вызова: валидация аргументов, проверка разрешений, изолированное выполнение, захват результата. Read-only операции идут параллельно, мутирующие — последовательно.

Шаг 5: упаковка результатов

Результаты форматируются как сообщения для LLM. Ошибки перехватываются и возвращаются как результаты с ошибкой — модель может самокорректироваться.

Шаг 6: обновление контекста

Результаты добавляются к истории диалога. Если контекстное окно близко к лимиту — запускается compaction.

Шаг 7: цикл

Возврат к шагу 1. Повтор до завершения.

Условий завершения несколько: ответ без вызовов инструментов, превышение лимита ходов, исчерпание бюджета токенов, срабатывание tripwire, прерывание пользователем, safety refusal. Простой вопрос — 1-2 итерации. Сложный рефакторинг — десятки вызовов инструментов за много итераций.

Ralph Loop: многосессионный паттерн

Для задач, которые не помещаются в одно контекстное окно, Anthropic создал двухфазный паттерн «Ralph Loop». Первый агент — Initializer — разворачивает окружение: init-скрипт, progress-файл, список фич, стартовый git-коммит. Затем Coding Agent в каждой новой сессии читает git-логи и progress-файлы для ориентации, берёт незавершённую фичу с максимальным приоритетом, работает над ней, коммитит и пишет саммари. Префемственность между контекстными окнами обеспечивает файловая система.

Как фреймворки реализуют харнесс

Claude Agent SDK (Anthropic)

Харнесс открывается через одну функцию query(), которая создаёт агентный цикл и возвращает async-итератор стримящих сообщений. Runtime — «тупой цикл», интеллектуальность в модели. Claude Code работает по циклу Gather-Act-Verify: собрать контекст (поиск по файлам, чтение кода), выполнить действие (редактирование, запуск команд), проверить результат (тесты, проверка вывода), повторить.

Agents SDK (OpenAI)

Харнесс — класс Runner в трёх режимах: async, sync, streamed. Подход code-first: логика workflow выражается на нативном Python, а не в графовых DSL. Харнесс Codex расширен трёхслойной архитектурой: Codex Core (код агента + runtime), App Server (двунаправленный JSON-RPC API) и клиентские интерфейсы (CLI, VS Code, веб). Все интерфейсы работают на одном харнессе — поэтому «модели Codex лучше ощущаются на интерфейсах Codex, чем в обычном чат-окне».

LangGraph (LangChain)

Харнесс моделируется как явный граф состояний. Два узла — llm_call и tool_node — соединены условным ребром: есть вызовы — маршрутизация в tool_node, нет — в END. LangGraph пришёл на смену AgentExecutor LangChain, который был deprecated в v0.2 из-за трудности расширения и отсутствия мультиагентности. Deep Agents LangChain открыто используют термин «agent harness»: встроенные инструменты, планирование через write_todos, файловые системы для контекста, запуск субагентов, персистентная память.

CrewAI

Ролевая мультиагентная архитектура: Agent (харнесс вокруг LLM, задаваемый ролью, целью, бэкстори и инструментами), Task (единица работы), Crew (коллекция агентов). Слой Flows добавляет «детерминированный скелет с интеллектуальностью там, где нужно» — маршрутизация и валидация, пока Crews обеспечивают автономное взаимодействие.

AutoGen (Microsoft Agent Framework)

Первооткрыватели conversation-driven оркестрации. Трёхслойная архитектура (Core, AgentChat, Extensions) с пятью паттернами: sequential, concurrent (fan-out/fan-in), group chat, handoff и magentic (менеджер-агент ведёт динамический task ledger, координируя специалистов).

Метафора строительных лесов

Сравнение со строительными лесами не для красоты — оно точно. Леса — временная конструкция, которая позволяет рабочим добраться туда, куда иначе не дотянуться. Сами они ничего не строят. Но без них верхние этажи не существуют.

Ключевой момент: леса убирают, когда здание готово. По мере того как модели умнеют, сложность харнесса должна уменьшаться. Manus переписывали систему пять раз за полгода — и каждый раз убирали сложность. Замысловатые определения инструментов превратились в обычные shell-команды. «Управляющие агенты» схлопнулись в простые структурированные handoff’ы.

За этим стоит принцип ко-эволюции: модели проходят post-training с конкретным харнессом в цикле. Модель Claude Code обучалась на том самом харнессе, который используется в продакшене. Поменяйте реализацию инструментов — и производительность может просесть из-за этой связи.

«Тест на будущее»: если более мощная модель поднимает производительность без усложнения харнесса — дизайн верный.

Семь решений, определяющих каждый харнесс

Семь развилок, перед которыми стоит каждый архитектор агентной системы.

Single-agent vs. multi-agent

И Anthropic, и OpenAI рекомендуют: сначала выжать максимум из одного агента. Мультиагентность добавляет overhead — лишние LLM-вызовы на маршрутизацию, потерю контекста при handoff’ах. Делить агента стоит, когда инструментов больше ~10 с пересечениями или есть чётко разделённые домены задач.

ReAct vs. plan-and-execute

ReAct чередует рассуждение и действие на каждом шаге — гибко, но дороже за шаг. Plan-and-execute разделяет планирование и исполнение. LLMCompiler сообщает об ускорении в 3,6x против последовательного ReAct.

Стратегия управления контекстным окном

Пять production-подходов: time-based clearing, conversation summarization, observation masking, structured note-taking, sub-agent delegation. Исследование ACON показало сокращение токенов на 26-54% при точности 95%+ — за счёт приоритета reasoning traces над сырыми выводами инструментов.

Дизайн цикла верификации

Вычислительная верификация (тесты, линтеры) даёт детерминированную истину. Inferential verification (LLM-as-judge) ловит семантические проблемы, но добавляет задержку. Команда Thoughtworks Мартина Фаулера разделяет это на guides (feedforward — направлять до действия) и sensors (feedback — наблюдать после).

Архитектура разрешений

Permissive (быстро, но рискованно — большинство действий одобряется автоматически) против restrictive (безопасно, но медленно — подтверждение на каждое действие). Выбор зависит от контекста развёртывания.

Стратегия скопинга инструментов

Больше инструментов — чаще хуже, а не лучше. Vercel вырезал 80% инструментов из v0 и получил лучший результат. Claude Code через lazy loading достигает 95% сокращения контекста. Принцип: открывать минимальный набор, нужный для текущего шага.

Толщина харнесса

Сколько логики в харнессе, а сколько в модели. Anthropic ставит на тонкие харнессы и улучшение модели. Граф-ориентированные фреймворки ставят на явный контроль. Anthropic регулярно убирает шаги планирования из Claude Code, когда новые версии модели интернализируют эту способность.

Харнесс — это и есть продукт

Два продукта на одинаковых моделях могут показывать радикально разные результаты — только за счёт дизайна харнесса. TerminalBench подтверждает: смена только харнесса передвигала агентов на 20+ позиций в рейтинге.

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

Индустрия движется к тонким харнессам по мере роста качества моделей. Но харнесс не исчезнет. Даже самая мощная модель нуждается в чём-то, что управляет её контекстным окном, крутит вызовы инструментов, хранит состояние и проверяет результат.

Когда ваш агент в следующий раз даст сбой — не вините модель. Смотрите на харнесс.

Ограничения

Ограничения

Харнесс решает много проблем, но создаёт новые. Вот что нужно учитывать.

Context rot — качество ответа падает на 30%+, когда ключевая информация оказывается в середине окна.

Даже окна в миллион токенов не спасают.

Накопление ошибок — 10 шагов с 99% успеха на каждом дают ~90,4% сквозного успеха.

Ошибки копятся быстрее, чем ожидает интуиция.

Ко-эволюция — модель обучается на конкретном харнессе.

Смена реализации инструментов может просадить производительность из-за тесной связи.

Толщина харнесса — перетяжелённый харнесс блокирует улучшения модели.

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

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

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

Что не делать при проектировании харнесса.

Больше инструментов — лучше — на практике чаще наоборот.

Vercel вырезал 80% инструментов из v0 и получил лучший результат. Открывайте минимальный набор для текущего шага.

Копировать чужой харнесс — харнесс тесно связан с моделью и задачей.

То, что работает у Anthropic или OpenAI, может не сработать в вашем контексте.

Игнорировать context management — надежда на большое контекстное окно не работает.

Деградация instruction-following растёт с объёмом контекста. Нужны активные стратегии: compaction, masking, just-in-time retrieval.

Пропустить верификацию — без циклов верификации агент — демо, не продукт.

Способность проверять свою работу поднимает качество в 2-3 раза.

Чеклист

Чеклист

Что проверить перед запуском production-агента.

Оркестрационный цикл — while-цикл с чёткими условиями завершения:

ответ без вызовов, лимит ходов, бюджет токенов, tripwire, прерывание.

Управление контекстом — compaction, observation masking или just-in-time retrieval.

Не полагаться на размер окна.

Обработка ошибок — разделение на транзиентные, LLM-recoverable, пользовательские и неожиданные.

Retry с backoff, но с лимитом.

Циклы верификации — rules-based feedback (тесты, линтеры), visual feedback, LLM-as-judge.

Минимум один тип.

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

Lazy loading — как в Claude Code: 95% сокращения контекста.

Безопасность — архитектурное разделение enforcement и reasoning.

Модель решает, что попытаться; система — что разрешить.

Память как подсказку

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

Ссылки

Ссылки

По теме

По теме