Code Becomes the Agent Harness

This survey reframes code as the runtime layer that connects agent reasoning, actions, memory, and verification.

• Research org: Unspecified in arXiv abstract
• Core data: No benchmark numbers in abstract
• Breakthrough: Centers code as the basis for agent infrastructure

Large language models are already good at writing code, but this paper argues that code is becoming more than an output format. In agentic systems, it can serve as the operational layer that ties together reasoning, action, environment modeling, and execution-based verification.

For developers, that matters because the quality of an agent is no longer just about the model’s next-token accuracy. It also depends on the harness around the model: how it plans, stores state, calls tools, checks results, and coordinates across steps or across agents.

What problem this paper is trying to fix

The paper starts from a simple observation: modern LLMs can generate and understand code across a wide range of tasks, from competitive programming to repository-level software engineering. But once those models are used as agents, code is no longer merely the thing being produced. It becomes the substrate that lets the system operate.

That shift creates a terminology and design problem. If code is doing double duty as both an artifact and an infrastructure layer, then it helps to have a framework for thinking about what that infrastructure actually includes. This survey proposes that framework by using the idea of an agent harness.

In plain English, the paper is trying to give engineers a cleaner mental model for agent systems built around code. Instead of treating planning, memory, tools, and verification as separate add-ons, it groups them under one view: code as the harness that holds the agent together.

How the method works in plain English

This is a survey, so the “method” is not a new model architecture or a training recipe. The contribution is a structured way to organize the field. The authors divide code-as-harness systems into three connected layers.

The first layer is the harness interface. This is where code connects the agent to reasoning, action, and environment modeling. In practice, this is the part that decides how the agent expresses steps, invokes operations, and represents the world it is acting in.

The second layer is harness mechanisms. Here the paper focuses on planning, memory, and tool use for long-horizon execution, plus feedback-driven control and optimization. The point is to make the harness reliable and adaptive rather than brittle.

The third layer is scaling from single-agent to multi-agent systems. In that setting, shared code artifacts can support coordination, review, and verification across multiple agents. That is a useful lens for systems where several workers need to agree on state, inspect each other’s outputs, or divide responsibilities.

Seen together, these layers describe code not as a side effect of agent behavior, but as the operating surface where the agent’s behavior becomes executable and checkable.

What the paper actually shows

Because this is a survey, the abstract does not report a new benchmark, a model release, or an experimental comparison. There are no numbers in the abstract to cite, so the paper should be read as a conceptual and organizational contribution rather than a results paper.

What it does provide is a map of representative methods and applications. The survey spans coding assistants, GUI and OS automation, embodied agents, scientific discovery, personalization and recommendation, DevOps, and enterprise workflows. That range is important because it shows the harness idea is not limited to one narrow coding benchmark.

The paper also highlights open challenges that are practical rather than theoretical. These include evaluation beyond final task success, verification when feedback is incomplete, regression-free harness improvement, consistent shared state across multiple agents, human oversight for safety-critical actions, and support for multimodal environments.

That list is a strong signal about where current agent systems still struggle. It suggests that even if the model can produce plausible steps, the surrounding code layer still has to deal with state, error recovery, and safety in ways that are hard to capture with a single end metric.

Why developers should care

If you are building agentic software, this paper is useful because it pushes you to think like a systems engineer, not just a prompt engineer. The harness is where the agent becomes something you can run, inspect, retry, and verify.

That framing matters for production. A code-centric harness can make it easier to represent long-running workflows, preserve state across steps, and create explicit checkpoints for verification. It can also make failures more diagnosable, because the agent’s actions are mediated through code rather than hidden inside a free-form text stream.

At the same time, the paper is clear about the hard parts. Shared state across multiple agents is still tricky. Safety-critical actions still need human oversight. And evaluation based only on whether the final task succeeded is not enough to tell you whether the harness is actually robust.

For teams shipping agents into real workflows, that means the interesting question is not just “Can the model do the task?” It is “Can the code layer around the model make the task executable, verifiable, and stateful under messy real-world conditions?”

What this means in practice

The most practical takeaway is that code should be treated as infrastructure for agents, not just as a language the model happens to speak. That changes how you might design an agent stack: more explicit interfaces, more internal state management, more verification hooks, and more attention to how multiple agents share artifacts.

The survey does not claim that this approach solves agent reliability. It does, however, argue that a unified harness perspective can help organize the next wave of agent engineering. For anyone building coding assistants, automation systems, or multi-agent workflows, that is a useful shift in perspective.

• Code is presented as the operational layer for agent reasoning and action.
• The survey organizes the field into interface, mechanisms, and scaling to multi-agent systems.
• Its main value is a practical framework for building executable and verifiable agent systems.

In other words, the paper is less about a single breakthrough model and more about a design pattern for the agent era. If code is the harness, then agent quality depends as much on the surrounding system as on the model inside it.