Harness Engineering: как LangChain улучшил агента с 30 на 5 место, меняя только обвязку модели

Когда модель — не главное: прорыв через инженерию обвязки

В феврале 2026 года команда LangChain сделала то, что многие считали невозможным. Они взяли своего стандартного ReAct-агента, который скромно занимал 30-е место в Terminal Bench 2.0, и подняли его на 5-ю позицию. И самое интересное — они не меняли модель. Совсем. Никаких GPT-5, Gemini Ultra 2.0 или Claude 3.5. Тот же самый GPT-4o, который был доступен ещё в 2024. Вся магия произошла в обвязке.

Это и есть Harness Engineering — дисциплина, которая перестала гоняться за новыми моделями и начала выжимать максимум из того, что уже есть. Плюс 13.7 балла на том же железе. Как? Сейчас разберём.

Проблема: почему ваш агент тупит на 30-м месте?

Представьте типичную сцену. Вы взяли LangChain (или любой другой фреймворк), подключили GPT-4o через OpenAI, написали три строчки системного промпта и запустили. Агент работает. Но работает посредственно. Он забывает контекст, делает глупые ошибки в арифметике, не проверяет свои действия, а когда что-то идёт не так — вы не понимаете, где именно.

Terminal Bench 2.0 (актуальный бенчмарк на 17.02.2026) — это не синтетический тест. Это реальные задачи из продакшена: работа с файловой системой, выполнение команд, анализ данных, многошаговое планирование. Агент на 30-м месте справляется с базовыми задачами, но регулярно проваливает сложные цепочки. Основные болевые точки:

• Слепое исполнение: Агент выполняет команды, не задумываясь о последствиях. `rm -rf /`? Почему бы и нет.
• Арифметические галлюцинации: LLM плохо считает в уме. Особенно с плавающей точкой.
• Потеря контекста в длинных сессиях: После 10-15 шагов агент забывает, что делал в начале.
• Нулевая наблюдаемость: Когда агент зависает или выдаёт ерунду, вы не видите, в каком именно промпте он ошибся.

Именно эти проблемы решает Harness Engineering. Не заменой модели на что-то «покруче», а инженерией вокруг неё.

Решение: три столпа, которые подняли агента на 5-е место

LangChain не изобретал ничего принципиально нового. Они просто системно применили три техники, которые до этого использовались точечно. Вместе они дали синергетический эффект.

1 Системный промпт, который думает, а не просто инструктирует

Старый промпт (тот самый, что давал 30-е место) выглядел примерно так:

"""You are a helpful assistant. You can use tools to interact with the system. Think step by step."""

Новый промпт — это полноценный контракт с агентом. Он явно описывает роли, ограничения, форматы ответов и, что критично, процесс мышления. Вот ключевые изменения:

• Явное разделение фазы мышления и действия: Агент должен сначала написать `Thought:`, потом только `Action:`. Это не просто формальность — это принудительное замедление.
• Конкретные запреты: Не просто «будь осторожен», а «никогда не выполняй команды, которые могут удалить системные файлы без явного подтверждения пользователя».
• Шаблоны для само-проверки: В промпт встроены вопросы, которые агент должен задать себе перед действием: «Правильно ли я понял задачу?», «Есть ли риски у этой команды?», «Можно ли решить задачу проще?».

2 Self-Verification: агент, который проверяет сам себя

Раньше агент действовал по схеме «подумал-сделал». Теперь схема выглядит как «подумал-проверил-сделал-проверил результат». Self-verification — это не отдельный вызов LLM. Это встроенные проверки на уровне инструментов и промежуточного ПО (middleware).

Как это работает в коде (на примере LangChain 1.0+):

from langchain.agents import AgentExecutor
from langchain.middleware import SelfVerificationMiddleware

# Старый подход (без проверок)
# agent_executor = AgentExecutor(agent=agent, tools=tools)

# Новый подход со встроенной верификацией
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    middleware=[
        SelfVerificationMiddleware(
            check_arithmetic=True,  # Проверка расчётов через калькулятор
            check_destructive_commands=True,  # Валидация опасных команд
            max_retries=2  # Автоматические попытки исправить ошибку
        )
    ]
)

Когда агент пытается выполнить команду `rm`, middleware перехватывает запрос, запускает быструю валидацию (часто через ту же LLM, но с узким промптом «Опасна ли эта команда?»), и только потом пропускает. Если агент выдал числовой результат — middleware может отправить его на пересчёт через инструмент-калькулятор.

Это добавляет latency? Да, 100-200 мс на шаг. Но это снижает процент ошибок в Terminal Bench с 18% до 4%. Овчинка стоит выделки.

3 Глубокая трассировка через LangSmith: видеть невидимое

Самое большое преимущество LangChain в 2026 году — это не фреймворк, а экосистема. LangSmith превратился из простого трейсера в полноценную платформу observability для агентов.

Раньше трассировка показывала: «агент вызвал инструмент X». Теперь она показывает:

• Полный chain-of-thought агента, включая скрытые рассуждения
• Тепловую карту задержек по инструментам
• Автоматически выявленные паттерны ошибок (например, «агент часто путает флаги ls -l и ls -la»)
• Зависимости между шагами в длинных сессиях

