Lets Talk 
TL;DR
- Google’s Harness2 is an open-source framework that explores improving AI agents without retraining their underlying models.
- It tests changes to prompts, tools, memory, and execution procedures to find better ways of completing tasks.
- The framework works at two levels, improving individual tasks and retaining useful lessons for future assignments.
- Google’s experiments reported improvements of up to 11.5 points on WorkBuddy-Bench, although real-world results may differ.
- Harness2 could influence how developers build and maintain AI agents in 2027, particularly for complex business workflows.
Introduction
Imagine spending days improving an AI agent, only to discover that it still makes the same mistake whenever it encounters an unfamiliar task.
The model understands the instructions. It has access to the necessary tools. Yet somewhere along the way, it chooses the wrong action or follows an inefficient process.
Replacing the model might help, but what if the real problem isn’t the model?
Google Research’s Harness², commonly written as Harness2, explores that question. Released in October 2026, the framework looks at ways to improve how agents work by changing their instructions, tools, memory, and other supporting components.
It’s an interesting development for teams building AI agents for business operations.
As 2027 approaches, the research raises a bigger question: could improving an agent’s working environment become a regular part of AI agent development?
What Is Google’s Harness2 Recursive Agent Framework?
Google Harness2 is an open-source research framework designed to improve how AI agents complete tasks without retraining their language models.
To understand what it does, we first need to understand an agent harness.
Picture an AI agent answering customer questions. It may be powered by an advanced language model, but the model alone doesn’t know which CRM to search, how to retrieve an order, or when to create a support ticket.
The instructions and supporting components that make those actions possible are collectively called the agent harness.
These components can include system prompts, memory, tool guidance, guardrails, subagents, reusable skills, scripts, and plugins.
Each plays a different role. Memory keeps useful context available. Tool guidance explains how external applications should be used. Guardrails restrict certain actions, while skills provide instructions for tasks the agent performs repeatedly.
A problem with any one of these components can affect the agent’s performance.
Harness2 investigates whether changing them and comparing execution results can lead to a better configuration.
Why Did Google Develop Harness2?
An AI agent may perform well on the tasks used during development but struggle when something unfamiliar appears.
Take a coding assistant. It might work perfectly in a small project, then waste time searching irrelevant directories when introduced to a larger repository.
The difficulty isn’t necessarily a lack of programming knowledge. Its instructions for navigating the repository might be unsuitable.
Developers could rewrite those instructions manually. Harness2 explores a different approach: letting an optimization process test alternative configurations and compare what happens.
The framework can also retain lessons from earlier attempts, making those experiences available during later refinements.
How Does Google’s Harness2 Framework Work?
Harness2 uses two forms of recursion. One deals with the task an agent is currently performing. The other helps future tasks benefit from previous improvements.
Task-Level Recursion
Suppose a coding agent is asked to locate a bug in an unfamiliar project.
During its first attempt, it opens several unrelated files before finding the relevant module.
Harness2 can explore different approaches to the same assignment.
One configuration might tell the agent to inspect the project structure first. Another might introduce more specific search instructions.
The framework executes the alternatives and examines differences between them.
It can use that evidence to identify a more promising harness configuration.
This process doesn’t prove that the agent has found the correct bug. It helps improve the execution approach, while tests or independent checks are still needed to verify the outcome.
Harnessing-Level Recursion
The second level deals with what happens after the current task.
Suppose a refined configuration helps the coding agent navigate an unfamiliar repository more effectively.
Harness2 can preserve the adopted harness and the lessons supported by that execution.
Later, when another task requires repository exploration, those lessons can inform a new round of refinement.
The distinction is worth emphasizing: the underlying model hasn’t learned new information through training. The system surrounding it retains information that may help with future work.
The Propose–Probe–Compose Process
Google describes the task-level optimization process using three steps.
Propose: Generate possible changes to the harness. These might involve instructions, tools, memory, or reusable skills.
Probe: Execute the candidate configurations on the task and collect evidence about their behavior.
Compose: Compare the executions and use the findings to construct a refined harness.
Harness2 can explore alternatives in parallel or refine a configuration through successive attempts.
It’s a more structured way to investigate agent behavior than repeatedly rewriting prompts without recording what actually changed.
How Is Harness2 Different From Traditional AI Agent Frameworks?
Developers already use frameworks such as LangGraph and CrewAI to build AI agents. So does Harness2 solve the same problem?
Not quite.
LangGraph and CrewAI help developers organize workflows, coordinate agents, and connect tools.
Harness2 focuses on how the setup surrounding an agent can be improved.
For example, a team might build a document-processing agent using an orchestration framework. The workflow retrieves a document, extracts information, and sends the result to another system.
Everything is connected correctly, but the agent occasionally chooses an unsuitable extraction procedure.
Harness2-style optimization could help compare different instructions or tools for that task.
| Area | Traditional agent development | Harness2 approach |
| Configuration | Developers define the setup | Alternative configurations can be tested |
| Improvements | Often involve manual changes | Uses execution comparisons |
| Model training | Depends on the project | Model weights remain unchanged |
| Previous lessons | Depend on the system’s design | Can inform later refinement |
| Oversight | Developer responsibility | Still requires developer oversight |
Harness2 isn’t a direct replacement for orchestration frameworks.
Instead, it explores an additional part of the development process: finding better ways for an already configured agent to perform its work.
This is particularly relevant to custom AI agent development, where a successful application depends on tool integration, workflow design, and reliable execution, not just the model powering it.
How Google’s Harness2 Could Change AI Agent Development in 2027
Harness2 hasn’t established that AI agents will independently solve every execution problem. Still, the research introduces ideas that could influence how development teams work over the coming years.
1. Developers Could Spend Less Time Adjusting Prompts Manually
Prompt adjustments often become an ongoing part of agent development.
A team changes one instruction, tests the agent, discovers another issue, and makes another change.
Sometimes the new version performs better. Sometimes it creates a different problem.
Harness2 offers a way to test alternative harness configurations through a structured process.
Developers would still decide which changes are acceptable, but they might not need to investigate every small variation manually.
2. Agent Improvements Could Be Based on Execution Evidence
A prompt that produces one impressive answer isn’t necessarily a reliable improvement.
What happens when the next customer asks a slightly different question? Or when a coding agent encounters a repository organized in another way?
Harness2 encourages comparing actual executions rather than relying only on how convincing a response appears.
For development teams, that could make optimization decisions easier to explain and evaluate.
The important question becomes whether the change improves performance across relevant tasks, not whether a single demonstration looks better.
3. Complex Business Agents Could Become Easier to Refine
Consider an agent responsible for processing supplier invoices.
It reads the document, checks the purchase-order number, validates amounts, and prepares the information for an accounting system.
Now suppose the agent repeatedly misses a line item on invoices from a particular supplier.
The problem might be the extraction instructions, a missing validation step, or how the document is processed.
A harness optimization approach could help compare these alternatives.
Of course, an agent shouldn’t update financial records simply because its new configuration seems better. The extracted information would still need verification.
4. Businesses May Need Less Fine-Tuning for Certain Problems
When an AI application performs poorly, teams sometimes consider switching models or fine-tuning the one they already use.
But imagine a reporting agent that regularly calls the wrong database function.
Would retraining the model solve the underlying issue? Possibly, but the tool instructions deserve attention first.
Harness2 highlights the value of examining the entire system before deciding how to improve it.
Fine-tuning remains useful for specialized requirements. It’s simply not the answer to every agent failure.
5. Maintaining Enterprise Agents Could Become More Systematic
A business might eventually run separate agents for sales, customer service, reporting, and internal operations.
Each agent will have its own instructions, integrations, and restrictions.
When something changes, developers need to understand which configuration is being used and whether the new version introduces problems elsewhere.
Harness optimization could encourage more disciplined configuration tracking.
Teams could keep records of tested changes, evaluation results, and accepted improvements.
Those practices would make maintenance easier to manage, although businesses would still need to establish their own approval and rollback processes.
6. Agent Optimization Could Continue After Deployment
A deployed AI agent doesn’t operate in an environment that stays the same forever.
An API changes. A company introduces another approval step. A connected application begins returning information in a different format.
The original agent configuration may no longer work as intended.
By 2027, teams may increasingly treat agent optimization as part of ongoing software maintenance.
They could regularly evaluate execution behavior, test proposed adjustments, and deploy approved changes.
Harness2 provides a research example of this approach, but whether it becomes a widely used production framework remains to be seen.
What Do Google’s Harness2 Benchmark Results Show?
Google Research evaluated Harness2 across three professional benchmarks using four model-harness configurations involving GLM-5 and Gemini 3.5 Flash.
The reported improvements are worth examining because the underlying models weren’t retrained during harness optimization.
| Benchmark | Evaluated tasks | Maximum reported improvement |
| WorkBuddy-Bench | Office, web, and coding assignments | +11.5 points |
| JobBench | Professional workplace tasks | +4.5 points |
| LAB | Legal assignments | +11.8 percentage points in partial pass rate |
In one WorkBuddy-Bench evaluation, a GLM-5 configuration improved from 64.2 to 75.7 after refinement.
That suggests changing an agent’s operating setup can have a measurable effect on performance.
There are limits to what we can conclude, though.
These figures come from particular research configurations. They don’t mean every business agent will experience the same improvement.
The LAB result also measures partial pass rate rather than successful completion of every task.
Companies interested in adopting similar techniques would need to evaluate them against their own workflows, costs, and reliability requirements.
The full methodology is available in Google’s Harness² research paper.
Where Could Harness2-Style AI Agents Be Useful?
The research is particularly interesting for tasks where an agent needs to work with unfamiliar information or multiple tools.
These examples describe potential applications, not confirmed enterprise deployments of Harness2.
Customer Support Automation
A support agent might need to check an order, retrieve shipping information, and create a ticket.
If it repeatedly searches the wrong system, changing the tool instructions could improve its execution.
Harness optimization might help developers compare alternative retrieval procedures before choosing one.
Software Development
Coding agents frequently move between projects with different dependencies and repository structures.
Instructions that work in one project may not suit another.
Testing alternative navigation or debugging procedures could help an agent handle these differences more effectively.
Document Processing
Contracts, invoices, and compliance documents rarely follow one consistent format.
An extraction agent might need different procedures depending on the document it receives.
Harness-level experimentation could help developers determine which instructions or validation steps work better across different formats.
Financial Reporting
Reporting agents often retrieve information from multiple systems before performing calculations.
If a tool is poorly configured, an otherwise capable model may still produce an inaccurate report.
Improving tool guidance and validation procedures could help reduce avoidable execution problems.
Business Workflow Automation
An employee onboarding agent may create accounts, prepare documents, and send notifications.
When the process changes, developers need to update its instructions and integrations.
Harness optimization could offer a way to compare alternative procedures before changing the live workflow.
Businesses exploring such applications can work with generative AI development services to connect AI capabilities with existing applications and operational requirements.
What Are the Challenges and Limitations of Google’s Harness2?
There’s a considerable difference between improving a research benchmark and running an agent inside a business.
Harness2 introduces several practical questions that developers need to address.
How Much Does Recursive Optimization Cost?
Trying multiple configurations means executing tasks multiple times.
Those experiments consume model tokens, computing resources, and potentially paid API calls.
If the improvement is small, the additional expense may not be worthwhile.
Teams need to measure both performance and cost rather than assuming that more experimentation is always beneficial.
Can an Apparently Better Configuration Still Fail?
Yes.
An agent may perform a task more efficiently while producing the wrong answer.
Similarly, instructions that work for one document type could cause problems with another.
This is why independent evaluation matters. Developers need representative test cases, not just successful examples from the optimization process.
What About Security?
An agent with permission to execute scripts or access business systems can cause serious problems if its permissions aren’t controlled.
Google’s Harness2 GitHub repository notes that executor network access is unrestricted and that its Codex execution configuration disables sandboxing.
These research settings should not be copied into sensitive production systems.
Businesses would need isolated environments, access restrictions, and approval processes before experimenting with real data.
Is Harness2 Production-Ready?
Harness2 is an open-source research release, not a complete enterprise deployment solution.
Businesses still need authentication, logging, monitoring, error handling, and secure infrastructure.
They also need a way to review proposed harness changes and reverse them if something goes wrong.
A recursive optimization process doesn’t remove those responsibilities.
How Can Businesses Prepare for Recursive AI Agent Development in 2027?
Organizations don’t need to deploy Harness2 immediately to benefit from the thinking behind it.
A sensible starting point is to make existing agents easier to evaluate and maintain.
Choose a Specific Use Case
Start with a workflow where success can be measured.
Document classification, internal knowledge retrieval, and customer request routing are examples worth evaluating.
Define the expected result before introducing an optimization process.
Keep Agent Components Modular
Prompts, tools, memory, and permissions shouldn’t be unnecessarily tangled together.
When components are clearly separated, developers can investigate failures without rebuilding the entire application.
It also becomes easier to test changes to individual parts of the harness.
Record What Happens During Execution
A successful response doesn’t tell the whole story.
Teams should also track tool failures, processing times, operating costs, and situations requiring human intervention.
Execution records provide useful evidence when evaluating a proposed change.
Test Before Releasing Changes
New configurations should be evaluated in isolated environments before entering production.
Compare them against existing performance, check for security issues, and preserve a way to restore an earlier version.
Know When Optimization Is Worthwhile
Not every agent needs recursive improvement.
A straightforward workflow may perform reliably with carefully designed instructions and conventional testing.
More complex agents that encounter frequently changing tasks may be better candidates for advanced optimization.
An experienced AI agent development company can help businesses assess these requirements and select a suitable architecture before investing in experimental techniques.
The Future of AI Agent Development Beyond Harness2
A common assumption is that making AI agents better requires increasingly capable language models.
That will remain important, but Harness2 draws attention to another part of the problem.
An agent also needs suitable instructions, dependable tools, useful context, and a sensible execution process.
Even a highly capable model can struggle when these components are poorly configured.
In the coming years, development teams may devote more attention to measuring and improving the entire agent system.
That could mean maintaining reusable skills, testing different execution procedures, and introducing controlled configuration changes after deployment.
It won’t eliminate the need for human judgment. Developers still need to decide which changes are safe, which results are acceptable, and whether optimization expenses are justified.
The long-term significance of Harness2 may be that it encourages teams to treat the agent harness as an important engineering component rather than a fixed collection of instructions.
Final Thoughts
Google’s Harness2 offers a different way to think about improving AI agents.
Instead of automatically turning to a larger model or fine-tuning, developers can examine the instructions, tools, memory, and procedures surrounding the existing model.
Its recursive approach shows how alternative configurations can be tested and useful lessons carried into future assignments.
The research results are encouraging, but broader production adoption will depend on reliability, security, and cost.
For businesses planning AI initiatives in 2027, building agents that are easy to test, maintain, and improve is a practical place to begin.
Explore Creole Studios’ AI Agent Development Services to discuss custom agent development, enterprise integrations, deployment, and ongoing support.
Frequently Asked Questions
What is Google’s Harness2 framework?
Google’s Harness2 is an open-source research framework that experiments with improving AI agents without retraining their models. It focuses on the supporting system, including prompts, tools, memory, and execution procedures.
How does Harness2 improve AI agents without retraining models?
Harness2 tests alternative configurations using its Propose–Probe–Compose process. It compares execution behavior and uses the evidence to refine the harness while keeping model weights unchanged.
Is Google Harness2 open source?
Yes. Google Research released Harness2 on GitHub under the Apache 2.0 license. Developers can explore its code and research experiments, although it isn’t an officially supported Google product.
What is recursive agent harnessing?
Recursive agent harnessing involves repeatedly testing and refining the system surrounding an AI model. Harness2 also retains useful lessons from previous assignments to help guide later improvements.
Can businesses use Harness2 for enterprise AI agent development?
Businesses can experiment with the framework, but its research implementation should not be considered production-ready without additional engineering. Secure execution, evaluation, monitoring, and approval controls are important.
Will Harness2 replace traditional AI agent frameworks?
Unlikely. Frameworks such as LangGraph and CrewAI help developers organize agent workflows. Harness2 explores how harness configurations can be improved. The approaches solve different problems and could complement each other.
