What is an agent harness?

An agent harness is everything around the model that turns a chat completion into an agent: the loop that decides when to call tools and when to stop, tool routing and execution, context management and compaction when the window fills, subagent delegation, session persistence and recovery, and the sandbox where commands run. The model supplies judgment; the harness supplies the hands, memory and safety rails. OpenAI's Codex harness and Anthropic's Claude Agent SDK are the two best-known reference harnesses in 2026, and both vendors now offer hosted versions — OpenAI's Agents API (public beta since September 10, 2026) and Anthropic's Managed Agents.

Hosted harness or DIY loop: which is cheaper?

In platform fees, roughly equal in 2026: OpenAI's Agents API charges no fee beyond tokens, tools and container time; Anthropic's Managed Agents bill session-hours on top of tokens; DIY costs your own compute. The real difference is engineering: compaction, tool search, parallel subagents and durable sessions are weeks of work to build and months to keep current as models change. Hosted harnesses can also lower token spend through programmatic tool calling and on-demand tool loading. For a team without a dedicated agent-infrastructure engineer, hosted is usually cheaper in total cost; for high-volume products with tight margins, a tuned DIY loop can win.

When should you build your own agent loop instead of using a hosted harness?

Build your own when you need Zero Data Retention or non-US data residency that the hosted product does not offer (OpenAI's Agents API is US-only and not ZDR-eligible as of September 2026), when you must swap models across vendors without rewriting the agent, when the execution path has to stay entirely inside your network for audit reasons, when your loop is unusual enough that a general harness fights you, or when you are at a scale where shaving tokens per task is worth an engineer. Frameworks such as LangGraph, Mastra and the OpenAI or Claude Agent SDKs make DIY far less work than it was in 2024.

Does using a hosted harness lock you in?

More than a raw model API does, less than a full platform. Sessions, artifacts and compaction state live with the vendor and are not portable; the agent definition (instructions, tools, MCP servers) mostly is. Mitigations: keep tools behind MCP servers you own so they move with you, keep the sandbox self-hosted or on a neutral provider (E2B, Modal, Daytona, Cloudflare), and keep evaluation harnesses vendor-agnostic so you can measure a switch. OpenAI's harness logic is open source (github.com/openai/codex), which reduces the black-box risk but not the data-gravity risk.

Quick Answer

Hosted Agent Harness vs DIY Agent Loop: Which Wins in 2026

Published: September 11, 2026

The Short Answer

	Hosted harness (OpenAI Agents API, Anthropic Managed Agents)	DIY loop (Agents SDK, Claude Agent SDK, LangGraph, Mastra, hand-rolled)
Who runs the loop	Vendor	You
Compaction, tool search, subagents, resume	Included, updated with each model release	You build and maintain
Sandbox	Vendor-hosted, self-hosted or partner	Whatever you wire
Time to first working agent	Hours	Days to weeks
Platform fee	OpenAI: none; Anthropic: session-hours	None; your compute
ZDR / residency	Limited (OpenAI: US-only, no ZDR as of Sep 2026)	Whatever the model endpoint allows
Multi-vendor models	Single vendor	Yes
Portability	Agent definition yes; sessions/state no	High
Debuggability	Events, traces, open-source harness code (OpenAI)	Full
Best for	Long-running cloud agents, small teams, fast iteration	Regulated data, multi-model, high-volume cost tuning, unusual loops

Rule of thumb: start hosted unless compliance or multi-vendor requirements forbid it; go DIY when you can name the specific thing the hosted harness cannot do.

What a harness actually does

The model is a function from context to text. Everything that makes it an agent is harness:

The loop — call model, parse tool calls, execute, append results, repeat, decide when done.
Context management — summarise or compact as the window fills, keep instructions pinned, preserve the prompt cache.
Tool routing — expose the right tools without bloating the prompt; run calls in parallel; filter large results before they hit context.
Subagents — split work, give each its own context, merge results.
Persistence — durable sessions you can steer mid-turn and resume days later.
Environment — a sandbox with files, packages, skills and network policy.

In 2024 every team wrote all of this. By 2026 the frontier labs had written it several times over for their own products and started renting it out.

The hosted option in 2026

OpenAI Agents API (public beta, September 10, 2026): the Codex harness as a service. One session-create call with model, instructions, tools, MCP servers, multi_agent settings and an environment; OpenAI handles compaction, tool search, programmatic tool calling, subagents, steering, resume and webhooks. Compute is your choice — OpenAI-hosted sandbox, self-hosted, or partners (Blaxel, Cloudflare, Daytona, DigitalOcean, E2B, Modal, Oracle, Runloop, Vercel). No fee beyond tokens, tools and containers. Constraints: US data residency only, no ZDR.

Anthropic Managed Agents plus the Claude Agent SDK: Anthropic runs the control plane and can host the sandbox, or you self-host the sandbox on your infrastructure (GA across the Claude API in mid-2026); billed as session-hours plus tokens. The SDK itself — subagents, compaction hooks, permissions, MCP — is the harness behind Claude Code and is open for DIY use.

Both give you the harness the vendor uses internally, which is the strongest argument for them: the harness is tuned to the model, and it improves the day a new model ships instead of the quarter after.

The DIY option in 2026

DIY no longer means writing the loop from scratch. The realistic stack is an SDK or framework — OpenAI Agents SDK, Claude Agent SDK, LangGraph, Mastra, Microsoft Agent Framework — plus a sandbox provider and your own persistence. You own:

the execution path (nothing runs where you did not deploy it),
the model choice (swap vendors, route by task, run open weights locally),
the data controls (ZDR endpoints, regional residency, your own logs),
the economics (tune tokens per task, cache aggressively, batch where possible).

You also own the maintenance. Each model generation changes what “good compaction” and “good tool routing” look like; the vendor’s harness moves with the model, yours does not until you move it.

Cost, honestly

Token spend for the same work on the same model is identical either way. The deltas:

Hosted may use fewer tokens via on-demand tool loading and code-side result filtering. Measure on your workload.
Hosted adds container or session-hour charges; DIY adds your compute and a person.
Engineering time dominates below scale. A senior engineer maintaining a bespoke harness costs more than most teams’ inference bills. Above scale — millions of tasks a month — a few percent of tokens is worth that engineer.

Decision guide

Situation	Pick
ZDR contract, EU/UK residency, audited execution path	DIY loop on a compliant endpoint
Need to route tasks across OpenAI, Anthropic, Google and open models	DIY
Team of 1–5 shipping a cloud agent this month	Hosted
Multi-hour research/coding agents with subagents	Hosted (harness is the product)
Tightly scripted, low-token, very high volume	DIY, tuned
You already run a working SDK loop	Stay; hosted is a migration, not a flag
Unusual control flow (human-in-loop at odd points, custom planners)	DIY (or hosted only if steering hooks cover it)

Reducing lock-in either way

Put every tool behind an MCP server you control — it moves between harnesses unchanged.
Keep the sandbox neutral (self-hosted or a provider both vendors integrate with).
Maintain a vendor-agnostic eval set so a switch is a measurement, not a leap.
Export artifacts on completion; do not treat vendor session state as your system of record.