Harness^2: Recursive Agent Harnessing for an Open World

Reading guide

Problem and motivation

An LLM agent's performance depends heavily on its execution harness—the runtime scaffolding of prompts, tools, memory, subagents, and plugins surrounding a frozen base model. In dynamic open-world settings, agents continually encounter unseen, complex workflows. Existing recursive self-improvement (RSI) techniques for harnesses struggle due to two primary challenges:

1. Absence of ground-truth verifiers: Online deployment tasks do not provide ground-truth answers or reliable test-time scoring functions to evaluate whether an online harness edit helped or harmed performance.
2. Lack of cross-task transfer: Direct harness modifications are typically task-specific; blindly carrying an execution harness forward across shifting task distributions causes instability and performance regressions.

Key ideas

Harness^2 couples two distinct levels of recursion:

• Task-Level Recursion: Refines the execution harness for the active task without ground-truth verifiers via a contrastive Propose–Probe–Compose cycle. It formulates invariant proposals (agent operational workflows) and domain-specific proposals (practitioner domain rules), probes both under matched conditions, and composes verified behavioral improvements.
• Harnessing-Level Recursion: Extracts reusable procedural lessons and adopted components from the test-time refinement process into a persistent harness improvement library, improving the improver's meta-capability on subsequent tasks.
• Pluggable Scaling: Supports scaling exploration width via parallel recursion ($k$ candidate pools composed concurrently) or depth via sequential recursion ($k$ chained iterations).

Method

An agent is decomposed into a frozen model $\mathcal{M}$ and an editable harness $\mathcal{H}=(c^1,\dots ,c^K)$ across $K=8$ file-level components (system prompt, guardrails, memory, skills, tool guidance, scripts, subagents, middleware plugin).

Task-Level Recursion

For a task $q_t$, execution history $\mathcal{E}$, and fixed improvement harness ${\mathcal{R}}_t$, a contrastive step $\Phi$ produces an updated harness ${\mathcal{H}}^{\prime }$, execution record $e^{\prime }$, and step record $\xi$: $$({\mathcal{H}}^{\prime },e^{\prime },\xi )=\Phi (q_t,\mathcal{H},\mathcal{E};{\mathcal{R}}_t)$$

1. Propose: Samples a reference execution $e^0\sim \mathcal{A}(q_t;\mathcal{M},\mathcal{H})$. Conditioned on $e^0$ and ${\mathcal{R}}_t$, it generates an invariant candidate (procedural/tool flow) and a domain-specific candidate (practitioner constraints).
2. Probe: Executes candidates on $q_t$ to observe behavioral contrasts against the reference execution.
3. Compose: Selectively merges verified, non-conflicting edits from the candidate pool.

In Parallel Recursion, $k$ invariant and domain candidates are sampled, and $k$ independent composition sessions yield successors: $${\mathcal{H}}_j^{\prime }=\text{textsc}{Compose}_j(q_t,\mathcal{H},\mathcal{B},\mathcal{P};{\mathcal{R}}_t),j=1,\dots ,k$$ In Sequential Recursion, $k$ refinement steps are chained sequentially: $$({\mathcal{H}}^{(r)},e^{(r)},{\xi }^{(r)})=\Phi (q_t,{\mathcal{H}}^{(r-1)},{\mathcal{E}}^{(r-1)};{\mathcal{R}}_t),r=1,\dots ,k$$

Harnessing-Level Recursion

After task completion and artifact selection, the improvement process reviews the full improvement record ${\mathcal{D}}_t$ to update the improvement harness library: $${\mathcal{R}}_{t+1}=\text{textsc}Update({\mathcal{R}}_t,{\mathcal{H}}_t^{\star },{\mathcal{D}}_t)$$ Lessons are explicitly conditioned on concrete trajectory contrasts, avoiding spurious attributions.

Results

Evaluated across WorkBuddy-Bench (WB), JobBench, and Legal Agent Benchmark (LAB) using Gemini 3.5 Flash and GLM-5 under OpenCode and Codex:

• Single Step ($k=1$) Gains: Yields improvements up to $+11.5$ points on WB Avg. (GLM-5 on OpenCode: $64.2\to 75.7$), $+4.5$ points on JobBench (Gemini on OpenCode: $31.5\to 36.0$), and $+11.8$ percentage points in LAB Partial pass rate (GLM-5 on OpenCode: $59.6\%\to 71.4\%$).
• Budget Scaling: Adding parallel recursion at $k=5$ yields additional gains of $+2.9$ to $+3.9$ points on WB, $+3.0$ to $+4.2$ points on JobBench, and $+2.6$ to $+6.7$ percentage points on LAB.
• Same-Model improver: Demonstrates that gains do not rely on an external superior model; when the same model acts as both executor and harness editor (tested across GLM-5 up to Claude Opus 5), consistent performance improvements occur across all benchmarks.
• Component Ablations: Removing the library, scoping roles, and composition lowers WB performance by $3.1$, $2.9$, and $1.6$ points, respectively.

Limitations and open questions

• Inference Compute Overhead: Proposing, probing, and composing multiple harnesses incurs substantial additional token and rollout costs.
• Stochasticity and Attribution Bias: Without ground-truth verifiers, reliance on behavioral contrasts can still occasionally lead to noisy credit attribution or conservative/restrictive edits when execution variance is high.
• Library Growth and Pruning: The library retains components sequentially; mechanisms to prune outdated lessons or actively consolidate conflicting skills over very long task horizons remain an open area for research.