Harness²: Enabling AI Agents to Self-Evolve, Achieving an 11.5-Point Gain Without Real Annotations

In AI agent research, a core contradiction is becoming increasingly prominent: we want agents to complete tasks autonomously in open worlds, yet we must rely on human-designed prompts, tool sets, and memory mechanisms—and these "harnesses" are often fixed and struggle to adapt to new tasks. Google Research's newly open-sourced Harness² framework attempts to break this deadlock with a "recursive" approach: not only does it let agents complete tasks, but it also lets them automatically evolve their own harness during the task.

What Is Harness²?

Harness² is a plug-and-play recursive agent harnessing framework. Its core proposition is: first harness the agent, then harness its self-improvement capability. Unlike traditional agent development paradigms, Harness² does not require developers to predefine a perfect set of prompts, tools, and memory strategies; instead, it lets the agent automatically optimize these components during task execution.

The framework was released as open source on Product Hunt, positioned as an innovative product at the intersection of developer tools and artificial intelligence, and received 108 upvotes, ranking third on the daily leaderboard. Its Makers include researchers such as Han Yu, and the code is publicly available on GitHub.

Agent harness refers to the entire set of external supporting components built around a large language model (LLM), typically including the system prompt, callable tool set (function/tool calling), context and memory management, output parsing and retry logic, and more. The model itself is only responsible for generating tokens, while the harness determines what it can perceive, what it can do, and how multiple steps of action are chained together. In early forms such as AutoGPT and ReAct, the harness was entirely hand-written by developers, and whenever the task changed, the prompts and tool descriptions often had to be retuned. The name Harness² comes precisely from this: adding another layer of harness to the harness, that is, using an outer mechanism to automatically optimize the inner harness and turn what was originally static engineering configuration into a learnable object.

Dual Recursion: Co-evolution at the Task and Framework Levels

The most central design of Harness² is the "dual recursion" mechanism. It runs optimization loops at two levels simultaneously:

Task-Level Recursion: Propose-Probe-Compose

Within a single task, the agent refines its execution strategy through a "Propose-Probe-Compose" loop. Specifically, the agent first proposes an initial action plan, then probes environmental feedback through actual execution, and finally composes effective steps into a better solution. This process does not require a ground-truth verifier; instead, it relies on the observable results of the task itself for self-evaluation.

Ground-truth verifier refers to an external evaluator used in agent optimization or reinforcement learning that can judge whether a "standard answer" is correct, in order to compute rewards or filter trajectories. It can be a human-annotated answer, a unit test, a rule checker, or a strong-model judge. The limitation of such verifiers is that open-world tasks (such as web navigation or document organization) usually do not have a unique correct answer; building comprehensive verifiers is extremely costly, and it is easy to train agents to "game the test" rather than generalize. The idea of annotation-free self-improvement is to bypass the verifier and instead use the environment's own observable feedback (whether execution succeeds, whether the structure is self-consistent, whether subsequent steps flow smoothly) to provide weak supervision signals, thereby reducing dependence on expensive human annotation and strong external judges.

Framework-Level Recursion: Accumulation and Reuse of Experience

Across tasks, Harness² accumulates reusable experience. After each task execution, the agent not only saves the task result but also records which prompt structures, tool-calling patterns, and memory organization methods were more effective. This experience is abstracted into transferable "framework knowledge" and injected as prior knowledge in subsequent tasks, enabling the agent's harness to evolve gradually.

This dual-recursion design allows the agent both to solve the problem at hand and to become smarter the more it is used. Google Research reported a performance improvement of up to +11.5 points on the professional benchmark WorkBuddy^Ad-Bench, validating the effectiveness of the framework.

