Agent Harness срещу Agent Framework срещу MCP: Кой слой управлява цикъла, състоянието, инструментите, разрешенията и възстановяването

Harness, framework и MCP се използват взаимозаменяемо в дискусиите за архитектурата на агентите. Те не са едно и също нещо. Намират се на различни слоеве, отговарят за различни отговорности и все повече се припокриват по границите си. Тази статия разграничава трите с помощта на 1 въпрос. Кой слой отговаря за цикъла на изпълнение, състоянието, транспорта на инструментите, разрешенията и възстановяването?

3-те категории

Агентски harness: Harness-ът е системата за изпълнение, която обгръща модела и го превръща във функциониращ агент. Публикацията на OpenAI Codex като платформа (19 август 2026 г.) го определя директно. Harness-ът управлява състоянието на разговора, предава изпълнението поточно и използва инструменти. Той също така налага политики за sandbox и одобрение и пренася работата между отделните ходове. Документацията на Anthropic за Claude Code нарича същото нещо агентски harness. Claude Agent SDK предоставя „същите инструменти, агентски цикъл и управление на контекста, които захранват Claude Code“. Harness-ът е обвързан с конкретно мнение. Той доставя цикъл, модел на разрешенията, sandbox и стратегия за контекста като едно цяло.
Агентски framework: Framework-ът е библиотека от примитиви за съставяне на агенти. Той обхваща клиенти за модели, абстракции за инструменти, оркестрация на графи, интерфейси за памет и hooks за наблюдаемост. Примери включват LangGraph, OpenAI Agents SDK и Microsoft Agent Framework, който достигна 1.0 GA през април 2026 г. Framework-ът ви дава частите и скелета на цикъла. Вие определяте политиката.
MCP: Model Context Protocol е wire протокол, а не runtime. Той стандартизира начина, по който LLM приложение (хостът) открива и извиква възможности, предоставяни от сървъри: инструменти, ресурси и подсказки. MCP използва съобщения JSON-RPC 2.0 между хостове, клиенти и сървъри. От декември 2025 г. Linux Foundation’s Agentic AI Foundation го управлява заедно с goose, AGENTS.md и вече A2A. MCP не притежава нито цикъл, нито състояние на агента. Той притежава договора между агента и неговите инструменти.

Матрица на отговорностите

Таблицата съпоставя всяка отговорност със слоя, който по подразбиране я притежава. „Притежава“ означава, че слоят определя и налага поведението. „Предоставя“ означава, че слоят излага hook, но не определя политиката.

Отговорност	Агентски harness	Агентски framework	MCP
Цикъл на изпълнение	Притежава: Фиксиран, готов за продукта цикъл с ограничения на ходовете и компактиране.	Притежава скелета: Вие конфигурирате прекратяването, предаването и ограниченията на ходовете.	Няма: Само заявка/отговор.
Състояние и памет на агента	Притежава: Сесии, възобновяване, разклоняване, checkpointing на файлове.	Предоставя: Checkpointer-и, хранилища за сесии, идентификатори на нишки.	Няма на протоколно ниво от 2026-07-28 г.
Транспорт на инструменти	Използва: Вградени инструменти плюс MCP клиент.	Използва: Function инструменти плюс MCP клиент.	Притежава: JSON-RPC през stdio или Streamable HTTP.
Разрешения и одобрения	Притежава: Режими на разрешенията, hooks, sandbox.	Предоставя: Guardrails, прекъсвания, middleware.	Делегира на хоста: Не може да налага.
Възстановяване	Притежава: Възобновяване на сесията, връщане на checkpoint, компактиране.	Предоставя: Надеждно изпълнение, повторно възпроизвеждане, повторни опити.	Частично: Разширение Tasks за дълго изпълнявани заявки.
Изолиране и sandbox	Притежава: OS sandbox, worktrees, контейнери.	По избор: Хоствани sandbox среди или micro-VM.	Няма.
Оркестрация на множество агенти	Притежава модели: Подагенти, динамични работни процеси.	Притежава примитиви: Графи, предаване, fan-out.	Няма: A2A обхваща комуникацията между агенти.

