🤖 AI

HarnessBridge: Learnable Bidirectional Controller for LLM Agent Harness

This paper introduces HarnessBridge, a lightweight, learnable bidirectional controller that automates the agent-environment interface through observation and action projections, achieving performance comparable to or better than specialized manual harnesses while significantly reducing token usage and trajectory length across various LLMs.

Original authors: Xiaoxuan Wang, Haixin Wang, Alexander Taylor, Jason Cong, Yizhou Sun, Wei Wang

Published 2026-06-12

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Xiaoxuan Wang, Haixin Wang, Alexander Taylor, Jason Cong, Yizhou Sun, Wei Wang

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are hiring a brilliant but slightly scattered detective (the AI Agent) to solve a complex mystery that takes days to crack. The detective is incredibly smart, but they have a bad habit: they write down everything they see, hear, and think in a massive notebook. Eventually, the notebook becomes so thick that the detective can't find the important clues anymore, and they get stuck reading the same useless pages over and over.

Meanwhile, the detective keeps trying to open doors that are already locked or knocking on walls that don't exist, wasting time and energy.

This is the problem the paper addresses. The "harness" is the system that sits between the detective and the world, managing the flow of information. Usually, this system is built by humans using rigid rules (like "always keep the last 10 pages"). But the authors of this paper, HarnessBridge, asked: What if we could teach the system itself how to manage the detective's notebook and actions, just like a smart assistant?

Here is how HarnessBridge works, broken down into simple concepts:

1. The Two-Way Bridge

Think of HarnessBridge as a smart bouncer standing at the door between the Detective (the AI) and the Crime Scene (the computer environment). It has two main jobs, working in opposite directions:

Job A: The "Editor" (Observation Projection)

The Problem: The Crime Scene sends the detective a massive stream of data: every file they opened, every error message, every dead end. The detective's memory (the AI's context window) gets clogged with "noise."
The HarnessBridge Solution: The Editor looks at the detective's notebook and performs three actions:
- Keep: It saves the critical clues (like "The suspect was seen at 5 PM" or "The code failed because of a missing file").
- Summarize: It condenses long, boring sections. Instead of pasting 50 lines of code the detective already read, it writes: "You checked the database files and found the error was in line 42."
- Drop: It throws away the trash. If the detective spent 10 minutes looking for a file that didn't exist, the Editor deletes that entire section so the detective doesn't waste time re-reading it.
The Result: The detective gets a clean, short, high-quality briefing instead of a 100-page novel. This saves money (token usage) and helps the detective focus.

Job B: The "Coach" (Action Projection)

