Trend

Coding agents are being measured by controls, memory, and cost

Week · 2026-W24 · Software Intelligence

This week’s large language model (LLM) coding work treats autonomy as an operations problem. Claw-SWE-Bench, Trace, and PROJECTMEM show the center of gravity: compare agent harnesses fairly, enforce user rules at runtime, and keep project state across sessions.

Runtime enforcement and action limits

Agent control moved into the execution loop. Trace compiles user corrections into rules with applicability checks and verifiers, then blocks completion until active checks pass. In ClawArena, it reduced held-out preference violations to 37.6% in distribution and 2.0% out of distribution.

The enterprise-security work adds a broader control model for production agents. It checks plans, delegation chains, capability sets, and session state before actions reach tools. Agent Joe gives a smaller product example: a Rust-only coding agent with no shell access, built to cut the risk of arbitrary terminal commands. Claude Code’s nested sub-agents show why these limits matter. Nesting improves context isolation, but the cited examples include 887,000 tokens per minute and a $47,000 invoice after 23 sub-agents.

Harness accounting and agent benchmarks

Benchmark work focused on the agent harness, not only the base model. Claw-SWE-Bench fixes task set, prompt, Docker workspace, budget, patch extraction, and evaluator so harnesses can be compared under the same contract. Its results are large enough to matter operationally: with the same GLM 5.1 model, a minimal OpenClaw adapter reached 19.1% Pass@1, while the full adapter reached 73.4%.

AgentBeats takes a related evaluation problem and makes the benchmark itself a judge agent. The paper reports a five-month competition with 298 judge agents and 467 subject agents. EsoLang-Bench adds another stress test. It separates six coding agents by 88.4 percentage points, far wider than the 6.6-point spread reported on SWE-Bench Verified in the same summary.

Persistent state for multi-agent coding

State became a first-class engineering object. PROJECTMEM records issues, attempts, fixes, decisions, and notes in an append-only local log. It exposes that memory through the Model Context Protocol (MCP), a tool interface for connecting agents to external context and actions. Its pre-action gate warns before the agent repeats a failed fix or edits a fragile file.

DeLM shows the multi-agent version of the same need. Agents share verified gists about facts, failed hypotheses, constraints, and partial solutions, then pull work asynchronously from a queue. On SWE-bench Verified with Gemini 3 Flash, it reports 65.7% Avg.@1 at $0.12 per task, compared with $0.24 to $0.26 for listed baselines. Claude Code’s nested agents add a commercial example of separate context frames, though the cost evidence argues for explicit spend caps.

Proof signals and safer software work

Several sources treat verification as part of the agent work loop. Jane Street’s formal-methods essay argues that agent-written code increases review pressure, and that proof tools can give agents feedback beyond tests. The piece gives the old cost baseline clearly: seL4 took 25 person-years to verify 8,700 lines of C, with about 23 lines of proof per line of code.

ComAct shows a different path to safer action: make professional software control executable and inspectable. In CAD workflows, the agent writes Python scripts over COM interfaces, then uses code validity and task success as evaluation signals. The reported ComCADBench covers 1,000 tasks across SolidWorks, Inventor, and AutoCAD, with GUI-based agents near zero success in the summary.

NewerRobot VLA work is being tested against time, contact, and missing evidenceOlderAgent tools need memory, proof signals, and secretless sandboxes