GloriaaaM/LLM-Agent-Harness-Survey

English | 中文

Agent Harness for Large Language Model Agents: A Survey

Official paper repository and living evidence index

Agent capability emerges from a model–harness–environment configuration. The harness decides how the model observes, acts, uses tools, manages context and state, crosses permission boundaries, recovers from failure, and leaves evidence for evaluation.

This is the official repository for Agent Harness for Large Language Model Agents: A Survey. The paper is the center of the project: it defines the object of study, introduces the ETCSLV analytical framework, reconstructs the field's historical lineages, compares representative systems, and sets an evaluation and research agenda. The resource index below keeps the survey's evidence base current between paper releases.

📄 Paper v4 · 🌐 Archived preprint v3 · 🗂️ Resource Index 2026.10 (evidence through 2026-10-13) · Paper v5 is in revision

Survey contributions · Framework · Systems · Benchmarks · Research library

---

Read and Cite the Survey

Qianyu Meng et al. (2026), Agent Harness for Large Language Model Agents: A Survey. The repository PDF is v4; the current DOI resolves to the archived v3 preprint. Paper v5 remains unpublished while its manuscript, figures, and references are being revised.

• Read: Paper v4 PDF
• Preprint: Archived v3 record
• Cite: DOI 10.20944/preprints202604.0428.v3