Останалата част от тази статия обосновава всеки ред с източници.

Кой притежава цикъла на изпълнение

Всеки агент работи в цикъл. Изпраща контекста към модела, прочита отговора, изпълнява извикванията на инструменти, подава резултатите обратно и повтаря. И harness-ът, и framework-ът реализират този цикъл. Разликата е в това доколко можете да го контролирате.

Цикъл на harness-а: Claude Agent SDK документира цикъла си в 5 стъпки. Получаване на prompt, оценяване и отговор, изпълнение на инструменти, повторение, връщане на резултат. Всеки пълен цикъл е 1 ход, а цикълът приключва, когато Claude генерира отговор без извиквания на инструменти. Hooks могат да прихващат, променят или блокират извикванията на инструменти, преди да бъдат изпълнени. Самият цикъл не може да бъде пренаписан от вас. Codex harness-ът на OpenAI предоставя достъп до цикъла чрез app-server, документиран клиентски протокол. Приложенията създават нишки, стартират ходове, получават събития и обработват заявки за одобрение.
Цикъл на framework-а: Цикълът на OpenAI Agents SDK приключва при финален резултат. Той се стартира отново при предаване или изпълнява извикванията на инструменти и продължава. Превишаването на max_turns предизвиква MaxTurnsExceeded, а tripwire на guardrail предизвиква GuardrailTripwireTriggered. В LangGraph цикълът е такъв, какъвто начертаете като граф. Възлите, ребрата и условното маршрутизиране определят контролния поток.
MCP: MCP няма цикъл. От спецификацията 2026-07-28 той дори няма handshake. Обменът initialize/initialized и заглавката Mcp-Session-Id бяха премахнати. Всяка заявка пътува самостоятелно, като носи версията на протокола и възможностите на клиента в _meta. Цикълът на хоста решава кога да извика tools/call. MCP само определя как изглежда това извикване по мрежата.

Кой притежава състоянието

Harness: Състоянието се намира в harness-а и се запазва между сесиите. Claude Agent SDK поддържа сесии, които могат да бъдат възобновени или разклонени по-късно. Checkpointing-ът на файлове възстановява файловете до всяко предишно състояние. Слоят harness на Microsoft доставя FileMemoryProvider за бележки, обхванати от сесията, и автоматично компактиране на контекста, което следи използването на токени в средата на цикъла. Работата на Anthropic по дълго изпълнявани harness-и отива още по-далеч. Тя предава състоянието между контекстните прозорци чрез артефакти на диска. Всяка нова сесия започва без спомен за предишната.
Framework: Framework-ите предоставят примитиви за състоянието, но не определят политиката за неговото запазване. Надеждното изпълнение на LangGraph изисква да прикачите checkpointer и да предадете идентификатор на нишка. То предлага 3 режима на надеждност. "exit" запазва само когато графът приключи, "async" записва, докато се изпълнява следващата стъпка, а "sync" записва преди всяка стъпка. Направете грешен избор и срив по средата на изпълнението ще изгуби състоянието. OpenAI Agents SDK предлага Sessions за автоматична история на разговорите, със SQLite, SQLAlchemy и криптирани backends.
MCP: Версията от 2026-07-28 г. направи ядрото на протокола без състояние. Насоките на поддържащите го са ясни. Ако сървърът се нуждае от състояние между извикванията, създайте handle от инструмент. Моделът го предава обратно като аргумент. Състоянието е проблем на агента, а не на протокола.

Кой притежава транспорта на инструментите

Това е 1-ят ред, който MCP притежава изцяло.

MCP определя 3 примитива от страна на сървъра: инструменти (функции, които моделът изпълнява), ресурси (контекст и данни) и подсказки (шаблонизирани работни процеси). Клиентите могат да предлагат elicitation, което позволява на сървър да поиска допълнителен вход от потребителя. Транспортът е JSON-RPC 2.0 през stdio или Streamable HTTP. Ревизията от 2026-07-28 г. направи заглавките Mcp-Method и Mcp-Name задължителни за HTTP заявките. Шлюзовете и ограничителите на честотата вече могат да маршрутизират по заглавки, без да анализират телата. Тя също така направи отговорите на tools/list кешируеми с ttlMs и cacheScope и оттегли стария HTTP+SSE транспорт с 12-месечен преходен период.