Инженеры LangChain использовали эти данные не для отчётности, а для обратной связи в промпт. Они выявили топ-5 ошибок своего агента, прописали в системный промпт конкретные контрмеры, и результат появился в следующем прогоне Terminal Bench.

Пошаговый план: как повторить этот результат

Хотите улучшить своего агента на 10+ баллов в Terminal Bench (или просто в продакшене)? Делайте так.

Шаг 1: Инструментарий и подготовка

Убедитесь, что у вас актуальные версии (на 17.02.2026):

pip install langchain==1.0.0 langchain-openai==0.3.0 langsmith==0.2.0

Зарегистрируйтесь в LangSmith (есть бесплатный тариф) и настройте экспорт трассировок. Без этого вы будете оптимизировать вслепую.

Шаг 2: Анализ текущих провалов

Запустите своего агента на 20-30 типовых задачах (возьмите примеры из Terminal Bench или своих продакшен-кейсов). Откройте LangSmith и найдите паттерны:

• На каких шагах агент чаще всего ошибается?
• Какие инструменты вызывают наибольшие задержки?
• Есть ли повторяющиеся логические ошибки?

Запишите топ-3 проблемы. Например: «агент неправильно интерпретирует относительные пути», «путает флаги grep», «не проверяет существование файла перед чтением».

Шаг 3: Переписывание системного промпта

Не пишите промпт с нуля. Возьмите базовый шаблон из документации LangChain и адаптируйте под свои проблемы. Структура должна быть такой:

# Роль и цель
Ты — агент для выполнения задач в терминале. Твоя основная цель — выполнять задачи точно и безопасно.

# Критические правила (запреты)
1. Никогда не выполняй команды с rm, mv, cp без явного подтверждения от пользователя в том же запросе.
2. Всегда проверяй существование файлов перед чтением/записью.
3. Для арифметических операций используй инструмент calculator.

# Процесс мышления
Ты ДОЛЖЕН следовать этому формату:
Thought: [Твои рассуждения о задаче, возможных рисках и плане]
Action: [Инструмент для использования]
Action Input: [Ввод для инструмента]

# Само-проверка
Перед каждым действием ответь себе на вопросы:
- Правильно ли я понял задачу?
- Есть ли более простой способ?
- Какие могут быть побочные эффекты?

# Примеры ошибок (из прошлых трассировок)
- НЕПРАВИЛЬНО: `cat /etc/passwd` без проверки прав
- ПРАВИЛЬНО: сначала `ls -la /etc/passwd`, потом cat если файл существует и доступен

Шаг 4: Внедрение Self-Verification Middleware

Не делайте сложную логику самостоятельно. Используйте готовые middleware из LangChain 1.0:

from langchain.middleware import (
    SafetyCheckerMiddleware,
    ArithmeticCheckerMiddleware,
    ContextPreservationMiddleware
)

agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    middleware=[
        SafetyCheckerMiddleware(blocked_commands=["rm -rf", "dd", "mkfs"]),
        ArithmeticCheckerMiddleware(),  # Автоматически перепроверяет вычисления
        ContextPreservationMiddleware(max_context_length=4000)
    ],
    return_intermediate_steps=True  # Критично для отладки
)

Шаг 5: Настройка непрерывной обратной связи

Каждую неделю:

1. Собирайте 50-100 трассировок из продакшена
2. Экспортируйте их из LangSmith в CSV
3. Ищите новые паттерны ошибок (можно простым скриптом на Python)
4. Добавляйте новые правила в системный промпт

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

Нюансы и ошибки, которые сломают ваш прогресс

Самая частая ошибка — пытаться внедрить всё и сразу. Начните с одного middleware, измерьте эффект в Terminal Bench, потом добавляйте следующее. И всегда смотрите на компромисс: точность vs скорость.

Что дальше? Harness Engineering после 2026

Модели будут становиться умнее. GPT-5, Gemini Ultra 3, Claude 4 — они все придут. Но Harness Engineering не умрёт. Она сместится в сторону более тонкой настройки.

Вместо базовых проверок безопасности появятся:

• Контекстно-зависимая валидация: Middleware, который понимает семантику задачи. Удаление файла в боевой среде vs в тестовой — разные уровни риска.
• Динамическая адаптация промпта: Системный промпт, который меняется в зависимости от времени суток, нагрузки на систему, прошлых ошибок агента.
• Предсказание ошибок: LangSmith уже сейчас экспериментирует с ML-моделями, которые предсказывают, где агент likely ошибится, и заранее добавляют guardrails.

Иронично, но чем умнее становятся модели, тем важнее становится обвязка вокруг них. Потому что с увеличением возможностей растёт и потенциальный ущерб от ошибок. Ваш GPT-5 может написать гениальный код, но без proper harness он всё равно удалит продакшен-базу.

Финальный совет: перестаньте гоняться за новыми моделями как за серебряной пулей. Возьмите текущую модель, включите LangSmith, напишите системный промпт с учётом ваших конкретных ошибок, добавьте два-три middleware для само-проверки. Скорее всего, этого хватит, чтобы подняться в рейтинге на 10-15 позиций. Проверено на Terminal Bench. Проверьте на своём коде.