×
Community Blog Better Harness Is Here: Make Your Agent Better with Every Task

Better Harness Is Here: Make Your Agent Better with Every Task

This article introduces Qoder's Better Harness, a tool that diagnoses and optimizes AI agent workflows by turning task lessons into reusable assets.

Learn More about Qoder

Explore Qoder – Agentic Coding For Enterprise


Summary: Qoder introduces Better Harness (Beta): assess your agent’s working environment across five dimensions, fix issues with one click, and turn the lessons from every task into reusable assets—so your agent keeps getting better.


You have always been the one checking the agent’s code at the end. This time, turn things around: give the agent’s working environment a health check.

Today’s coding agents can read requirements, change code, run tests, and submit pull requests. But being able to do many things is not the same as doing them well.

An agent typically cycles through “understand the task—take action—inspect the results—adjust and continue.” This is the agent loop. A reliable loop does more than keep the agent busy: it makes the goal clear, defines what must not be changed, establishes how to verify the result, and sets out what to do when something fails. Otherwise, an agent may change a great deal of code and run many tests without being able to demonstrate that the task is actually complete.

Over the past two years, the industry has coined a succession of terms to tackle this problem: prompt engineering, context engineering, harness engineering, loop engineering, and, more recently, graph engineering. The pace is accelerating—the latest two arrived just a month apart. On social media outside China, engineers joke, “Are we still talking about loops, or have we moved on to graphs?” The Chinese developer community has an even simpler take: “If you wait long enough to learn it, you won’t have to.”

Our advice: you do not need to chase every new term. The terminology keeps changing, but the underlying challenge has not: make the agent’s goals, boundaries, and verification methods clear, then retain the lessons from each task. The practical response has not changed either: whenever an agent makes a mistake, put a mechanism in place to prevent it next time.

The new Better Harness (Beta) in Qoder Desktop starts by diagnosing gaps, then helps you fix them and retain what you learn. Its checks draw on the Qoder team’s internal practice and approaches repeatedly validated by the community. The aim is to equip the agent with project context, the right development tools, effective verification methods, and clearly defined safety boundaries—bringing every loop closer to reliable delivery.

image_1_

In the latest Qoder Desktop, open Better Harness to start an analysis and fix issues through the visual interface, or run the/better-harnessSkill directly. It examines how the agent carries out tasks, identifies missing or weak elements, and helps you determine what to add or improve next.

Better Harness: Diagnose, Improve, and Recheck the Work Loop

Better Harness does not assess the quality of a single answer. It examines the entire harness that supports a coding agent’s work: whether goals and context are clear, the project is easy to run, permissions are controlled, verification is effective, delivery is safe, and both the team and the agent can keep learning from each task.

image_2_

The analysis follows four main steps:

  1. Map the current harness: identify its goals, context, execution entry points, feedback, delivery process, and learning mechanisms.
  2. Find the gaps: show which part of the loop lacks a mechanism, integration, actual execution, or evidence of results.
  3. Choose the smallest effective mechanism for improvement: address the issue with the most appropriate Rule, Skill, Hook, script, automation, or human approval gate.
  4. Fix and recheck: keep the fix within a defined scope, run the relevant checks, and rerun /better-harness to see whether the loop has actually improved.

Better Harness first gathers raw data through its main analysis flow. It then asks three independent, read-only subagents to interpret three types of evidence: agent customization assets (whether Rules, Skills, Hooks, and other configurations are complete and usable), real task sessions (what the agent actually did and what happened), and the project’s software engineering foundations. Evidence is collected independently and then brought together, preventing one line of analysis from biasing another.

Agent Customization: From Available Capabilities to Actual Use

In coding agents such as Qoder, Rules, Skills, Custom Agents, MCPs, Plugins, Memories, and Hooks are the building blocks of an agent loop. Better Harness identifies these user-configured capabilities, as shown below.

image_3_

But having these capabilities does not make a loop reliable. Tests in a project do not prove that the relevant tests ran for this task; an installed Skill does not prove that the agent used it when needed. We therefore also examine how Skills, Rules, and other capabilities are used to help users uncover context engineering issues that affect the loop.

The report uses Qoder Canvas to present more detailed data, such as each Skill’s usage trend over time: which are called frequently, and which have never been used since installation. Fixing these context engineering issues also has a direct benefit: lower credit consumption. The agent no longer has to spend context on repeatedly figuring out the same things.

image_4_

Better Harness also analyzes past sessions for practices that could become Rules or Skills and help users work faster. But not every finding should become a Skill, and not every recurring task should be automated. The analysis concludes with practical recommendations for improvement, as illustrated below.

