This repository accompanies the survey Code as Agent Harness: Toward Executable, Verifiable, and Stateful Agent Systems. We study the emerging role of code in agentic AI: code is no longer only a generated artifact, but increasingly serves as an executable, inspectable, and stateful harness through which agents reason, act, model environments, receive feedback, and coordinate. The repository organizes representative papers around three connected layers: Harness Interface, Harness Mechanisms, and Scaling the Harness, covering directions such as coding assistants, GUI/OS automation, scientific discovery, and embodied intelligence.

@article{ning2026codeasharness,
  title   = {Code as Agent Harness: Toward Executable, Verifiable, and Stateful Agent Systems},
  author  = {Ning, Xuying and Tieu, Katherine and Fu, Dongqi and Wei, Tianxin and Li, Zihao and Bei, Yuanchen and others},
  journal = {arXiv preprint arXiv:2605.18747},
  year    = {2026}
}

[2026-05] 🚀 Our survey Code as Agent Harness: Toward Executable, Verifiable, and Stateful Agent Systems is available on arXiv. Slides and project page links will be added here once available.

• 🔔 News
• 📋 Table of Contents
• 🧩 Harness Interface
  • 💭 Code for Reasoning
  • 🤖 Code for Acting
  • 🌍 Code for Environment Modeling
• 🛠️ Harness Mechanisms
  • 🗺️ Planning for Code Agents
  • 🧠 Memory and Context Engineering
  • 🔧 Tool Usage for Code Agents
  • 🧪 Feedback-Guided Iterative Debugging
• 👥 Scaling the Harness: Multi-Agent Code-Centric Systems
  • 🎭 Functional Role Specialization
  • 💬 Interaction Modes
  • 🕸️ Workflow Topology
  • ⚡ Execution Feedback Integration
  • 🔄 Shared-Harness Synchronization
  • 🏛️ Shared Harness Representation
  • 🎯 Harness-State Convergence
• 🚀 Applications and Emerging Fields
  • 💻 Code Assistants
  • 🖥️ GUI / OS Agents
  • 🔬 Scientific Discovery Agents
  • 🤖 Autonomous Embodied Agents

Code as the basic interface between a model and its task environment. Programs convert model outputs into executable, inspectable, and stateful structures: code makes reasoning executable, action programmable, and environment state inspectable.

Programs externalize internal logic into verifiable computation, allowing interpreters, symbolic solvers, execution traces, or process rewards to check and refine intermediate steps.

Generated programs serve as policies, tool calls, behavior trees, or reusable skills for embodied, GUI, software, and tool-use environments.

Program states, repositories, traces, simulators, and tests represent state, dynamics, and feedback signals for agent interaction.

Once code is placed inside the agent loop, the harness must decide what to execute next, preserve useful state, expose the right tools, and convert failures into corrective actions.

Planning is harness control: it structures how the agent externalizes intent into executable steps, schedules interactions with code artifacts and tools, and regulates the trajectory of reasoning, execution, and revision over time.

Memory in code-as-agent-harness systems is a state-management layer: which information stays in the active context, which is compacted, and which is offloaded to durable external storage.

Tool usage is the action and observation layer of the code-agent harness: agents search repositories, inspect files, edit code, run commands, execute tests, call APIs, and verify intermediate results — all under typed schemas, sandboxes, and lifecycle hooks.

Iterative debugging closes the harness loop: development environments expose feedback (compiler diagnostics, runtime errors, tests, critique), and the agent transforms these signals into diagnosis, revision, and progressively better debugging behavior.

When multiple agents operate over code, the harness must coordinate roles, share intermediate artifacts, maintain common state, and verify collective progress through repositories, tests, traces, and structured workflows.

Distinct agents own slices of the shared code harness — synthesis, understanding, verification, execution, and planning.

Code-centric multi-agent interaction is artifact-mediated: agents observe and modify shared code, and grounding comes from the objective state exposed by execution.

Topology of agent interaction (chain, cyclic, hierarchical, star, adaptive) is one of the most consequential design decisions in multi-agent code generation.

Code is uniquely executable, producing objective oracle signals that anchor multi-agent coordination.

How multi-agent systems maintain a consistent shared view of program state.

Four levels of formalization for the shared substrate: implicit/file-only, repository-based, execution-based, and blackboard.

How a multi-agent code system decides the shared harness has reached an acceptable final state.

Code-centric agentic systems become operational in tangible domains where code defines observable state, executable actions, persistent memory, and feedback signals.

Repositories, tests, issue threads, and development tools form a persistent program world; assistants act over it as code-centric agents.

GUI/OS environments are program worlds in the most literal sense: every observation is rendered code, and every action is a call into another piece of code.

Code grounds embodied actions in physical feasibility, accumulates reusable skills as memory, and supports auditable real-world deployment.

Hypotheses are encoded as differential equations or generative models; protocols as XDL or Opentrons scripts; analyses as Jupyter notebooks. Code carries scientific reasoning, scientific action, and the scientific environment itself.

As recommendation moves from static prediction toward interactive agents, personalization systems must reason over latent and evolving user preferences through structured, editable preference states and executable feedback pipelines.

We thank the broader community for the contributions surveyed here. If your paper should be added or moved, please open a pull request or issue.

This repository is released under the MIT License.