When Does Restricting a Coding Agent to execute_code Help? A Regime $\times$ Agent-Design Ablation

• URL: http://arxiv.org/abs/2607.10569v1
• Date: Sun, 12 Jul 2026 04:52:08 GMT
• Title: When Does Restricting a Coding Agent to execute_code Help? A Regime $\times$ Agent-Design Ablation
• Abstract summary: We run a comparison of three-arm ablation (baseline / bash_only / code_only) on synthetic computation tasks and SWE-bench Mini modification tasks.<n>Across the four resulting (regime, agent) cells, restricting the agent to a single execute_code MCP tool is cheaper than -- or statistically tied with -- its cheapest tool-rich rival.<n>The lone exception is SWE-bench/Claude, where code_only is directionally costlier.
• Score: 20.672156968511587
• License: http://creativecommons.org/licenses/by/4.0/
• Abstract: Modern coding agents expose multiple tool surfaces -- IDE primitives, bash, and Model Context Protocol (MCP) code-execution -- and the field has shipped three contradictory claims about which one matters. We run the missing crossed comparison: an integrity-clean three-arm ablation (baseline / bash_only / code_only) on synthetic computation tasks and SWE-bench Mini modification tasks, holding model, harness, and prompts fixed, with two agents (Claude Code, OpenAI Codex CLI) so the comparison spans both regime and agent-design axes. Across the four resulting (regime, agent) cells, restricting the agent to a single execute_code MCP tool is cheaper than -- or statistically tied with -- its cheapest tool-rich rival in three cells (significantly on Artifact/Claude and SWE-bench/Codex; directionally on Artifact/Codex), with pass rates statistically tied within each cell. The lone exception is SWE-bench/Claude, where code_only is directionally costlier (+14.4%, not significant); a conditional-cost analysis localizes that gap to failure-cost on doomed-run trajectories, not a per-edit tax on successful runs. Two implications: the cheapest tool surface is jointly determined by task regime and agent design rather than by either axis alone, and the headline cost signal lives in cache-adjusted cost -- not pass rate, which is invariant across surfaces at the model sizes we evaluate. The benchmark harness, task suite, and analysis code are available at https://github.com/hyang0129/onlycodes.

Related papers

• Codebook Agent: Amortized Topology Design for LLM Multi-Agent Systems [67.04448659688579]
  We develop a query-independent 16-entry codebook that ranks the top decoded candidates in a single batched forward pass.<n>With no iterative search and no message passing at test time, Codebook Agent is the most accurate method on all six benchmarks.
  arXiv  Detail & Related papers  (2026-09-02T08:10:22Z)
• TRIM: Reducing AI-Generated CodeSlop via Agent Trajectory Minimization [57.14479960309637]
  Coding agents are increasingly used to accelerate code generation in many downstream tasks.<n>Despite their value, agent-generated code tends to be larger and more verbose than the corresponding human-written implementation.<n>We show that the cause lies in the agent's own search process.
  arXiv  Detail & Related papers  (2026-07-20T17:06:19Z)
• Teach it to stop, not just to click [0.0]
  We show a repaired policy's success rate is dominated by upstream footing.<n>We release a library (cua_reliability) for routine k-seed reporting.
  arXiv  Detail & Related papers  (2026-07-19T08:46:06Z)
• To Run or Not to Run: Analyzing the Cost-Effectiveness of Code Execution in LLM-Based Program Repair [18.653708704742353]
  Executions can be time-consuming and expensive, yet their impact on program repair agents remains underexplored.<n>Code execution is used across all agents and models analyzed, with an average of 8.8 test runs per task.<n>Current agents apply execution indiscriminately, paying its cost on instances where it provides little benefit.
  arXiv  Detail & Related papers  (2026-06-25T12:49:59Z)
• Code Isn't Memory: A Structural Codebase Index Inside a Coding Agent [0.13999481573773073]
  We run three arms (the harness with the index, the same harness without it, and an agentic- comparator) on SWE-PolyBench and SWE-bench Pro with Opus 4.7 held fixed throughout.<n>The within-harness ablation produces a large localization gain and a statistically separated resolve gain, with no cost penalty per cell and lower cost per solve.<n>The deployment question for a structural index is thus not whether it is too expensive to run (across seeds, the index lands at a lower $/solved than agentic) but whether the workload includes multi-file changes where structural ranking pays off
  arXiv  Detail & Related papers  (2026-06-21T10:10:51Z)