image_5_

For an identified improvement opportunity, simply click “Plan a fix” to have AI generate and execute a corresponding repair plan. More importantly, these fixes need not serve only the current task: they can become reusable user assets such as Rules, Skills, and Memories, continually strengthening your own agent harness.

Each task analysis becomes more than a one-off optimization: it helps refine your own harness. As your reusable assets grow, the agent gains a better understanding of you and your project, improving the quality and efficiency of subsequent loops.

Real Task Sessions: Reconstructing How the Agent Loop Actually Ran

Having the underlying capabilities does not, on its own, make a harness reliable. Tests in a project do not prove that the relevant tests ran for this task; an installed Skill does not prove that the agent used it when needed. Better Harness therefore also analyzes real task sessions—the last 30 days by default—to establish what the agent actually did and what results it achieved.

image_6_

The basic unit of analysis is a task episode: a user goal paired with an observable acceptance criterion. Within each episode, we focus on four types of signals:

  1. Recurring workflows: when the same type of task repeatedly involves the same steps or corrections across episodes, a Skill, Rule, or script may be missing.
  2. Closed-loop verification: whether tests, linting, builds, regression checks, and other checks actually ran and targeted the right areas. Repetition alone does not make verification effective; the analysis must also consider whether the subsequent results were accepted.
  3. Attributing friction: when a task stalls, determine whether the cause lies in the harness, the project, the model, or the requirements themselves, rather than blaming every failure on the agent.
  4. High-impact one-off events: whether an operation blocked by permission controls, a missing diagnostic entry point, or a failed recovery materially changed the course of the task.

An independent, read-only subagent performs this analysis. It can access only sanitized factual summaries—not raw prompts, private paths, secrets, or other sensitive content. Together, these signals let us examine how Skills, Rules, and other capabilities are actually used, helping users identify context engineering issues that affect the loop while reducing unnecessary credit consumption.

Project Engineering Foundations: Discover, Run, and Verify

The quality of a loop depends not only on how the agent is used, but also on the project’s existing software engineering foundations. A project may have extensive documentation, scripts, and tests. Yet if the agent cannot find the right entry points, get the project running, or use failure results to decide what to do next, those capabilities are unlikely to play a meaningful part in the task loop.

image_7_

This part of the analysis examines five aspects of the engineering foundations needed to support an agent’s work:

  1. Discoverability: for a specific task, can the agent quickly locate the relevant code, module boundaries, project constraints, and required checks?
  2. Run readiness: are dependencies, configuration, build steps, and startup instructions clear? When the environment breaks, can it be diagnosed, reset, and brought back into a working state?
  3. Fast feedback: after a code change, do suitable checks and tests promptly tell the agent what went wrong, where the problem may have originated, and what to do next?
  4. Enforceable requirements: are architecture, security, interface compatibility, database migration, and other requirements checked automatically by tools, rather than existing only in documentation or conventions?
  5. Controlled changes: are the boundaries of the agent’s changes clear? Do high-risk operations require confirmation, and can failures be followed by a rollback, recovery, or safe exit?

For example, a test command in a README shows only that the project provides an entry point for testing. Inspecting the script reveals what it actually covers. Only when those checks run during a real task and their results lead to the necessary corrections can we establish that this feedback path has truly become part of the agent loop.

Make Every Agent Loop Strengthen the Next

A /better-harness analysis is not the finish line. It helps you find gaps, generate a repair plan, and verify after the fix that a new Rule, Skill, Hook, or script has genuinely become part of the agent’s work loop.

More importantly, lessons worth reusing become personal or team agent assets, making subsequent loops more stable, efficient, and controlled.

Update to the latest Qoder Desktop release, v1.18.0, and open Better Harness in the Quest window—or run /better-harness—to see which gap is most worth addressing next.

0 1 0
Share on

Alibaba Cloud Community

1,596 posts | 525 followers

You may also like

Comments

Alibaba Cloud Community

1,596 posts | 525 followers

Related Products

  • Qoder

    From Assisted to Autonomous — Adapting to Every Programming Need

    Learn More
  • QwenWork

    QwenWork is dedicated to helping employees strengthen their professional competitiveness in the AI era and to enabling enterprises to improve organizational effectiveness.

    Learn More
  • AgentCore

    AgentCore unifies agent construction, governance, and execution capabilities so enterprises can deploy diverse agents with confidence.

    Learn More
  • Token Plan

    Build more, spend less. One plan, every modality.

    Learn More