Анатомия agent harness: что на самом деле строят Anthropic, OpenAI, Perplexity и LangChain

Черновик перевода статьи Akshay из X. Источник: x.com/akshay_pachaar/status/2041146899319971922. Оригинальное название: “The Anatomy of an Agent Harness”.

Глубокий разбор того, что на самом деле строят Anthropic, OpenAI, Perplexity и LangChain: orchestration loop, tools, memory, context management и всё остальное, что превращает stateless LLM в способного агента.

Вы построили чатбота. Возможно, прикрутили ReAct-loop с несколькими инструментами. Для демо оно работает. Потом вы пытаетесь сделать что-то production-grade — и колёса отваливаются: модель забывает, что делала три шага назад, tool calls молча падают, а context window забивается мусором.

Проблема не в модели. Проблема во всём вокруг модели.

LangChain показали это, когда изменили только инфраструктуру вокруг своего LLM — та же модель, те же веса — и поднялись с места за пределами топ-30 до пятого места на TerminalBench 2.0. Отдельный исследовательский проект достиг 76,4% pass rate, позволив LLM оптимизировать саму инфраструктуру, и обошёл hand-designed systems.

У этой инфраструктуры теперь есть имя: agent harness.

Что такое agent harness?

Термин формализовали в начале 2026 года, но сама концепция существовала задолго до этого. Harness — это вся программная инфраструктура вокруг LLM: orchestration loop, tools, memory, context management, state persistence, error handling и guardrails.

Документация Anthropic Claude Code формулирует просто: SDK — это “the agent harness that powers Claude Code”. Команда OpenAI Codex использует ту же рамку, фактически приравнивая термины “agent” и “harness” к non-model infrastructure, которая делает LLM полезной.

Мне нравится каноническая формула Vivek Trivedy из LangChain:

“If you're not the model, you're the harness.”

Вот различие, на котором люди часто спотыкаются. “Agent” — это возникающее поведение: целенаправленная, использующая инструменты, самокорректирующаяся сущность, с которой взаимодействует пользователь. Harness — это механизм, который производит это поведение. Когда кто-то говорит “я построил агента”, на практике он построил harness и направил его на модель.

Beren Millidge точно описал эту аналогию в эссе “Scaffolded LLMs as Natural Language Computers” в 2023 году. Сырая LLM — это CPU без RAM, disk и I/O. Context window служит RAM: быстрой, но ограниченной. Внешние базы данных работают как disk storage: большие, но медленные. Tool integrations — это device drivers. Harness — операционная система.

“We have reinvented the Von Neumann architecture.”

Потому что это естественная абстракция для любой вычислительной системы.

Три уровня инженерии

Вокруг модели есть три концентрических уровня инженерии:

• Prompt engineering — создаёт инструкции, которые получает модель.
• Context engineering — управляет тем, что модель видит и когда.
• Harness engineering — включает оба предыдущих уровня плюс всю прикладную инфраструктуру: orchestration tools, state persistence, error recovery, verification loops, safety enforcement и lifecycle management.

Harness — это не wrapper вокруг prompt. Это полная система, которая делает возможным автономное агентное поведение.

12 компонентов production harness

Если синтезировать подходы Anthropic, OpenAI, LangChain и broader practitioner community, production agent harness состоит из двенадцати отдельных компонентов.

1. Orchestration Loop

Это heartbeat системы. Он реализует цикл Thought-Action-Observation (TAO), также известный как ReAct loop. Цикл выглядит так: собрать prompt, вызвать LLM, распарсить output, выполнить tool calls, вернуть результаты обратно, повторять до завершения.

Механически это часто просто while-loop. Сложность живёт не в самом цикле, а во всём, чем он управляет. Anthropic описывает runtime как “dumb loop”: весь интеллект живёт в модели, harness просто управляет ходами.

2. Tools

Tools — руки агента. Они описываются схемами: name, description, parameter types — и внедряются в context LLM, чтобы модель знала, что доступно. Tool layer отвечает за registration, schema validation, argument extraction, sandboxed execution, result capture и форматирование результатов обратно в LLM-readable observations.

Claude Code даёт инструменты в шести категориях: file operations, search, execution, web access, code intelligence и subagent spawning. OpenAI Agents SDK поддерживает function tools через @function_tool, hosted tools вроде WebSearch, CodeInterpreter, FileSearch и MCP server tools.

3. Memory

Memory работает на нескольких временных масштабах. Short-term memory — история разговора внутри одной сессии. Long-term memory сохраняется между сессиями: Anthropic использует project files CLAUDE.md и автоматически создаваемые MEMORY.md; LangGraph использует namespace-organized JSON Stores; OpenAI поддерживает Sessions на SQLite или Redis.

Claude Code реализует трёхуровневую иерархию: lightweight index примерно по 150 символов на запись, который всегда загружается; подробные topic files, подтягиваемые по требованию; и raw transcripts, доступные только через search.

Критический принцип дизайна: агент воспринимает собственную memory как “hint” и проверяет её по фактическому состоянию перед действием.

4. Context Management