Инициираните от сървъра sampling, roots и logging вече са deprecated. Тяхната замяна е Multi Round-Trip Requests (MRTR). Сървърът връща resultType: "input_required", а клиентът повтаря оригиналното извикване с добавени отговори. Това е важно за реда с разрешенията по-долу.

Harness-ите и framework-ите и двата се намират върху MCP като клиенти. Claude Code и Claude Agent SDK се свързват с MCP сървъри. Те също така ви позволяват да дефинирате персонализирани инструменти чрез MCP сървър в процеса. Codex се свързва с MCP сървъри, а примерът Relay на OpenAI вгражда Codex до табло, задвижвано от MCP инструменти, притежавани от приложението. Microsoft Agent Framework 1.0 включва поддръжка за MCP и A2A. Протоколът е общата основа. Данните за приемането го потвърждават. Поддържащите MCP съобщават за близо половин милиард изтегляния на SDK месечно във всички SDK от Tier 1. TypeScript и Python SDK вече са преминали по 1 милиард общи изтегляния.

Кой притежава разрешенията

Спецификацията на MCP е недвусмислена по този въпрос. Хостовете трябва да получат изрично съгласие от потребителя, преди да извикат който и да е инструмент. Описанията и анотациите на инструментите трябва да се третират като ненадеждни, освен ако сървърът не е доверен. И тогава идва ключовото изречение: „MCP сам по себе си не може да налага тези принципи за сигурност на протоколно ниво“. Разрешенията принадлежат на хоста.

Harness: Harness-ите притежават модела на разрешенията от край до край. Claude Code доставя 6 режима на разрешения: default, acceptEdits, plan, auto, dontAsk и bypassPermissions. Правилата за отказ блокират във всеки режим с изключение на bypassPermissions, който изцяло пропуска слоя на разрешенията. Режимът auto маршрутизира всяко извикване на инструмент през фонов класификатор. Hooks добавят персонализирана логика при PreToolUse и PermissionRequest. Codex има същата форма. App-server може да постави хода на пауза и да издаде заявка за одобрение, на която лиентът трябва да отговори, преди работата да продължи.

Framework: Framework-ите ви дават hook, но не и политика. OpenAI Agents SDK разполага с guardrails за входа, изхода и инструментите, а tripwire прекратява изпълнението. LangGraph използва interrupt() вътре във възел, за да постави изпълнението на пауза за одобрение, и Command(resume=...), за да продължи. Microsoft Agent Framework добавя middleware ToolApprovalAgent с правила „не питай отново“. Във всеки случай вие пишете логиката за одобрение и потребителския интерфейс.

MCP: MCP вече пренася заявката за одобрение през wire чрез elicitation и MRTR. Supabase например планира да го използва, така че инструментите да могат да потвърдят разход или разрушителна заявка, преди да действат. Сървърът може да попита. Само хостът може да реши.

Кой притежава възстановяването

Harness: Възстановяването е мястото, където harness-ите доказват стойността си. Claude Agent SDK може да възобнови сесия и да върне промените по файловете до checkpoint. Той компактира контекста, когато прозорецът се запълни. Динамичните работни процеси на Claude Code продължават от мястото, на което са спрели, ако терминалът бъде затворен. Публикацията на Anthropic за дизайна на harness (март 2026 г.) разделя генератор от агент оценител, защото самостоятелно оценяваната работа се изкривява в положителна посока. Публикацията на OpenAI за harness от февруари 2026 г. отчита резултата от тази дисциплина. Codex е създал приблизително 1500 слети pull request-а за 5 месеца. Хранилището е достигнало около 1 милион реда код. Екипът е нараснал от 3 до 7 инженери, със средно 3,5 PR-а на инженер на ден. OpenAI също така съобщава за ефект на harness-а върху ARC-AGI-3. Запазеното разсъждение и компактирането на контекста са повишили GPT-5.6 Sol от 13,3% на 38,3%, като същевременно са намалили изходните токени шесткратно . Един и същ модел, различен harness, различен резултат.