The Problem: Sometimes the detective gets stuck in a loop. They might try to open a door they know is locked, or they might try to solve a puzzle by guessing randomly instead of using logic. They keep doing this, wasting steps.
The HarnessBridge Solution: Before the detective's action is sent to the Crime Scene, the Coach checks it.
- Pass: If the action makes sense, the Coach says "Go ahead."
- Reject: If the action is a waste of time (like trying to run a test that hasn't been fixed yet), the Coach blocks it.
- The Feedback: Crucially, the Coach doesn't just say "No." It gives a specific note: "Don't run that test yet. You haven't fixed the bug in the login.py file. Go fix that first."
The Result: The detective stops making useless mistakes and learns from the feedback immediately.

2. How It Learns (The "Training" Phase)

You might wonder, "How does this bouncer know what to do?"
The authors didn't write a list of rules. Instead, they trained HarnessBridge like a student.

They took thousands of examples of successful detective cases (where the AI solved the problem).
They showed the system: "Here is the messy notebook the detective had. Here is the clean version that would have helped them solve it faster. Here is the action they took, and here is the better action they should have taken."
The system learned to mimic these decisions. It learned to be a "learnable policy," meaning it adapts to the situation rather than following a static rulebook.

3. The Results: Smarter and Cheaper

The paper tested this system on real-world coding challenges (like fixing bugs in software).

Performance: HarnessBridge helped the AI solve problems just as well as, or better than, the best human-made systems.
Efficiency: This is the big win. Because the system compressed the information and stopped the AI from making useless moves, it used significantly fewer "tokens" (the currency of AI computing). In some cases, it reduced the cost by over 50% or even 90%.
Generalization: The system was trained on one type of AI detective, but it worked perfectly when paired with different, even larger, AI models. It's like a coach who learned to train a specific athlete but could instantly improve the performance of any other athlete they worked with.

Summary Analogy

If the AI Agent is a race car driver, the traditional harness is a static GPS that gives the same instructions to everyone. HarnessBridge is a smart co-pilot who:

Filters out the radio static so the driver can hear the track clearly.
Summarizes the race history so the driver knows the current strategy without reading the whole manual.
Slaps the driver's hand if they try to take a turn that leads to a wall, and tells them exactly where to steer instead.

The paper claims this approach makes AI agents faster, cheaper to run, and better at solving long, complex tasks without needing humans to manually rewrite the rules every time.

Technical Summary: HarnessBridge

Problem Statement

Large Language Models (LLMs) are increasingly deployed as agents for complex, long-horizon tasks (e.g., autonomous software engineering, web navigation). While progress has focused on stronger generator models and richer environments, a critical third axis—the harness mediating agent-environment interaction—remains a bottleneck.

Existing harnesses are largely manually engineered scaffolds that format observations, manage context, and validate actions. As interaction horizons grow, these static systems face two primary limitations:

Environment-to-Agent (Observation): Trajectories accumulate redundant context, stale errors, and low-value details, obscuring decision-critical states and inflating token costs.
Agent-to-Environment (Action): Models may repeat ineffective actions, pursue invalidated hypotheses, or issue malformed commands, consuming scarce environment steps without advancing the task.

Current automated approaches (e.g., Meta-Harness) typically optimize external scaffolds or prompts but do not learn the runtime interaction policy that dynamically determines what information flows to the generator and what actions are committed to the environment. The authors ask: Can the harness be formulated as an end-to-end learnable generation problem?

Methodology: HarnessBridge

The authors propose HarnessBridge, a lightweight, learnable harness controller that parameterizes the agent-environment interface as a bidirectional projection policy ( $\pi_h$ ). The generator policy ( $\pi_g$ ) remains frozen; optimization occurs solely over the harness.

1. Bidirectional Projections

HarnessBridge learns two distinct mappings:

Observation Projection ( $P_{obs}$ ): Maps the raw interaction history ( $H_t$ ) to a generator-visible state ( $\tilde{H}_t$ ).
- Mechanism: It processes each history unit $h_i$ $h_{i}$ and assigns a decision $z_i \in \{Pass, Compress, Drop\}$ $z_{i} \in {P a ss, C o m p r ess, D r o p}$ .
  - Pass: Keep the unit unchanged.
  - Compress: Condense the unit while preserving meaning (e.g., summarizing verbose logs).
  - Drop: Remove irrelevant, stale, or superseded content.
- Active-State Index: A learned component ( $U_t$ ) placed before the history that explicitly tracks unresolved errors, open constraints, established facts, and pending goals, ensuring critical state is visible without reconstructing it from a long trajectory.
Action Projection ( $P_{act}$ ): Maps a proposed generator action ( $a_t$ ) to an environment-facing action ( $a'_t$ ).
- Mechanism: It predicts a decision $d_t \in \{Pass, Reject\}$ $d_{t} \in {P a ss, R e j ec t}$ .
  - Pass: Execute the action ( $a'_t = a_t$ ).
  - Reject: Block the action ( $a'_t = \emptyset$ ) and return trajectory-grounded feedback ( $\rho_t$ ) to the generator.
- Feedback Structure: Rejections must include a concern (why the action is unproductive), evidence (specific quotes from the history supporting the rejection), and a suggestion (how to improve). This prevents unproductive loops while preserving informative exploration.

2. Unified Instruction Tuning

Instead of training separate modules, HarnessBridge unifies both projections into a single conditional generation problem using a shared policy ( $P_\theta$ ).

Training Data: Constructed from solved trajectories (e.g., SWE-bench Verified).
Supervision: The model is trained via instruction tuning to generate the appropriate projection (compressed state or pass/reject decision with feedback) based on the task specification and current trajectory.
Data Curation: High-quality supervision is filtered using an LLM judge to ensure:
- Observation projections preserve decision-critical evidence and schema consistency.
- Action projections are trajectory-grounded (rejections must cite specific history) and lead to efficiency gains.
Model: A lightweight LLM (Qwen3.5-0.8B) is fine-tuned to serve as the controller, while the generator (e.g., Qwen3.5-35B, GPT-5.4) remains frozen.

Key Contributions

End-to-End Learnable Harness: Introduces the first framework replacing manually engineered interaction logic with a learnable harness policy that mediates the agent-environment interface.
Unified Instruction Tuning: Demonstrates the first application of unified instruction tuning to learn bidirectional mappings (observation compression and action validation) between agents and environments.
HarnessBridge System: Presents a working system that achieves competitive task performance with significantly reduced token usage and trajectory length.

Experimental Results

The authors evaluated HarnessBridge on Terminal-Bench 2.0 and SWE-bench Verified across various open-source and commercial models.

Performance vs. Efficiency: HarnessBridge matches or surpasses strong specialized harnesses (e.g., Terminus 2, OpenHands, Meta-Harness) while substantially reducing token usage.
- On Terminal-Bench 2.0 (Qwen3.5-35B), it achieved a 33.7% success rate (vs. 30.3% for Terminus 2) with a 46.8% reduction in token usage.
- On SWE-bench Verified, it maintained a 60.2% success rate (vs. 61.6% for Terminus 2) with a 23.1% token reduction.
Generalization: Models trained on trajectories from a smaller generator (Qwen3.5-35B) generalized effectively to larger commercial models (e.g., GPT-5.4, Claude-Opus-4.7), often improving success rates and reducing token costs by up to 90% on specific models.
Ablation Studies: Removing either the observation or action projection module resulted in decreased success rates, confirming that both components are necessary for optimal interaction.
Case Studies: Analysis showed that HarnessBridge effectively compresses redundant reasoning and navigation turns while preserving critical test outputs and error messages. It successfully interrupted "redundant verification loops" where agents repeatedly checked code without testing, redirecting them to actionable steps.

Significance and Claims

The paper claims that HarnessBridge recasts the agent-environment interface as a learnable policy rather than static infrastructure. Its significance lies in:

Scalability: By learning to suppress stale context and reject unproductive actions, the system remains efficient as task horizons extend, addressing a central limitation of current long-horizon agents.
Efficiency: It achieves substantial reductions in token consumption and trajectory length without sacrificing (and often improving) task success rates.
Transferability: The learned control patterns generalize across different generator models and environments, suggesting that the harness captures fundamental properties of effective agent-environment interaction rather than overfitting to a specific model's trajectory artifacts.

The authors note that their evaluation is currently confined to coding settings, but the mechanism operates over generic tool-use trajectories, implying potential applicability to web navigation and multi-step research workflows.