Именно здесь многие агенты тихо проваливаются. Главная проблема — context rot: производительность модели падает на 30%+, когда ключевой контент оказывается в середине окна. Это показали исследования Chroma и Stanford “Lost in the Middle”. Даже million-token windows страдают от деградации instruction-following по мере роста контекста.

Production-стратегии включают:

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

Цель context engineering у Anthropic: найти минимальный набор high-signal tokens, который максимизирует вероятность нужного результата.

5. Prompt Construction

Этот компонент собирает то, что модель реально видит на каждом шаге. Структура иерархическая: system prompt, tool definitions, memory files, conversation history и текущий user message.

OpenAI Codex использует строгий priority stack: server-controlled system message, tool definitions, developer instructions, user instructions через каскадные AGENTS.md с лимитом 32 KiB, затем conversation history.

6. Output Parsing

Современные harness’ы полагаются на native tool calling: модель возвращает structured tool_calls, а не free text, который нужно парсить вручную. Harness проверяет: есть tool calls — выполнить их и продолжить loop. Нет tool calls — это final answer.

Для structured outputs OpenAI и LangChain поддерживают schema-constrained responses через Pydantic models. Legacy-подходы вроде RetryWithErrorOutputParser остаются для edge cases.

7. State Management

LangGraph моделирует state как typed dictionaries, текущие через graph nodes, а reducers объединяют updates. Checkpointing происходит на super-step boundaries, позволяя resume после прерываний и time-travel debugging.

OpenAI предлагает четыре взаимоисключающие стратегии: application memory, SDK sessions, server-side Conversations API или lightweight chaining через previous_response_id. Claude Code идёт другим путём: git commits как checkpoints и progress files как structured scratchpads.

8. Error Handling

Вот почему это важно: 10-step процесс с 99% успехом на каждом шаге всё равно имеет только около 90,4% end-to-end success. Ошибки быстро накапливаются.

LangGraph различает четыре типа ошибок: transient — retry with backoff; LLM-recoverable — вернуть ошибку как ToolMessage, чтобы модель адаптировалась; user-fixable — interrupt for human input; unexpected — поднять выше для debugging. Anthropic ловит failures внутри tool handlers и возвращает их как error results, чтобы loop продолжал работать. Production harness Stripe ограничивает retry двумя попытками.

9. Guardrails and Safety

OpenAI SDK реализует три уровня: input guardrails, output guardrails и tool guardrails. Механизм tripwire мгновенно останавливает агента при срабатывании.

Anthropic архитектурно отделяет permission enforcement от model reasoning. Модель решает, что попытаться сделать; tool system решает, что разрешено. Claude Code независимо гейтит около 40 discrete tool capabilities в три стадии: trust establishment при загрузке проекта, permission check перед каждым tool call и explicit user confirmation для high-risk operations.

10. Verification Loops

Это то, что отделяет toy demos от production agents. Anthropic рекомендует три подхода: rules-based feedback — tests, linters, type checkers; visual feedback — screenshots через Playwright для UI tasks; LLM-as-judge — отдельный subagent оценивает output.

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

11. Subagent Orchestration

Claude Code поддерживает три execution models: Fork — byte-identical copy of parent context; Teammate — отдельная terminal pane с file-based mailbox communication; Worktree — собственный git worktree и isolated branch на агента.

OpenAI SDK поддерживает agents-as-tools, когда specialist решает bounded subtask, и handoffs, когда specialist полностью берёт управление. LangGraph реализует subagents как nested state graphs.

Loop в движении: пошаговый walkthrough

1. Prompt Assembly. Harness собирает полный input: system prompt + tool schemas + memory files + conversation history + current user message. Важный контекст ставится в начало и конец prompt, учитывая “Lost in the Middle”.
2. LLM Inference. Собранный prompt уходит в model API. Модель генерирует output tokens: text, tool call requests или оба.
3. Output Classification. Если есть текст без tool calls — loop завершается. Если есть tool calls — переходим к execution. Если запрошен handoff — обновляется current agent и loop перезапускается.
4. Tool Execution. Для каждого tool call harness валидирует arguments, проверяет permissions, выполняет в sandboxed environment и captures results. Read-only операции могут идти параллельно; mutating operations выполняются последовательно.
5. Result Packaging. Tool results форматируются как LLM-readable messages. Ошибки ловятся и возвращаются как error results, чтобы модель могла self-correct.
6. Context Update. Results добавляются в conversation history. При приближении к limit запускается compaction.
7. Loop. Возврат к Step 1 до termination.

Termination conditions layered: модель дала ответ без tool calls, превышен maximum turn limit, исчерпан token budget, сработал guardrail tripwire, пользователь прервал выполнение или вернулся safety refusal. Простой вопрос может занять 1–2 turns. Сложный refactoring task может протянуть десятки tool calls через много turns.

Для long-running tasks через несколько context windows Anthropic разработала двухфазный паттерн “Ralph Loop”: Initializer Agent готовит environment — init script, progress file, feature list, initial git commit; затем Coding Agent в каждой новой сессии читает git logs и progress files, ориентируется, выбирает самый приоритетный incomplete feature, работает, commit’ит и пишет summaries. Filesystem даёт continuity между context windows.