• ExecuGraph: A Multi-Agent, Execution-Grounded Framework for Reliable Backend Code Synthesis with Large Language Models [2.3004655342211078]
  Large Language Models generate plausible backend code, but a single-pass paradigm provides no guarantee of correctness or runtime reliability.<n>We present ExecuGraph, a multi-agent framework that places execution-based validation at the center of backend code.<n>A per-agent ablation, retry-budget sweep, error-class taxonomy, and test-source audit are reported.
  arXiv  Detail & Related papers  (2026-06-18T05:58:17Z)
• Claw-SWE-Bench: A Benchmark for Evaluating OpenClaw-style Agent Harnesses on Coding Tasks [75.92297551160692]
  General-purpose agents such as OpenClaw are increasingly used as autonomous tool users.<n>We introduce Claw-SWE-Bench, a multilingual SWE-bench-style benchmark and adapter protocol.<n>Claw-SWE-Bench treats harness and cost accounting as first-class axes of SWE-style coding-agent evaluation.
  arXiv  Detail & Related papers  (2026-06-10T17:16:23Z)
• Scaling Laws for Agent Harnesses via Effective Feedback Compute [53.68149869349268]
  emphEffective Feedback Compute (EFC) is a trace-level scaling coordinate that credits feedback only when it is informative, valid, non-redundant, and retained for subsequent decisions.<n>EFC-based coordinates consistently predict failure rates better than raw-compute baselines.
  arXiv  Detail & Related papers  (2026-05-28T09:45:47Z)
• LACUNA: Safe Agents as Recursive Program Holes [3.2613419151327343]
  LLM agents increasingly act by writing code, yet a split persists between the runtime that drives the agent and the code the model writes.<n>We present LACUNA, a programming model for agents that closes this split while preserving safety.<n>Our primitive expresses ReAct loops, sub-agents, skills, parallel decomposition, and multi-model planning as ordinary control flow.
  arXiv  Detail & Related papers  (2026-05-27T15:27:25Z)
• From Patches to Trajectories: Privileged Process Supervision for Software-Engineering Agents [56.31499185764872]
  Supervised fine-tuning (SFT) on long teacher trajectories is the dominant way to instill investigation and reasoning in open software-engineering (SWE) agents.<n>We propose Patches-to-Trajectories (P2T), which uses $pstar$ as privileged information during curation and formulates trajectory construction as bi-objective optimization over per-step effectiveness and trajectory length.
  arXiv  Detail & Related papers  (2026-05-21T04:54:55Z)
• ClawSafety: "Safe" LLMs, Unsafe Agents [25.729388843970014]
  Personal AI agents like OpenClaw run with elevated privileges on users' local machines.<n>ClawSAFETY is a benchmark of 120 adversarial test scenarios organized along three dimensions (harm domain, attack vector, and harmful action type)<n>Each test case embeds adversarial content in one of three channels the agent encounters during normal work: workspace skill files, emails from trusted senders, and web pages.
  arXiv  Detail & Related papers  (2026-04-01T22:24:24Z)
• RewardHackingAgents: Benchmarking Evaluation Integrity for LLM ML-Engineering Agents [0.9821874476902969]
  LLM agents increasingly perform end-to-end ML engineering tasks where success is judged by a single scalar test metric.<n>This creates a structural vulnerability: an agent can increase the reported score by compromising the evaluation pipeline rather than improving the model.<n>We introduce RewardHackingAgents, a workspace-based benchmark that makes two compromise vectors explicit and measurable.
  arXiv  Detail & Related papers  (2026-03-11T22:06:44Z)
• INC: An Indirect Neural Corrector for Auto-Regressive Hybrid PDE Solvers [61.84396402100827]
  We propose the Indirect Neural Corrector ($mathrmINC$), which integrates learned corrections into the governing equations.<n>$mathrmINC$ reduces the error amplification on the order of $t-1 + L$, where $t$ is the timestep and $L$ the Lipschitz constant.<n>We test $mathrmINC$ in extensive benchmarks, covering numerous differentiable solvers, neural backbones, and test cases ranging from a 1D chaotic system to 3D turbulence.
  arXiv  Detail & Related papers  (2025-11-16T20:14:28Z)
• Runaway is Ashamed, But Helpful: On the Early-Exit Behavior of Large Language Model-based Agents in Embodied Environments [54.67512489842682]
  Large language models (LLMs) have demonstrated strong planning and decision-making capabilities in complex embodied environments.<n>We take a first step toward exploring the early-exit behavior for LLM-based agents.
  arXiv  Detail & Related papers  (2025-05-23T08:23:36Z)

This list is automatically generated from the titles and abstracts of the papers in this site.

This site does not guarantee the quality of this site (including all information) and is not responsible for any consequences.