Experience distillation and context injection are the implementation foundation of framework-level recursion. So-called "framework knowledge" is usually reusable fragments stored in natural language, such as "for this type of task, retrieval followed by summarization is more effective" or "before calling a certain tool, confirm the parameter format first." Unlike model weight updates (fine-tuning), this kind of experience does not change model parameters; instead, it is dynamically concatenated into the prompts or context of subsequent tasks, which is why it is also called "context-learning-style" continual learning. Its advantages are that it requires no retraining, is interpretable, and can be manually reviewed; the cost is that it is limited by context window length, and when the experience library grows too large, retrieval, compression, and filtering mechanisms are needed, otherwise noise or even mutually conflicting guidance may be introduced.

How Is Self-Improvement Without Real Annotations Achieved?

Traditional agent optimization methods often rely on human-annotated correct answers or reward signals, which is almost infeasible in open-world tasks. Harness²'s breakthrough is that it uses the natural feedback of the task environment as an implicit supervision signal.

For example, in code generation or document processing tasks, the agent can judge the quality of a solution through execution results (whether the code runs, whether the document structure is reasonable) without needing a human-annotated "standard answer." The Propose-Probe-Compose loop is essentially a search strategy based on environmental feedback, while framework-level recursion distills this search experience into reusable patterns.

This brings an important insight: an agent's self-improvement does not necessarily require a powerful external verifier; the environment itself can be the teacher. Of course, the effectiveness of this approach depends on the quality and richness of environmental feedback, and it may face challenges in scenarios where feedback is sparse or noisy.

What Does This Mean for Developers?

Harness² markets itself as "plug-and-play," meaning developers do not need to build a complex agent optimization system from scratch; instead, they can connect existing agents to the framework and let them evolve automatically. This is especially valuable for the following scenarios:

• Open-world tasks: tasks such as web navigation, file management, and multi-step information retrieval that lack clear reward signals.
• Rapid prototyping: developers do not need to manually tune prompts and toolchains; the framework automatically explores effective configurations.
• Continual learning systems: agents continuously accumulate experience during long-term operation and adapt to changing environments.

The framework is open source on GitHub, and developers can freely inspect implementation details and integrate it into their own projects. Although there are not many comments on Product Hunt, followers generally express interest in its self-improvement capability "without real annotations."

Limitations and Outlook

Harness² is currently validated mainly on professional benchmarks such as WorkBuddy-Bench, and its performance on broader, noisier real-world tasks remains to be seen. The computational overhead brought by dual recursion is also a practical issue—each task requires multiple rounds of probing and composition, and the framework level also needs to maintain an experience library, which places higher demands on inference cost.

In addition, there are boundaries to the transferability of experience. Whether framework knowledge accumulated in one task domain can be effectively transferred to a completely different domain depends on the granularity of experience abstraction. Google Research's paper (if available) may further discuss these limitations.

Overall, Harness² proposes a compelling direction: making the agent's harness itself a learnable, evolvable object. This is not only a technical innovation but also changes the way we design agent systems—from "careful design" to "designing a system that can design itself." For developers following the frontier of AI agents, this is an open-source project worth studying in depth.

One-line Summary

Google Research open-sources Harness², enabling agents to recursively evolve their own harness during tasks and gain 11.5 points without real annotations.

Paragraph Summary

Harness² is a plug-and-play recursive agent harnessing framework open-sourced by Google Research. Its core proposition is to let agents automatically optimize their "harness" (prompts, tool sets, memory mechanisms) while completing tasks, rather than relying on developers to pre-design them manually. It adopts dual recursion: at the task level, a Propose-Probe-Compose loop proposes solutions, probes them using environmental feedback, and composes them into better solutions; at the framework level, it accumulates reusable experience across tasks and injects it as priors into subsequent tasks. The framework does not rely on a ground-truth verifier but uses natural environmental feedback as implicit supervision, reporting up to a +11.5-point improvement on WorkBuddy-Bench. Its value lies in lowering the barrier to agent development and making it suitable for open-world tasks, rapid prototyping, and continual learning scenarios, but computational overhead and the boundaries of cross-domain experience transfer remain major limitations.