@article{meng2026agentharness,
  title     = {Agent Harness for Large Language Model Agents: A Survey},
  author    = {Meng, Qianyu and Wang, Yanan and Chen, Liyi and Wu, Wei and
               Li, Yihang and Jiang, Wenyuan and Wang, Qimeng and
               Lu, Chengqiang and Gao, Yan and Wu, Yi and Hu, Yao},
  year      = {2026},
  doi       = {10.20944/preprints202604.0428.v3},
  url       = {https://www.preprints.org/manuscript/202604.0428/v3},
  publisher = {Preprints}
}

---

What This Survey Contributes

Most agent reports foreground the model and task score while leaving the runtime configuration implicit. The survey makes that missing layer explicit and connects conceptual analysis to systems, benchmarks, and engineering evidence.

1. A joint unit of analysis. Agent behavior is studied at the model–harness–environment level, so results can be attributed to the configuration that produced them.
2. A shared architectural lens. ETCSLV organizes recurring harness functions into execution, tools, context, state, lifecycle, and evaluation.
3. A historical account. The survey connects software test harnesses, reinforcement-learning environments, early LLM-agent frameworks, and today's persistent agent runtimes.
4. A comparable system landscape. Thirty-four systems are assessed with the same evidence-coded component matrix, including coding, application-runtime, workplace, personal-agent, OS, and meta-harness routes. The set remains open as public evidence improves; Claude Code, Codex, DeepSeek Harness, and OpenClaw receive equal-depth treatment as anchor cases.
5. An evaluation map. Harness-effect benchmarks, lifecycle and security tests, long-horizon recovery, protocol benchmarks, evaluation infrastructure, and task environments are separated by what they actually vary.
6. A research agenda for evolving runtimes. The survey connects context, memory, tools, security, observability, and cost to harness evolution and bounded runtime self-improvement.

What the landscape reveals

• The harness is an experimental variable. Changing tools, context policy, state, permissions, or loop logic can change observed behavior even when the model is fixed.
• Architectural coverage and product maturity are different questions. ETCSLV records what a system exposes; reliability, adoption, and quality require their own evidence.
• Long-horizon agents turn traces and lifecycle events into research objects. Final-task success alone cannot explain recovery, policy decisions, accumulated state, or regressions.
• Runtime self-improvement needs an outer evaluation loop. Persistent changes should be isolated, tested on held-out tasks, versioned, gated for safety and cost, and reversible.

Survey and Repository Map

The README follows the survey's argument rather than presenting a detached software catalog. Read the numbered sections in order for the conceptual account; use each directory as the maintained evidence layer behind that part of the paper.

Survey question	Repository section	What you will find
What is the harness layer?	1. Conceptual Framework	Model–harness–environment boundary and ETCSLV
Where did this architecture come from?	2. Historical Evolution	Test harness, RL environment, LLM-agent, and runtime lineages
Which systems implement it?	3. System Landscape	Four anchor cases, an open 34-system evidence matrix, and a categorized directory
How should it be evaluated?	4. Evaluation Landscape	30 direct harness benchmarks, evaluation infrastructure, and task environments
What evidence supports each engineering problem?	5. Research Library	168 papers, specifications, architecture notes, and reports organized by engineering problem
How were entries selected and how does this relate to the paper?	About the Survey	Evidence rules, versions, citation, and contribution guide

---

1. Conceptual Framework

We analyze a harness as H = (E, T, C, S, L, V): six governance functions that repeatedly appear across public systems. The lens compares architectural coverage; product quality and production readiness require separate evidence.

Component	Symbol	What to look for
Execution Loop	E	Turn and step control, termination, retry, recovery, delegation
Tool Registry	T	Typed tools, routing, validation, authorization, result handling
Context Manager	C	Prompt assembly, retrieval, compaction, salience, provenance
State Store	S	Cross-turn and cross-session persistence, checkpoints, recovery
Lifecycle Hooks	L	Authentication, approval, policy, instrumentation, interception
Evaluation Interface	V	Trajectories, intermediate state, outcomes, experiments, audit

---

2. Historical Evolution

Year	Milestone	Why it matters to harnesses
1997–2005	JUnit, TestNG, xUnit family	Standardized setup, execution, observation, assertion, and teardown
2016	OpenAI Gym	Made step/reset a canonical interface between agents and environments
2022	ChatGPT and LangChain	Brought tool use and composable LLM applications into a common runtime pattern
2023	ReAct, Toolformer, MemGPT, Reflexion, Voyager, AutoGPT	Established reasoning–acting, memory, reflection, and skill accumulation patterns
2023	CAMEL, ChatDev, Generative Agents	Expanded orchestration to roles, teams, and social simulation
2023	AgentBench, SWE-bench	Made environment design and agent evaluation central infrastructure
2024	MetaGPT, WebArena, ToolLLM, SWE-agent, OSWorld	Connected agents to realistic tools, repositories, browsers, and desktops
2024	CodeAct, LATS, Tree of Thoughts	Explored executable actions and search-based control policies
2024	Model Context Protocol	Standardized a growing part of the tool-to-harness boundary
2025	HAL, AIOS, LangGraph, A2A	Advanced evaluation infrastructure, agent OS design, durable graphs, and agent interoperability
2025	MemoryOS, AgentBound†	Developed memory abstractions and runtime enforcement
2026	Antigravity, workplace and personal agents, Harness-Bench, HarnessX, LongHorizon-Harness, HarnessAudit-Bench, SCLATE	Expanded harnesses across coding, workplace, and personal agents while making harness choice, evolution, long-horizon operation, lifecycle risk, and auditability direct objects of study

---

3. System Landscape

The system landscape moves from depth to breadth: four anchor cases expose the runtime in detail, the evidence matrix applies one comparison scheme, and the directory preserves the wider ecosystem of systems, substrates, modules, and evaluation infrastructure. The comparison set is evidence-driven and open-ended; 34 is the current result of the inclusion rule, not a target or a claim of completeness. Product form is not an exclusion rule: workplace and personal agents belong when their runtime architecture is documented well enough to assess.

Four Anchor Systems

These four systems are the survey's anchor cases. They receive the same analytical weight because each exposes a distinct answer to the same runtime problem: how to turn model calls into governed, persistent, tool-using work.

• Claude Code — A vertically integrated coding harness that joins repository inspection, edits, commands, web and MCP tools, subagents, skills, hooks, permissions, checkpoints, and session continuation. Its CLI and Agent SDK make the execution and policy layers visible across interactive and programmable use.
• Codex — An open-source coding harness spanning terminal, IDE, app, and cloud workflows. Its runtime combines repository tools, sandboxing, approvals, MCP, skills, subagents, compaction, resumable threads, and structured events. The shared runtime makes long-horizon work inspectable across surfaces, while OpenAI's harness engineering account shows how those controls shape sustained software work.
• DeepSeek Harness — A plugin-native runtime in which model adapters, loops, tools, context projection, storage, telemetry, and interfaces are composed through profiles, bundles, and ordered patches. These boundaries let teams replace and audit the loop, context policy, tool behavior, and observability separately. The architecture, tool subsystem, and compaction design also provide a concrete base for bounded, evaluated, reversible harness-level improvement.
• OpenClaw — An always-on personal-agent harness organized around channels, sessions, tools, skills, memory, scheduled work, gateway routing, and sandboxed execution. It makes deployment continuity central: identity, credentials, background jobs, workspace state, and operational policy persist beyond a single chat turn. That operating model makes it a key case for studying durable personal agents rather than one-shot assistants.

Evidence-Coded Comparison Matrix

Ratings describe documented component coverage at the evidence cutoff. Quality, production maturity, and adoption are reported separately; popularity and stars serve only as adoption signals.

Legend: ● Full — built in and documented · ◐ Partial — limited, optional, or supplied by an official extension · ○ Absent — first-party material explicitly excludes it · ? Unverified — public evidence is insufficient.

Category	System	E	T	C	S	L	V
Anchor coding harnesses	Claude Code	●	●	●	◐	●	◐
Anchor coding harnesses	Codex	●	●	●	●	●	◐
Anchor coding harnesses	DeepSeek Harness	●	●	●	●	●	◐
Anchor coding harnesses	OpenClaw	●	●	●	●	●	◐
Coding harnesses	Antigravity CLI	●	●	●	●	●	◐
Coding harnesses	OpenCode	●	●	●	●	●	◐
Coding harnesses	Goose	●	●	◐	◐	●	◐
Coding harnesses	Grok Build	●	●	●	●	●	◐
Coding harnesses	Cline	●	●	◐	●	●	◐
Coding harnesses	OpenHands	●	●	●	●	●	◐
Coding harnesses	Deep Agents	●	●	●	●	●	●
Coding harnesses	Prime Agent	●	●	●	●	◐	◐
Coding harnesses	GitHub Copilot in VS Code	●	●	●	●	●	●
Coding harnesses	MiMo-Code	●	●	●	●	●	●
General runtimes	OpenAI Agents SDK	●	●	●	●	●	●
General runtimes	Google ADK	●	●	●	●	●	●
General runtimes	Microsoft Agent Framework	●	●	●	●	●	●
General runtimes	LangGraph	●	◐	◐	●	◐	◐
General runtimes	Mastra	●	●	●	●	●	●
Persistent, meta, and operational harnesses	DeerFlow	●	●	●	●	●	◐
Persistent, meta, and operational harnesses	AOHP	●	●	●	●	●	◐
Persistent, meta, and operational harnesses	Omnigent	●	●	◐	●	●	◐
Persistent, meta, and operational harnesses	TrueForge	●	●	●	●	●	●
Persistent, meta, and operational harnesses	LongHorizon-Harness	●	◐	●	●	●	●
Persistent, meta, and operational harnesses	Hermes Agent	●	●	●	●	●	●
Persistent, meta, and operational harnesses	SandBase	●	●	◐	●	●	●
Workplace and personal-agent harnesses	WorkBuddy	●	●	●	●	●	●
Workplace and personal-agent harnesses	Muse	●	●	●	●	●	◐
Workplace and personal-agent harnesses	Amazon Quick	●	●	●	●	●	●
Workplace and personal-agent harnesses	OpenAI Workspace Agents	●	●	●	●	●	◐
Workplace and personal-agent harnesses	QwenWork	●	●	●	●	●	?
Workplace and personal-agent harnesses	OpenAI dots	●	●	●	●	●	◐
Workplace and personal-agent harnesses	Grok Bot	●	●	●	●	●	?
Workplace and personal-agent harnesses	OpenJarvis	●	●	●	●	●	●

System Directory

The matrix includes every current system for which first-party material is sufficient to rate the six components at a useful level. It is neither a top-34 list nor a maturity ranking. Systems with a different analysis unit, incomplete evidence, or a narrower capability remain visible in the categorized directory below.

Compared coding harnesses

The four featured systems above are joined by ten coding harnesses in the comparison set.

• Antigravity CLI — Google's current coding harness, with dynamic subagents, asynchronous tasks, skills, hooks, project permissions, scheduled work, and a CLI that carries these controls into terminal workflows. It succeeds Gemini CLI for consumer use; Google documents the migration separately.
• OpenCode — An open-source coding agent with terminal and client/server surfaces, multi-provider model support, tool execution, sessions, and extensibility.
• Goose — A local, extensible coding agent whose tools and integrations are exposed through extensions and MCP-compatible interfaces.
• Grok Build — xAI's open coding-agent harness for repository work, tool use, context handling, and iterative verification.
• Cline — An IDE coding agent with plan/act workflows, checkpoints, browser and terminal tools, MCP integrations, and explicit approval points.
• OpenHands — A platform for software-development agents with isolated runtimes, event streams, tool execution, browsing, delegation, and evaluation integrations.
• Deep Agents — A batteries-included agent harness that combines planning, filesystems, subagents, context management, memory, and LangGraph execution.
• Prime Agent — A coding-agent system centered on long-running repository tasks, execution environments, trajectory capture, and training/evaluation workflows.
• GitHub Copilot in VS Code — An editor-native production harness with model-specific context and tool adaptation, explicit loop control, portable sessions, permission hooks, and a documented evaluation pipeline.
• MiMo-Code — Xiaomi's terminal coding harness with persistent project memory, checkpoints, context reconstruction, subagents, skills, MCP, permission rules, and judge-driven research and experiment loops.

General agent runtimes

• OpenAI Agents SDK — A runtime for tools, handoffs, guardrails, sessions, tracing, and multi-agent workflows. OpenAI's 2026 architecture update extends the same runtime toward longer-lived, stateful work.
• Google ADK — An agent development kit with workflow agents, tools, sessions, callbacks, evaluation, and deployment integrations.
• Microsoft Agent Framework — Microsoft's runtime for agents, workflows, middleware, memory, tools, observability, and evaluation; its Build 2026 update documents the platform's current direction.
• LangGraph — A stateful graph runtime for durable execution, checkpoints, interrupts, streaming, and human-in-the-loop agent workflows.
• Mastra — A TypeScript-native application runtime with autonomous agents, graph workflows, tools and MCP, stored suspend/resume state, memory, observability, and built-in evaluation.

Persistent, meta, OS, and operational harnesses

• DeerFlow — A modular agent harness for research and coding workflows with subagents, skills, memory, sandbox execution, and long-running tasks.
• AOHP — An OS-level harness for personalized interaction, local resources, efficiency, and security boundaries.
• Omnigent — A general agent platform joining tool use, state, memory, policy, and multi-surface execution.
• TrueForge — A self-hosted, vendor-neutral runtime and control plane spanning model calls, MCP and skills, sandboxing, approvals, deferred tools, context compaction, persistent sessions, identity, inspection, and reproducible experiments. Engineering note
• LongHorizon-Harness — A meta-harness that wraps existing coding agents in plan–act–verify, durable state, role isolation, audit, checkpoint, and recovery loops. Paper
• Hermes Agent — A persistent personal-agent runtime with memory, agent-created skills, multi-channel gateways, several sandbox backends, subagents, approvals, checkpoints, context compression, trajectories, and batch evaluation. Docs
• SandBase — A local-first operations and security control plane with resumable sessions, audit and replay, MCP toolsets, credential and approval policy, several sandbox backends, typed SDKs, and conformance tests.
• CUGA — IBM Research's open-source generalist agent harness on LangGraph that runs API (OpenAPI, MCP, LangChain tools), web, and hybrid tasks under configurable policies (intent guard, playbooks, tool approval), with skills, A2A sub-agents, and ACP. Paper
• oh-my-agent — An open-source harness layered on existing coding agents that installs into 14 runtimes (Claude Code, Codex CLI, Cursor and others), shares skills from one .agents/skills/ folder with supported runtimes, and has an optional Stop hook that runs the project's typecheck, test or lint script before the agent finishes.

Workplace and personal-agent harnesses

• WorkBuddy — Tencent Cloud's office harness plans and executes cross-tool work across messaging, documents, mail, meetings, and knowledge bases. Its open platform and managed-agent runtime expose skills, MCP/OAuth/A2A, multi-agent orchestration, context compression, memory, isolated execution, recovery, traces, evaluation, and lifecycle governance.
• Muse — Meta's personal-agent harness runs each agent in a persistent isolated VM with a browser, filesystem, terminal, memory, connected apps, self-built tools, scheduled and event-driven work, action approvals, credential isolation, and a complete activity trail. Design account · Launch and security architecture
• Amazon Quick — A workplace harness combining autonomous background agents, reusable flows, enterprise data spaces, granular autonomy, identity propagation, approvals, monitoring, and test runs with logs and watch variables.
• OpenAI Workspace Agents — Codex-powered organizational agents with shared skills, files, apps and MCP, cloud execution, schedules and Slack triggers, approval handoffs, role-based publishing, version history, analytics, and Compliance API visibility.
• QwenWork — A personal and organizational work platform with explicit Agent sessions, plans and intermediate results, files, skills, connectors, scheduled tasks, computer use, workspace isolation, and sensitive-action confirmation; a public general evaluator remains unverified.
• OpenAI dots — Always-on personal agents with a dedicated cloud computer and browser, plugins, persistent memory and notes, scheduled and proactive work, local and Codex-cloud actions, custom rules, auto-review, and approvals.
• Grok Bot — A persistent cloud-computer agent with browser, terminal, apps, parallel bots, bot-to-bot coordination, chief-of-staff hierarchies, and demonstration-to-routine learning; enterprise controls add isolation, access, network, and audit governance.
• OpenJarvis — A local-first, on-device personal-agent stack with typed runtime primitives, multiple agent loops, tools and MCP, sandboxing, several memory backends, scheduled operatives, full traces, trace-driven routing, and joint accuracy, latency, energy, and cost evaluation. Paper

Workplace and personal-agent watchlist

These systems remain in the index while their public architecture, maturity, or independent analysis unit is still emerging.

• Microsoft Copilot Autopilot — A preview workplace agent with its own identity, memory, computer, workspace, and enterprise governance; public tool and evaluation documentation is still limited.
• Google Workspace Studio — An agentic workplace flow builder with a 2026 least-privilege, HITL, DLP, drift-detection, and audit update.
• Claude Tag — A shared, persistent workplace interaction built from Claude Code and Cowork concepts; treated as a product surface of that lineage until a distinct runtime boundary is documented.
• Claude Managed Agents — Long-running enterprise sessions with per-tool permissions, credential vaulting, and audit logs; retained as a workplace deployment case related to the Claude runtime lineage.
• nanoMuse — A new open personal agent spanning phones and desktops with scheduled goals, editable memory, and risk gates; parts of the system build on DeepSeek Harness and OpenMinis. Paper
• Qwen Book — An early “OS as harness” workplace device combining model, operating system, apps, cloud, context, memory, execution, and governance; detailed component evidence is still limited.

Extended catalog

• Aider — Terminal pair programming with repository maps, edit formats, git integration, and broad model support.
• mini-SWE-agent — A deliberately minimal software-engineering agent with a short linear loop, multiple sandbox backends, trajectory inspection, and broad benchmark use; the SWE-agent maintainers recommend it for new work.
• SWE-agent — An agent-computer interface designed for solving software-engineering issues in repository environments.
• AutoGen — An event-driven framework for conversational and multi-agent applications.
• MetaGPT — A multi-agent software workflow organized around roles, standard operating procedures, and shared artifacts.
• CAMEL — A multi-agent framework for role-playing, tool use, memory, and agent societies.
• ChatDev — A virtual software company that coordinates specialized agents through a staged development process.
• AIOS — A research operating-system architecture that separates an agent kernel from the Cerebrum SDK and mediates models, tools, memory, storage, and access control; it remains historically important, while its analysis unit and incomplete public lifecycle/evaluation evidence differ from the full runtime matrix.
• Raven — A composable “harness of harnesses” for assembling and coordinating agent capabilities.
• Open SWE — An open-source asynchronous coding-agent reference built for delegated repository work.
• QM — An open coding-agent project exploring autonomous repository work and tool-driven development.
• Eve — Vercel's open agent project for iterative software work and execution-driven feedback.
• Shepherd — An agent orchestration project for coordinating development tasks and specialized workers.
• YYLO — A CLI for orchestrating coding agents with plugins, evidence capture, and longitudinal workflows.
• Gemini CLI — Google's earlier open-source terminal agent. Its consumer service migrated to Antigravity CLI in June 2026; the repository remains useful as an architectural lineage. Migration notice

Long-horizon and domain-specific harnesses

• RobotUse — A robot agent harness combining visual target and pose selection, subagent-local interaction histories, and persistent playbooks for learning from execution, with geometry, motion planning, and control handled by the backend. Paper · Project
• CheetahClaws — A research harness for system-level scaling around fixed models, including orchestration, tools, context, and parallel work. Paper
• DataFlow-Harness — A data-centric harness for composing, running, and evaluating agentic data workflows. Paper

Durable execution, protocols, and sandbox substrates

These projects provide infrastructure that a harness can run on or connect through. They are listed separately because durable execution, protocol hosting, or sandboxing does not by itself constitute a complete agent harness.

• Google AX — Durable execution infrastructure for distributed, long-running agents; Google's Agent Executor architecture explicitly supports bringing an existing harness.
• Agent Substrate — A persistence substrate with event logs, snapshots, branching, suspension, and resumption for agent runtimes.
• VS Code Agent Host — An editor-side host for coordinating coding-agent sessions, tools, permissions, and lifecycle events.
• Agent Host Protocol — A transport and protocol boundary between coding agents and host surfaces.

Capability modules and research patterns

These projects are evaluated for their focused capability or research pattern rather than full-stack component coverage.

• MemGPT — Tiered memory and context management inspired by operating systems.
• Reflexion — Verbal feedback and reflective memory across trials.
• Voyager — Open-ended skill acquisition, curriculum generation, and reusable code skills.
• Generative Agents — Memory, reflection, and planning for believable social agents.
• Concordia — A library for generative agent-based simulations grounded in physical, social, or digital worlds.
• SkillOpt — Bounded skill optimization from scored trajectories with evaluation gates.
• Harness² — Early research code for proposing, probing, and composing persistent changes to prompts, guardrails, memory, tool guidance, subagents, skills, scripts, and plugins.

Evaluation infrastructure

• HAL — Unified agent execution, evaluation, and leaderboard infrastructure.
• Harbor — Interchangeable agents, models, datasets, container environments, traces, and parallel rollouts. Paper
• AgentCompass — Infrastructure that separates benchmark, harness, and environment for reproducible agent evaluation.
• BrowserGym — A common environment and evaluation layer for web-agent research.
• lm-evaluation-harness — A widely used evaluation runner for language models; included as the lineage and naming reference for modern agent harness evaluation.

---

4. Evaluation Landscape

A benchmark belongs here when it reveals something about the runtime around the model: component choice, state over time, recovery, permissions, auditability, protocol behavior, or evaluation infrastructure. Every result should identify the model, harness, environment, task version, budget, and evaluator together.

1. Harness effect

• Harness-Bench — Compares model–harness configurations under shared sandboxed tasks, environments, budgets, and evaluation.
• Beyond the Model — Isolates the effects of tool registries, context compression, planning, subagents, and lazy skills.
• LongHarness Bench — Evaluates the accuracy and efficiency of harnesses for long-context work.
• Harness the Memory — Compares memory substrates in a shared harness across models and task suites.
• WildClawBench — Uses bilingual, multimodal, human-authored CLI tasks to compare how different harnesses shape results around the same underlying model family.

2. Harness evolution and runtime self-improvement

• EVOHARNESSBENCH — Measures retention and adaptation as tools, skills, and agents change over time.
• SkillOpt — Generates bounded skill edits from scored trajectories and accepts them through held-out evaluation gates.
• SCLATE — Places sessions, scheduled tasks, and memory consolidation on a shared event timeline.
• TaoLive — Studies harness-aware training for agents that must evolve with a changing runtime.
• Meta-Harness — Optimizes model harnesses end to end.
• AutoHarness — Synthesizes code harnesses to improve an agent around a fixed model.
• VeRO — Provides an evaluation harness in which agents evaluate and optimize other agents.
• AgentSWE — Evaluates agents across the lifecycle of creating, editing, and improving agent codebases, making the harness itself the object of software work.

3. Lifecycle, security, and audit

• HarnessRisk — Tests risks across configuration, extension, runtime, persistence, action, and recovery phases.
• HarnessSecurity-Bench — Measures utility and attack effects across real coding harnesses and permission settings.
• Hearsay — Tests whether harness-produced records support independent audit.
• SandboxEscapeBench — Measures whether models discover and exploit deliberately seeded sandbox misconfigurations and vulnerabilities.
• HarnessAudit-Bench — Evaluates trajectory-boundary compliance, execution fidelity, and system stability across harness configurations rather than relying only on final answers.

4. Long-horizon loops and recovery

• LoopsBench — Evaluates sustained development loops and the ability to keep making valid progress.
• Long-Horizon-Terminal-Bench — Tests agents on extended terminal tasks with accumulating state.
• SWE-Chain — Evaluates dependent software changes and obligations that propagate across a chain.
• ChainSWE — Measures repository work where later tasks depend on earlier changes and preserved state.
• Hell or High Water — Evaluates recovery from external failures during agent execution.

5. Protocol and tool substrate

• DynamicMCPBench — Evaluates live and changing MCP servers, tools, and state.
• MCP-Bench — Benchmarks end-to-end tool use through the Model Context Protocol.
• MCP-AgentBench — Tests MCP-based agents across tool discovery, selection, and execution.
• MCPAgentBench — Evaluates tool discrimination and stateful MCP interaction.

6. Evaluation infrastructure

• AgentCompass — Makes benchmark, harness, and environment explicit experimental units.
• Harbor — Runs interchangeable agents and models in containerized datasets with traces and parallel rollouts.
• HAL — Supplies unified execution and leaderboard infrastructure for agent evaluation.

Task environments

These benchmarks ask what tasks an agent can complete. Harness studies use them as task substrates and add controls that isolate the runtime as an experimental variable.

• RoboQuest — Simulated mobile-manipulation tasks for multimodal agents acting through tool calls; hidden information must be found by searching, inspecting, or testing. Paper
• AgencyBench — Long-context, consequential tasks for autonomous agents; report its aggregate and ecosystem-specific findings separately.
• ClawBench — Everyday online tasks for personal and computer-use agents. Paper
• OSWorld — Open-ended computer tasks in real operating-system environments.
• WebArena — Realistic websites and end-to-end tasks for autonomous web agents.
• GAIA — General-assistant questions that require reasoning, tools, and multiple modalities.
• SWE-bench — Real GitHub issues resolved against executable repositories.
• EC2-Bench — OpenClaw workspace tasks run by an edge model that can call a cloud model; compares who controls cloud invocation (external router vs. edge agent) on completion, cost, and privacy exposure. Paper

---

5. Research Library

Historical Lineages

Software Test Harnesses (1990s–2000s)

• JUnit: "JUnit: A Cook's Tour". Beck & Gamma. Java Report, 4(5), May 1999. [Archived article]

RL Environment Harnesses (2016–2022)

• OpenAI Gym: "OpenAI Gym". Brockman et al. arXiv 2016. [Paper] [Code]
• Gymnasium: "Gymnasium: A Standard Interface for Reinforcement Learning Environments". Towers et al. NeurIPS 2025. [Paper] [Code]

Early LLM Agent Frameworks (2023–2024)

• ReAct: "ReAct: Synergizing Reasoning and Acting in Language Models". Yao et al. ICLR 2023. [Paper] [Code]
• Toolformer: "Toolformer: Language Models Can Teach Themselves to Use Tools". Schick et al. NeurIPS 2023. [Paper]
• AutoGPT: "Auto-GPT: An Autonomous GPT-4 Experiment". Gravitas et al. GitHub 2023. [Code]
• BabyAGI: "BabyAGI". Nakajima. GitHub 2023. [Code]
• HuggingGPT: "HuggingGPT: Solving AI Tasks with ChatGPT and Its Friends in Hugging Face". Shen et al. NeurIPS 2023. [Paper]
• LangChain: "LangChain: Building Applications with LLMs through Composability". Chase et al. GitHub 2022. [Code]

---

Research by Engineering Problem

The hardest harness problems appear where execution, context, state, permissions, and evaluation meet. The nine reading lists below organize papers, benchmarks, and practitioner evidence by engineering problem; every source remains individually visible for scanning and citation.

Security & Sandboxing

Challenge: Agent sandboxes must prevent malicious tool use while permitting legitimate system access — a harder problem than traditional application sandboxing because agents intentionally interact with sensitive resources (file systems, network APIs, shell commands).

State of the art: SandboxEscapeBench measures whether models can exploit deliberately vulnerable sandbox configurations, while PRISM studies runtime interception and defense in depth. Together they motivate testing both isolation boundaries and the policies that mediate privileged actions; neither establishes a universal sandbox configuration for every agent workload.

Open problems: Compositional security properties (proving agent + harness + environment satisfy a safety specification) remain unsolved. Current defenses are reactive (detecting escapes) rather than preventive (proving impossibility of escape).

Evidence focus: SandboxEscapeBench tests whether models can discover and exploit deliberately seeded sandbox misconfigurations and vulnerabilities. The result motivates configuration testing and defense in depth; it is not a generic escape rate for correctly configured containers.

• SandboxEscapeBench†: "Quantifying Frontier LLM Capabilities for Container Sandbox Escape". Marchand et al. arXiv 2026. [Paper]
• InjecAgent: "InjecAgent: Benchmarking Indirect Prompt Injections in Tool-Integrated Large Language Model Agents". Zhan et al. arXiv 2024. [Paper]
• ToolHijacker†: "Prompt Injection Attack to Tool Selection in LLM Agents". Shi et al. NDSS 2026. [Paper]
• Securing MCP†: "Securing the Model Context Protocol (MCP): Risks, Controls, and Governance". Errico et al. arXiv 2025. [Paper]
• SHIELDA†: "SHIELDA: Structured Handling of Exceptions in LLM-Driven Agentic Workflows". Zhou et al. arXiv 2025. [Paper]
• PALADIN†: "PALADIN: Self-Correcting Language Model Agents to Cure Tool-Failure Cases". Vuddanti et al. ICLR 2026. [Paper]
• AgentBound†: "Securing AI Agent Execution". Bühler et al. arXiv 2025. [Paper]
• AgentSpec†: "Agentspec: Customizable runtime enforcement for safe and reliable llm agents". Wang et al. arXiv 2025. [Paper]
• AgentSys†: "AgentSys: Secure and Dynamic LLM Agents Through Explicit Hierarchical Memory Management". Wen et al. arXiv 2026. [Paper]
• Docker: "Docker: Lightweight Linux Containers for Consistent Development and Deployment". Merkel. Linux Journal 2014(239). [Paper]
• gVisor: "The True Cost of Containing: A gVisor Case Study". Young et al. HotCloud '19. [Paper]
• Firecracker: "Firecracker: Lightweight Virtualization for Serverless Applications". Agache et al. NSDI 2020. [Paper]
• WebAssembly: "Bringing the Web up to Speed with WebAssembly". Haas et al. PLDI 2017. [Paper]
• Indirect Prompt Injection: "Not What You've Signed Up For: Compromising Real-World LLM-Integrated Applications with Indirect Prompt Injection". Greshake et al. AISec 2023. [Paper]
• Misevolution Risks†: "Your agent may misevolve: Emergent risks in self-evolving llm agents". Shao et al. arXiv 2025. [Paper]
• Security Threat Modeling†: "Security Threat Modeling for Emerging AI-Agent Protocols: A Comparative Analysis of MCP, A2A, Agora, and ANP". Anbiaee et al. arXiv 2026. [Paper]
• AgentHarm†: "AgentHarm: A Benchmark for Measuring Harmfulness of LLM Agents". Andriushchenko et al. arXiv 2024. [Paper]
• TrustAgent: "TrustAgent: Towards Safe and Trustworthy LLM-Based Agents". Hua et al. EMNLP 2024. [Paper]
• ToolEmu†: "Identifying the Risks of LM Agents with an LM-Emulated Sandbox". Ruan et al. arXiv 2023. [Paper]
• Ignore Previous Prompt: "Ignore Previous Prompt: Attack Techniques For Language Models". Perez & Ribeiro. NeurIPS ML Safety Workshop 2022. [Paper]
• AgentFlow†: "Synthesizing Multi-Agent Harnesses for Vulnerability Discovery". Liu et al. arXiv 2026. [Paper]

Evaluation & Benchmarking

Evidence focus: Harness evaluation must report the runtime, environment, task version, budget, trajectory capture, and evaluator together. HAL, OSWorld, and METR illustrate different failure sources: execution variance, evaluator error, and disagreement between benchmark acceptance and human review.

• AgencyBench†: "AgencyBench: Benchmarking the Frontiers of Autonomous Agents in 1M-Token Real-World Contexts". Li et al. arXiv 2026. [Paper]
• AEGIS†: "AEGIS: No Tool Call Left Unchecked -- A Pre-Execution Firewall and Audit Layer for AI Agents". Yuan et al. arXiv 2026. [Paper]
• Hell or High Water†: "Hell or High Water: Evaluating Agentic Recovery from External Failures". Wang et al. COLM 2025. [Paper]
• SearchLLM†: "Aligning Large Language Models with Searcher Preferences". Wu et al. arXiv 2026. [Paper]
• Meta-Harness†: "Meta-Harness: End-to-End Optimization of Model Harnesses". Lee et al. arXiv 2026. [Paper]
• AutoHarness†: "AutoHarness: improving LLM agents by automatically synthesizing a code harness". Lou et al. arXiv 2026. [Paper]
• MASEval†: "MASEval: Extending Multi-Agent Evaluation from Models to Systems". Emde et al. arXiv 2026. [Paper]
• VeRO†: "VeRO: An Evaluation Harness for Agents to Optimize Agents". Ursekar et al. arXiv 2026. [Paper]
• ClawBench†: "ClawBench: Can AI Agents Complete Everyday Online Tasks?". Zhang et al. arXiv 2026. [Paper] [Code] [Project]
• TheAgentCompany†: "TheAgentCompany: Benchmarking LLM Agents on Consequential Real-World Tasks". Xu et al. arXiv 2024. [Paper]
• BrowserGym†: "The BrowserGym Ecosystem for Web Agent Research". Le Sellier De Chezelles et al. arXiv 2024. [Paper]
• WorkArena†: "WorkArena: How Capable are Web Agents at Solving Common Knowledge Work Tasks?". Drouin et al. arXiv 2024. [Paper]
• R-Judge: "R-Judge: Benchmarking Safety Risk Awareness for LLM Agents". Yuan et al. EMNLP 2024. [Paper]
• R2E: "R2E: Turning any GitHub Repository into a Programming Agent Environment". Jain et al. ICML 2024. [Paper]
• Evaluation Survey: "Evaluation and Benchmarking of LLM Agents: A Survey". Mohammadi et al. KDD 2025. [Paper]
• PentestJudge†: "PentestJudge: Judging Agent Behavior Against Operational Requirements". Caldwell et al. arXiv 2025. [Paper]
• PerspectiveGap†: "PerspectiveGap: A Benchmark for Multi-Agent Orchestration Prompting". Sun et al. arXiv 2026. [Paper] [Code]
• TraceDance†: "TraceDance: An Automated System for Building Agent Behavior Benchmarks from Real-World Agent Deployment Traces". Min et al. arXiv 2026. [Paper] [Project]
  • Constructs behavior-specific benchmarks from deployment traces and scores an LLM's next turn in a fixed recorded harness context, without executing its actions or replaying the environment.
• WildClawBench†: "WildClawBench: A Benchmark for Real-World, Long-Horizon Agent Evaluation". Ding et al. arXiv 2026. [Paper]
• HarnessAudit-Bench†: "Auditing Agent Harness Safety". Liu et al. arXiv 2026. [Paper]
• AgentSWE†: "AgentSWE: Can Coding Agents Build the Agent You Actually Want?". Wang et al. arXiv 2026. [Paper]
• EC2-Bench†: "Empowering Edge Agents: A Systematic Analysis of Edge-Cloud Collaboration in LLM Agent Execution". Huang et al. arXiv 2026. [Paper] [Code] [Project]

Protocol Standardization

Evidence focus: MCP, A2A, ACP, and related protocols operate at different interface layers. Their utility depends on semantics, state handling, authorization, error behavior, and testable interoperability, rather than protocol names alone.

• MCP: "Model Context Protocol". Anthropic. Technical Report 2024. [Spec]
• A2A: "Agent-to-Agent Protocol". Google. Technical Report 2025. [Spec] [Announcement]
• Protocol Comparison†: "A Survey of Agent Interoperability Protocols: Model Context Protocol (MCP), Agent Communication Protocol (ACP), Agent-to-Agent Protocol (A2A), and Agent Network Protocol (ANP)". Ehtesham et al. arXiv 2025. [Paper]
• Gorilla: "Gorilla: Large Language Model Connected with Massive APIs". Patil et al. NeurIPS 2023. [Paper] [Code]

Runtime Context Management

Evidence focus: SkillsBench and long-context studies show that adding context is not enough: selection, placement, compaction, provenance, and conflict handling determine whether additional material helps the agent.

• SkillsBench†: "SkillsBench: Benchmarking How Well Agent Skills Work Across Diverse Tasks". Li et al. arXiv 2026. [Paper]
• ReadAgent: "A Human-Inspired Reading Agent with Gist Memory of Very Long Contexts". Lee et al. ICML 2024. [Paper]
• MemoryOS: "Memory OS of AI Agent". Kang et al. arXiv 2025. [Paper]
• CoALA: "Cognitive Architectures for Language Agents". Sumers et al. TMLR 2024. [Paper]
• SkillFortify†: "Formal Analysis and Supply Chain Security for Agentic AI Skills". Bhardwaj. arXiv 2026. [Paper]
• Lost in the Middle: "Lost in the Middle: How Language Models Use Long Contexts". Liu et al. TACL 2024. [Paper]
• Context Engineering Survey†: "Context Engineering: A Survey of 1,400 Papers on Effective Context Management for LLM Agents". Mei et al. arXiv 2025. [Paper]

Tool Use & Registry

Evidence focus: Tool reliability depends on more than the number of available tools. Tool selection, typed contracts, semantic authorization, result validation, and recovery policy interact across the execution loop.

• CodeAct: "Executable Code Actions Elicit Better LLM Agents". Wang et al. ICML 2024. [Paper] [Code]
• Schema First†: "Schema First Tool APIs for LLM Agents: A Controlled Study of Tool Misuse, Recovery, and Budgeted Performance". Sigdel & Baral. arXiv 2026. [Paper]
• ToolLLM: "ToolLLM: Facilitating Large Language Models to Master 16000+ Real-world APIs". Qin et al. ICLR 2024. [Paper] [Code]
• ToolSandbox†: "ToolSandbox: A Stateful, Conversational, Interactive Evaluation Benchmark for LLM Tool Use Capabilities". Lu et al. arXiv 2024. [Paper]
• AutoTool†: "AutoTool: Efficient Tool Selection for Large Language Model Agents". Jia & Li. AAAI 2026. [Paper]
• Tool Learning Survey: "Tool Learning with Large Language Models: A Survey". Qu et al. Frontiers of Computer Science 2024. [Paper]
• GoEX†: "GoEX: Perspectives and Designs Towards a Runtime for Autonomous LLM Applications". Patil et al. arXiv 2024. [Paper]
• AgentTuning: "AgentTuning: Enabling Generalized Agent Abilities for LLMs". Zeng et al. ACL 2024. [Paper]
• HEART†: "Harness Engineering in LLM Tool Use via Agent-Native Reusable Tool Primitives". Jin et al. arXiv 2026. [Paper]

Memory Architecture

Evidence focus: Memory systems trade off retrieval quality, write policy, temporal consistency, provenance, latency, and cost. No single substrate is uniformly best across task types and interaction horizons.

• Agent Workflow Memory (AWM)†: "Agent Workflow Memory". Wang et al. arXiv 2024. [Paper]
• Mem0†: "Mem0: Building Production-Ready AI Agents with Scalable Long-Term Memory". Khant et al. arXiv 2025. [Paper]
• A-MEM†: "A-MEM: Agentic Memory for LLM Agents". Xu et al. NeurIPS 2025. [Paper]
• MemAct†: "Memory as Action: Autonomous Context Curation for Long-Horizon Agentic Tasks". Zhang et al. arXiv 2025. [Paper]
• Memory Survey†: "Memory for Autonomous LLM Agents: Mechanisms, Evaluation, and Emerging Frontiers". Du. arXiv 2026. [Paper]
• MemoryBank: "MemoryBank: Enhancing Large Language Models with Long-Term Memory". Zhong et al. AAAI 2024. [Paper]
• LoCoMo†: "Evaluating Very Long-Term Conversational Memory of LLM Agents". Maharana et al. arXiv 2024. [Paper]
• Memory Mechanisms Survey†: "A Survey on the Memory Mechanism of Large Language Model Based Agents". Zhang et al. arXiv 2024. [Paper]
• Evo-Memory†: "Evo-Memory: Benchmarking LLM Agent Test-time Learning with Self-Evolving Memory". Wei et al. arXiv 2025. [Paper]

Planning & Reasoning

Key numbers: SWE-agent ACI study shows interface design outweighs model capability as the primary performance determinant. LATS integrates MCTS with language model feedback for state-space search. Plan-on-Graph enables adaptive self-correcting planning on knowledge graphs through guidance, memory, and reflection mechanisms.

• Tree of Thoughts: "Tree of Thoughts: Deliberate Problem Solving with Large Language Models". Yao et al. NeurIPS 2023. [Paper] [Code]
• LATS: "Language Agent Tree Search Unifies Reasoning, Acting, and Planning in Language Models". Zhou et al. arXiv 2023. [Paper] [Code]
• Plan-on-Graph: "Plan-on-Graph: Self-Correcting Adaptive Planning of Large Language Model on Knowledge Graphs". Chen et al. NeurIPS 2024. [Paper]
• AFlow†: "AFlow: Automating Agentic Workflow Generation". Zhang et al. arXiv 2024. [Paper]
• Agent Q†: "Agent Q: Advanced Reasoning and Learning for Autonomous AI Agents". Putta et al. arXiv 2024. [Paper]
• OPENDEV†: "Building Effective AI Coding Agents for the Terminal: Scaffolding, Harness, Context Engineering, and Lessons Learned". Bui. arXiv 2026. [Paper]
• AOrchestra†: "AOrchestra: Automating Sub-Agent Creation for Agentic Orchestration". Ruan et al. arXiv 2026. [Paper]
• RAP: "Reasoning with Language Model is Planning with World Model". Hao et al. EMNLP 2023. [Paper]
• Inner Monologue: "Inner Monologue: Embodied Reasoning Through Planning with Language Models". Huang et al. CoRL 2022. [Paper]
• Agent-Oriented Planning: "Agent-Oriented Planning in Multi-Agent Systems". Li et al. ICLR 2025. [Paper]
• ExACT†: "ExACT: Teaching AI Agents to Explore with Reflective-MCTS and Exploratory Learning". Yu et al. arXiv 2024. [Paper]
• Steer, Don't Solve†: "Steer, Don't Solve: Training Small Critic Models for Large Code Agents". Gandhi et al. arXiv 2026. [Paper] [Code]
• LongHorizon-Harness†: "LongHorizon-Harness: Advancing Long-Horizon Agents for Real-World Tasks". Ma et al. arXiv 2026. [Paper] [Code]

Multi-Agent Coordination

Evidence focus: AgencyBench reports 48.4% aggregate performance for closed models versus 32.1% for open models, and separately observes native-ecosystem advantages for some proprietary systems. The aggregate 48.4% figure is not a native-SDK success rate.

• AdaptOrch†: "AdaptOrch: Task-Adaptive Multi-Agent Orchestration in the Era of LLM Performance Convergence". Yu. arXiv 2026. [Paper]
• SAGA†: "SAGA: A Security Architecture for Governing AI Agentic Systems". Syros et al. NDSS 2026. [Paper]
• MAS-FIRE†: "MAS-FIRE: Fault Injection and Reliability Evaluation for LLM-Based Multi-Agent Systems". Jia et al. arXiv 2026. [Paper]
• Byzantine fault tolerance†: "Rethinking the Reliability of Multi-agent System: A Perspective from Byzantine Fault Tolerance". Zheng et al. arXiv 2025. [Paper]
• Multi-agent baseline study†: "Rethinking the Value of Multi-Agent Workflow: A Strong Single Agent Baseline". Xu et al. arXiv 2026. [Paper]
• AgentVerse†: "AgentVerse: Facilitating Multi-Agent Collaboration and Exploring Emergent Behaviors". Chen et al. arXiv 2023. [Paper]
• Mixture-of-Agents†: "Mixture-of-Agents Enhances Large Language Model Capabilities". Wang et al. arXiv 2024. [Paper]
• Multi-Agent Survey: "Large Language Model Based Multi-Agents: A Survey of Progress and Challenges". Guo et al. IJCAI 2024. [Paper]
• Concordia†: "Generative Agent-Based Modeling with Actions Grounded in Physical, Social, or Digital Space Using Concordia". Vezhnevets et al. arXiv 2023. [Paper]
• PEvo: "Implicit Behavioral Alignment of Language Agents in High-Stakes Crowd Simulations". Wang et al. EMNLP 2025. [Paper]
• Agon†: "Agon: An Autonomous Large-Scale Omnidisciplinary Research System Built on Prompt Economy". Sun et al. arXiv 2026. [Paper] [Code]

Compute Economics

Evidence focus: Harness economics should report tokens, wall-clock time, tool and environment cost, concurrency, retries, failed work, and quality together. Throughput alone does not describe the cost of a long-running agent task.

• State of AI Report: "State of AI: An Empirical 100 Trillion Token Study with OpenRouter". Aubakirova et al. Andreessen Horowitz (a16z) and OpenRouter Inc., December 2025. [Report]
• BentoML Inference Report: "Beyond Tokens-per-Second: How to Balance Speed, Cost, and Quality in LLM Inference". Yang. BentoML Blog, January 2026. [Blog]
• H100 Price Spike: "H100 Price Spike: Understanding the 10% Surge in GPU Rental Costs". Li. Silicon Data Blog, January 2026. [Blog]
• NVIDIA GTC 2026: "NVIDIA GTC 2026: Live Updates on What's Next in AI". NVIDIA. NVIDIA Blog, March 2026. [Blog]
• Repo2Run†: "Repo2Run: Automated Building Executable Environment for Code Repository at Scale". Hu et al. arXiv 2025. [Paper]
• Policy-First†: "Guardrails as Infrastructure: Policy-First Control for Tool-Orchestrated Workflows". Sigdel & Baral. arXiv 2026. [Paper]
• Strong-Weak Collaboration: "An Empirical Study on Strong-Weak Model Collaboration for Repo-level Code Generation". Gandhi et al. EMNLP 2025. [Paper] [Code]

---

Harness Architectures and Evolution

• AutoRef†: "AutoRef: Harness Optimization for Agentic Multi-Reference Image Generation". Oshima et al. arXiv 2026. [Paper] [Code]
• Harness Engineering for Language Agents†: "Harness Engineering for Language Agents: The Harness Layer as Control, Agency, and Runtime". He et al. Preprints 2026. [Paper]
• DeepAgent†: "Deepagent: A general reasoning agent with scalable toolsets". Li et al. arXiv 2025. [Paper]
• Natural-Language Harnesses†: "Natural-Language Agent Harnesses". Pan et al. arXiv 2026. [Paper]
• Self-Evolving Agents Survey†: "A Survey of Self-Evolving Agents: What, When, How, and Where to Evolve on the Path to Artificial Super Intelligence". Gao et al. TMLR 2026. [Paper]
• Self-RAG: "Self-RAG: Learning to Retrieve, Generate, and Critique Through Self-Reflection". Asai et al. ICLR 2024. [Paper]
• Constitutional AI: "Constitutional AI: Harmlessness from AI Feedback". Bai et al. arXiv 2022. [Paper]
• AppAgent†: "AppAgent: Multimodal Agents as Smartphone Users". Zhang et al. arXiv 2023. [Paper]
• Scaling the Harness†: "From Model Scaling to System Scaling: Scaling the Harness in Agentic AI". Gu. arXiv 2026. [Paper] [Code]
• HarnessX†: "HarnessX: A Composable, Adaptive, and Evolvable Agent Harness Foundry". Chen et al. arXiv 2026. [Paper]
• DataFlow-Harness†: "DataFlow-Harness: A Grounded Code-Agent Platform for Constructing Editable LLM Data Pipelines". He et al. arXiv 2026. [Paper] [Code]

Related Surveys

• LLM Agents Survey: "A Survey on Large Language Model Based Autonomous Agents". Wang et al. arXiv 2023. [Paper]
• Rise of LLM Agents: "The Rise and Potential of Large Language Model Based Agents: A Survey". Xi et al. arXiv 2023. [Paper]
• LLM Survey: "A Survey of Large Language Models". Zhao et al. arXiv 2023. [Paper]
• AI Agent Systems†: "AI Agent Systems: Architectures, Applications, and Evaluation". Xu. arXiv 2025. [Paper]
• AutoResearch Survey†: "What's Missing in Autonomous Research? A Systematization of Systems, Benchmarks, and Verification". Ren et al. 2026. [Paper]
• LLM Agents: A Survey†: "LLM Agents: A Survey". Lee. Preprints.org 2026. [Paper]
• The Agent Loop†: "The Agent Loop: A Survey of Control Strategies, Skills, and Harnesses for LLM Agents". Lee and Park. SSRN 2026. [Paper]
• Code as Agent Harness†: "Code as Agent Harness". Ning et al. arXiv 2026. [Paper]

Practitioner Reports & Industry Insights

Production deployment experiences from Stripe, OpenAI, Cursor, METR, and other frontier practitioners.

• Building Effective Agents: "Building Effective Agents". Anthropic. Anthropic Engineering Blog, 2026. [Blog]

• Demystifying Evals: "Demystifying Evals for AI Agents". Anthropic. Anthropic Engineering Blog, 2026. [Blog]

• Context Engineering: "Context Engineering Our Way to Long-Horizon Agents". Chase. Sequoia Capital Podcast, 2026. [Podcast]

• Agent Frameworks, Runtimes, and Harnesses: "Agent Frameworks, Runtimes, and Harnesses". LangChain. LangChain Blog, 2025. [Blog]

• We Removed 80% of Our Agent's Tools: "We Removed 80% of Our Agent's Tools". Qu. Vercel Engineering Blog, 2025. [Blog]

• Harness Problem: "I Improved 15 LLMs at Coding in One Afternoon. Only the Harness Changed.". Can. Personal blog (blog.can.ac), February 2026. [Blog]

• AI Adoption Journey: "My AI Adoption Journey". Hashimoto. Personal blog, February 2026. [Blog]

• The Harness Gap: "The Harness Gap: AI Coding Output Rose 59% in 2025 While Teams Shipped 7% Less". Zoom In AI. Medium (Write A Catalyst), March 2026. [Blog]

• Stripe Minions: "Minions: Stripe's one-shot, end-to-end coding agents". Gray. Stripe Dev Blog, Feb 2026. [Blog]

• Harness Engineering (OpenAI): "Harness engineering: leveraging Codex in an agent-first world". Lopopolo. OpenAI Blog, Feb 2026. [Blog]

• Self-Driving Codebases: "Towards self-driving codebases". Lin. Cursor Blog, Feb 2026. [Blog]

• METR SWE-bench Analysis: "Many SWE-bench-Passing PRs Would Not Be Merged into Main". Whitfill et al. METR Notes, Mar 2026. [Report]

• Harness-Aware Training†: "Training Agents to Evolve with Their Harness: TaoLive Digital Avatar Agent Technical Report". TaoLive AIGC LLM Team. arXiv, August 2026. [Paper]

• Agents SDK Evolution: "The Next Evolution of the Agents SDK". OpenAI. April 2026. [Article]

• Copilot Harness Architecture: "Agent Harnesses: The Secret Sauce Behind GitHub Copilot in VS Code". Visual Studio Code Team. May 2026. [Article]

• Antigravity 2.0: "Introducing Google Antigravity 2.0". Google. May 2026. [Article]

• Agent Executor: "Agent Executor: Google's Distributed Agent Runtime". Google Cloud. May 2026. [Article]

• Agent Framework at Build: "Microsoft Agent Framework at Build 2026". Microsoft. June 2026. [Article]

• Custom Agent Harness: "How to Build a Custom Agent Harness". LangChain. June 2026. [Article]

• Token-Efficient Harnesses: "Improving Token Efficiency in GitHub Copilot". Visual Studio Code Team. June 2026. [Article]

• 50,000 Agent Runs: "What 50,000 Runs Taught Us". Visual Studio Code Team. June 2026. [Article]

• Provider-Specific Harness Tuning: "Optimizing the VS Code Coding Harness for Model Providers". Visual Studio Code Team. July 2026. [Article]

• Scaling the Claw or Harness: "Agent Harness: Scaling the Claw or Harness Capabilities". Microsoft. July 2026. [Article]

• TrueForge Engineering: "TrueForge: An Open-Source Agent Harness". TrueFoundry. August 2026. [Article]

• Agent Host Architecture: "Agent Host Architecture". Visual Studio Code Team. August 2026. [Article]

• Agent Factory: "Agent Factory Recap: Agent Harnesses, Shifting Left, and Autonomous Coding". Google Cloud. September 2026. [Article]

• Hermes Agent Runtime: "Hermes Agent Documentation". Nous Research. 2026. [Documentation]

• MiMo-Code Runtime: "MiMo-Code: Open-Source Coding Agent Harness". XiaomiMiMo. 2026. [Repository]

• Mastra Runtime: "Mastra: TypeScript Agent Framework and Runtime". Mastra. 2026. [Repository]

• SandBase Runtime: "SandBase Harness". SandBase. 2026. [Repository]

• WorkBuddy Open Platform: "Buddy App: An AI Harness for a Vertical Industry". Tencent Cloud. 2026. [Documentation]

• Muse Design and Runtime: "How We Designed Muse". Meta. September 2026. [Article] [Architecture]

• Amazon Quick Autonomous Agents: "Amazon Quick Announces Autonomous Agents". AWS. June 2026. [Announcement] [Documentation]

• OpenAI Workspace Agents: "Introducing Workspace Agents in ChatGPT". OpenAI. April 2026. [Article]

• QwenWork Runtime: "QwenWork International Edition: Product Guide". Alibaba Cloud. August 2026. [Documentation]

• OpenAI dots: "Introducing dots". OpenAI. September 2026. [Article]

• Grok Bot: "Introducing Grok Bot". xAI. August 2026. [Article] [Enterprise]

• OpenJarvis†: "OpenJarvis: Personal AI, on Personal Devices". OpenJarvis Team. arXiv 2026. [Paper] [Code]

---

Future Directions

Eight open research directions identified in the survey (no curated paper list — these are forward-looking):

• Formal Harness Specification Language — DSL for specifying and verifying H=(E,T,C,S,L,V) components
• Cross-Harness Benchmark Suite — portability testing across incompatible harness ecosystems
• Security Taxonomy & Threat Model — extension of OWASP Top 10 to agent harness attack surfaces
• Protocol Interoperability (MCP/A2A) — bridging tool-level and agent-level protocols
• Long-Horizon Evaluation Methodology — metrics that don't degrade under multi-session, multi-day tasks
• Harness-Aware Fine-Tuning — training models that are aware of their execution environment
• Memory Interface Standardization — portable memory APIs across flat, episodic, and graph stores
• Harness Transparency Specification — auditability and explainability for runtime decisions

---

---

About the Survey

Evidence and Curation

This is an opinionated research index. An entry belongs when it contributes a distinct harness architecture, a directly relevant benchmark, a reusable component, or evidence that changes how runtimes should be built or evaluated.

• Prefer primary evidence: source code, official documentation, papers, specifications, and clearly labeled first-party reports.
• Say why it belongs: every system and benchmark gets a one-sentence description of its contribution.
• Keep experimental units separate: model, harness, environment, task, budget, and evaluator should be named independently.
• Keep layers separate: full harnesses, capability modules, security layers, task environments, and evaluation runners are cataloged in their own categories.
• Track uncertainty: Unverified records insufficient public evidence; an Absent rating requires explicit first-party evidence.
• Record the cutoff: ratings reflect public evidence available through 2026-10-13 and may change as systems evolve.

---

Paper Versions and Citation

Artifact	Current version	Date / cutoff	Status
Resource index	2026.10	Evidence reviewed through 2026-10-13	This README; last updated 2026-10-14
Repository paper	v4	2026-04-14	Public PDF
Archived preprint	v3	2026-04-09	DOI record
Paper v5	In revision	—	The manuscript, figures, and references are under review

The repository currently publishes Paper v4. The resource index is newer and serves as the survey's living evidence layer; Paper v5 will incorporate reviewed material after the manuscript, figures, and references are complete. The full citation is kept near the top of this README.

Contributing

Missing a system, benchmark, paper, or corrected link? Open an issue or submit a pull request.

A strong contribution includes:

1. The canonical project, paper, or specification link.
2. One sentence explaining why it matters to the harness layer.
3. Primary evidence for architectural claims or quantitative results.
4. The version, commit, benchmark setup, and access date when the claim can drift.
5. The right category: full harness, module, benchmark, task environment, protocol, or evaluation infrastructure.

Corrections and suggestions: gloriamenng@gmail.com · wangyanan@mail.dlut.edu.cn · chenliyi@xiaohongshu.com

Update Log

Track	Version	Date	Changes
Resource index	2026.10	2026-10-14	Restored the paper title, citation, and survey narrative; reduced the header to stars, total references, and license; expanded the open evidence matrix from 20 to 34 systems, including eight workplace and personal-agent routes; added April–October systems, benchmarks, architecture reports, and a categorized full directory; rewrote the Chinese README with standard terminology and natural formal prose
Paper	v4	2026-04-14	Current repository PDF; predates the 2026.10 resource index
Archived preprint	v3	2026-04-09	DOI-linked public preprint

---

† denotes a preprint that was not peer-reviewed at the listed version.
Maintained by Qianyu Meng & Liyi Chen. Curated contributions are welcome.