Как реальные frameworks реализуют этот паттерн

Anthropic Claude Agent SDK раскрывает harness через одну функцию query(), которая создаёт agentic loop и возвращает async iterator со stream messages. Runtime — “dumb loop”; интеллект живёт в модели. Claude Code использует Gather-Act-Verify cycle: gather context, take action, verify results, repeat.

OpenAI Agents SDK реализует harness через Runner class с тремя режимами: async, sync и streamed. SDK “code-first”: workflow logic выражается в нативном Python, а не в graph DSL. Codex harness добавляет трёхслойную архитектуру: Codex Core, App Server с bidirectional JSON-RPC API и client surfaces — CLI, VS Code, web app. Все surfaces используют один harness.

LangGraph моделирует harness как explicit state graph: два nodes — llm_call и tool_node — соединены conditional edge. Если есть tool calls, route в tool_node; если нет — END. LangGraph вырос из LangChain AgentExecutor, который был deprecated в v0.2 из-за сложности расширения и отсутствия multi-agent support.

CrewAI реализует role-based multi-agent architecture: Agent, Task и Crew. Flows layer добавляет “deterministic backbone with intelligence where it matters”: routing и validation управляются явно, а Crews занимаются autonomous collaboration.

AutoGen, эволюционирующий в Microsoft Agent Framework, продвинул conversation-driven orchestration. Его Core, AgentChat и Extensions поддерживают sequential, concurrent fan-out/fan-in, group chat, handoff и magentic-паттерн, где manager agent ведёт dynamic task ledger для coordination specialists.

Метафора scaffolding

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

Ключевой инсайт: scaffolding убирают, когда здание готово.

По мере улучшения моделей сложность harness должна снижаться. Manus переписывали пять раз за шесть месяцев, и каждый rewrite удалял complexity. Complex tool definitions превращались в general shell execution. “Management agents” превращались в простые structured handoffs.

Это указывает на принцип co-evolution: модели теперь post-train’ят с конкретными harness’ами в loop. Модель Claude Code научилась использовать именно тот harness, с которым её тренировали. Изменение tool implementations может ухудшить performance из-за этой tight coupling.

Future-proofing test для harness design: если performance растёт с более сильными моделями без добавления harness complexity, дизайн здоровый.

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

1. Single-agent vs. multi-agent. Anthropic и OpenAI советуют сначала максимально прокачать single agent. Multi-agent systems добавляют overhead: extra LLM calls для routing и context loss при handoffs. Делить стоит только при tool overload свыше примерно 10 overlapping tools или явно отдельных доменах задач.
2. ReAct vs. plan-and-execute. ReAct чередует reasoning и action на каждом шаге: гибко, но дороже на step. Plan-and-execute разделяет planning и execution. LLMCompiler сообщает о 3,6x speedup над sequential ReAct.
3. Context window management strategy. Production-подходы: time-based clearing, conversation summarization, observation masking, structured note-taking и sub-agent delegation. ACON показал 26–54% token reduction при сохранении 95%+ accuracy за счёт приоритизации reasoning traces над raw tool outputs.
4. Verification loop design. Computational verification — tests, linters — даёт deterministic ground truth. Inferential verification через LLM-as-judge ловит semantic issues, но добавляет latency. Thoughtworks команда Martin Fowler описывает это как guides — feedforward до действия — и sensors — feedback после действия.
5. Permission and safety architecture. Permissive — быстро, но рискованно: auto-approve most actions. Restrictive — безопаснее, но медленнее: approval на каждое действие. Выбор зависит от deployment context.
6. Tool scoping strategy. Больше tools часто означает хуже performance. Vercel убрали 80% tools из v0 и получили лучшие результаты. Claude Code достигает 95% context reduction через lazy loading. Принцип: expose minimum tool set needed for the current step.
7. Harness thickness. Сколько логики живёт в harness, а сколько в модели. Anthropic ставит на thin harnesses и model improvement. Graph-based frameworks ставят на explicit control. Anthropic регулярно удаляет planning steps из Claude Code harness по мере того, как новые модели internalize эту capability.

Harness — это продукт

Два продукта на одинаковых моделях могут показывать радикально разную производительность только из-за дизайна harness. Доказательство TerminalBench ясно: изменение одного harness двигало агентов более чем на 20 позиций в рейтинге.

Harness — не solved problem и не commodity layer. Именно здесь живёт тяжёлая инженерия: управление context как scarce resource, verification loops, которые ловят failures до того, как они накопятся, memory systems, которые дают continuity без hallucination, и архитектурные ставки на то, сколько scaffolding строить, а сколько оставлять модели.

Поле движется к thinner harnesses по мере улучшения моделей. Но сам harness никуда не исчезает. Даже самой способной модели нужно что-то, что управляет context window, выполняет tool calls, сохраняет state и проверяет работу.

В следующий раз, когда ваш агент провалится, не обвиняйте модель. Посмотрите на harness.

Если вам понравился материал, автор оригинала — @akshay_pachaar, который пишет про AI, Machine Learning и vibe coding best practices.