Framework: Надеждното изпълнение на LangGraph изрично посочва, че възстановяването зависи от детерминизма. Обвивайте страничните ефекти в задачи, поддържайте възлите идемпотентни и едно изпълнение може да бъде възобновено седмица по-късно. OpenAI Agents SDK предоставя error_handlers и запазва завършените резултати от guardrail-ите, когато дадено изпълнение се провали. Framework-ът възпроизвежда. Вие гарантирате, че възпроизвеждането е безопасно.

MCP: Отговорът на MCP за дълго изпълнявана работа е разширението io.modelcontextprotocol/tasks, предоставено от AWS, с базирани на polling tasks/get и tasks/update. Това обхваща едно дълго извикване на инструмент. Не обхваща възстановяване на ниво агент.

Сравнение на архитектурите

                    +------------------------------------------+
  Приложение        |  Вашият продукт: UI, записи, бизнес       |
                    |  правила, потоци за съгласие               |
                    +------------------------------------------+
                          |                     |
                          v                     v
  Runtime слой      +----------------+   +-----------------------+
  (изберете един    |  AGENT HARNESS |   |  AGENT FRAMEWORK      |
   или комбинирайте)|  фиксиран цикъл|   |  композируем цикъл    |
                    |  сесии         |   |  checkpointer-и       |
                    |  разрешения    |   |  guardrails/interrupt |
                    |  sandbox       |   |  графи, предаване     |
                    |  компактиране  |   |  middleware, tracing  |
                    +----------------+   +-----------------------+
                          |                     |
                          +----------+----------+
                                     v
  Транспортен слой  +------------------------------------------+
                    |  MCP (JSON-RPC 2.0, stdio / Streamable   |
                    |  HTTP): инструменти, ресурси, подсказки, |
                    |  elicitation, разширение Tasks            |
                    +------------------------------------------+
                                     |
                                     v
  Слой на            +------------------------------------------+
  възможностите      |  MCP сървъри: GitHub, Figma, Supabase,   |
                    |  Sentry, Linear, вътрешни API            |
                    +------------------------------------------+

OpenAI начертава почти идентична картина за Relay. Приложението притежава продуктовия контекст, бизнес правилата и инструментите. Codex app-server предоставя агентския цикъл и изпълнението в sandbox.

Къде категориите се припокриват

Границите се размиват в 3 посоки:

Framework-ите поглъщат harness-и: Microsoft Agent Framework вече доставя слой „Agent Harness“. Той превръща всеки chat клиент в пълен harness с 1 извикване на метод. Включва компактиране на контекста, файлова памет, todo provider и режими за планиране спрямо изпълнение. Той също така добавя фонови подагенти и sandbox-нат shell executor. Microsoft описва harness-а като „слоя, в който разсъждението на модела се среща с реалното изпълнение“. Доставчик на framework признава, че суровите примитиви не са достатъчни.
Harness-ите се превръщат в платформи: OpenAI публикува с отворен код Codex harness-а и вече предлага 3 нива на интеграция. codex exec изпълнява ограничени задачи, Codex SDK дава програматичен контрол, а app-server вгражда цикъла в продукт. Claude Agent SDK на Anthropic прави същото за Claude Code. DeepSeek публикува DeepSeek Harness v0.1 на 13 август 2026 г. под лиценза MIT. Неговата предпоставка е, че всеки компонент, включително цикълът, е plugin. Когато един harness стане библиотека с документиран протокол, той започва да се конкурира с framework-ите.
MCP добавя функции с агентска форма: Elicitation, MRTR, разширението Tasks, Skills през MCP и MCP Apps разширяват протокола. Това са модели на взаимодействие, които преди се намираха в runtime-а. Поддържащите протокола обаче са начертали граница. Roots, sampling и logging са deprecated, а ядрото вече е заявка/отговор. MCP стандартизира интерфейса, но не се превръща в агента.

