Review paper argues code is becoming the operating layer for AI agents

Researchers from UIUC, Meta, and Stanford argue in a new review paper that code is becoming the foundation for how AI agents reason, act, and collaborate.

Code moves from output to operating substrate

The paper, titled “Code as Agent Harness” and published on arXiv, frames a shift in how agentic AI systems are built. According to the arXiv abstract, code is “no longer only an output” of AI systems but is becoming an “operational substrate” for reasoning, acting, environment modeling, and execution-based verification.

That distinction matters because many current AI products are described as agents when they do more than return text. In practice, an agent often needs to call tools, maintain context, interact with software environments, check results, and decide what to do next. The review paper argues that those capabilities are increasingly implemented through code surrounding the language model, rather than through the model alone.

The Decoder, which reported on the paper, summarizes the authors’ position as a code-centered view of agentic AI. The publication says the researchers argue that code is the foundation agents use to reason, act, and collaborate through an agent harness layer.

What the harness does

The project page for “Code as Agent Harness” describes the survey as a code-centered view of agentic AI in which code supports several agent functions: reasoning, acting, environment modeling, feedback, and multi-agent coordination.

In this framing, the language model is not treated as a fully autonomous system by itself. Instead, it is one component inside a broader software structure. That structure can define available tools, represent state, run checks, manage feedback from the environment, and coordinate activity between multiple agents.

The arXiv paper specifically highlights execution-based verification. That means an agent can use code not only to propose an answer or plan, but also to run something and evaluate whether the result works. For software tasks, this might involve executing tests. For other domains, the same principle can apply when an agent interacts with a simulated or structured environment and uses the result as feedback.

Why this matters for agent design

The review’s core argument is that the engineering layer around a model may be as important as the model itself for agentic behavior. If an agent needs memory, tools, action permissions, testing, or coordination mechanisms, those features must be represented and controlled somewhere. The authors’ answer is that code increasingly provides that control layer.

This view also helps separate two questions that are often blurred in discussions about autonomous agents. One question is how capable the underlying language model is. The other is how the surrounding system lets that model act. The paper’s framing suggests that progress in agents depends not only on larger or better models, but also on better harnesses: software structures that let models interact with environments in reliable and verifiable ways.

A survey of an emerging architecture

The project page presents the work as a survey, not as a single new agent system. Its contribution is to organize recent agentic AI work around the idea that code serves as the operational substrate for agent behavior.

That makes the paper useful as a map of where agent research is heading. Rather than treating code generation as the endpoint, the authors describe code as part of the loop that lets an AI system plan, execute, observe, revise, and coordinate.

The practical implication is straightforward: building more capable agents may require as much attention to harness design as to model selection. According to the sources, the review paper argues that code is increasingly the layer where agent reasoning becomes action.