Един термин, който не се припокрива: A2A. Комуникацията между агенти е отделен протокол, който вече също се управлява от Agentic AI Foundation. MCP свързва агент с инструменти. A2A свързва агент с други агенти.

Как да сглобите стека

Решението се свежда до 3 въпроса:

Искате ли да притежавате цикъла? Започнете с framework, ако се нуждаете от персонализиран контролен поток или граф, който можете да тествате възел по възел. LangGraph, OpenAI Agents SDK и Microsoft Agent Framework ви позволяват да оформите цикъла. Очаквайте сами да напишете политиката за разрешенията, политиката за запазване и sandbox-а.
Искате ли доказан цикъл с вградени разрешения и възстановяване? Harness-ът ви отвежда по-далеч и по-бързо, когато задачата наподобява програмиране, операции или изследване. Claude Agent SDK и Codex app-server доставят сесии, одобрения, sandbox среди и компактиране по подразбиране. В замяна на това губите контрол над цикъла заради поведението в продукция. Собствените числа на OpenAI показват, че дизайнът на harness-а променя резултатите от бенчмаркове с 25 пункта при един и същ модел.
От какви инструменти се нуждае агентът? Отговорът е MCP, независимо от слоя над него. Всеки harness и всеки основен framework го поддържа. Stateless ядрото от 2026-07-28 г. означава, че отдалеченият MCP сървър вече е обикновен HTTP workload зад load balancer. Изградете инструменталния слой веднъж и го използвайте повторно в различни runtime среди.
Обичайната производствена форма в края на 2026 г. е хибридна. Framework оркестрира външния граф. Harness изпълнява всяка тежка стъпка в собствен sandbox. MCP пренася всяко извикване на инструмент. Категориите са слоеве, а не съперници.

Основни изводи

Harness-ът притежава цикъла, състоянието, разрешенията и възстановяването като 1 обвързано с мнение цяло.
Framework-ът предоставя същите hooks, но оставя политиката, запазването и sandbox изолирането на вас.
MCP притежава само транспорта на инструментите и заявява, че не може да налага съгласието на протоколно ниво.
Framework-ите вече доставят harness слоеве, а harness-ите вече доставят SDK, така че границата се сближава.
Сглобявайте по слоеве: framework или harness за цикъла, MCP за всяко извикване на инструмент.

Източници

Model Context Protocol, Спецификация 2026-07-28
MCP Blog, Спецификацията 2026-07-28 (28 юли 2026 г.)
MCP Blog, Новата пътна карта на MCP (22 август 2026 г.)
Linux Foundation, Създаване на Agentic AI Foundation (9 декември 2025 г.)
Linux Foundation, AAIF стартира сертификацията MCPA (септември 2026 г.)
OpenAI, Инженеринг на harness-и: използване на Codex в свят, ориентиран към агентите (11 февруари 2026 г.)
OpenAI Developers, Codex като платформа: изграждайте върху отворения агентски harness (19 август 2026 г.)
OpenAI, документация за Codex app-server и Codex SDK
OpenAI Agents SDK, Изпълнение на агенти, Guardrails, Сесии
Anthropic, Преглед на Claude Agent SDK, Как работи агентският цикъл, Hooks, Сесии, Checkpointing на файлове
Anthropic, Режими на разрешенията в Claude Code
Anthropic Engineering, Ефективни harness-и за дълго изпълнявани агенти (ноември 2025 г.)
Anthropic Engineering, Дизайн на harness за дълго изпълнявана разработка на приложения (24 март 2026 г.)
Anthropic Engineering, Изпълнение на код с MCP (4 ноември 2025 г.)
Claude Blog, Harness за всяка задача: динамични работни процеси в Claude Code (2 юни 2026 г.)
Microsoft, Microsoft Agent Framework версия 1.0 (април 2026 г.)
Microsoft, Microsoft Agent Framework на BUILD 2026: Agent Harness, Hosted Agents, CodeAct (3 юни 2026 г.)
LangChain, Надеждно изпълнение в LangGraph и Прекъсвания
DeepSeek, DeepSeek Harness (13 август 2026 г.)

Преведено автоматично от английски. Оригиналната статия е на връзката по-долу.