Clean code and memory buy coding agents efficiency, not success

SonarSource ran Claude Code through 660 trials and found that code cleanliness had no effect on whether the agent finished its tasks (Does Code Cleanliness Affect Coding Agents?, on Hacker News’ front page today). The methodology is the careful kind this question deserves: minimal-pair repositories matched on architecture and dependencies but differing in static-analysis violations and cognitive complexity, built bidirectionally by degrading clean repos and cleaning messy ones, with 33 tasks graded by hidden tests at the application’s public surface. Completion rates didn’t budge in either direction. The bill did: on clean code the agent used 7 to 8% fewer tokens and revisited files 34% less often. Cleanliness didn’t make the agent smarter; it made the agent cheaper.

A community benchmark posted over the weekend reached the same shape of conclusion from the memory side. The team behind Greplica, a context layer for coding agents, benchmarked persistent memory with a temporal holdout: build memory only from a repo’s earlier agent sessions, hold out a later session, run its planning task at the same pre-task commit with and without memory. On 10 high-context planning tasks, memory cut cost 43%, tokens 49%, tool calls 36%, and planning time 26%. Two buried findings outrank the headline numbers. Without memory, identical tasks produced wildly different planning traces run to run, so single-run agent benchmarks carry that variance whether they report it or not. And the obvious baseline, dumping session notes into a docs folder, matched graph memory at 3 ingested sessions and degraded badly by 11, because the docs folder becomes a second codebase the agent must search, rank, and de-conflict. Their line for it: the bottleneck moves from storage to retrieval.

Read together, the two studies locate the cost of agentic coding in exploration rather than completion. Agents finish the task either way; what varies is tokens, tool calls, revisits, and variance. That makes pass rate the least informative number in a benchmark table, and the operational columns the ones worth reading first.

The harness infrastructure that surfaced in the last day fits that reading. Yohei Nakajima’s paper The Log Is the Agent proposes ActiveGraph, a runtime that inverts the usual framework shape: the append-only event log is the source of truth and the agent’s working graph is a deterministic projection of it. Event sourcing’s guarantees transfer intact, and they are things retrieval-and-summarize memory cannot offer: deterministic replay of any run from its log, forking at any event without re-executing the shared prefix, and lineage from top-level goal down to each model call. An Apache-2.0 implementation ships with replay and fork-and-diff demos. The determinism contract around model calls is where I’d probe first.

Sakana AI published Fugu, a multi-agent orchestrator consumed as a single model endpoint speaking Chat Completions or Responses. Behind the endpoint, two mechanisms from their ICLR 2026 work coordinate a pool of frontier models: TRINITY, a compact coordinator optimized with an evolutionary strategy that delegates three roles turn by turn, and Conductor, an RL-trained model that designs the agent-to-agent communication topology and writes targeted instructions for each worker. They benchmark against Gemini 3.1 Pro, Opus 4.8, and GPT 5.5. The packaging is the story: if orchestration hides behind a model API, multi-agent stops being an architecture decision, and your evals can no longer see the topology they’re grading.

At the opposite end of the stack, Mouse replaces the string-replacement edit primitive most agents live on with six declarative coordinate-based operations (INSERT, DELETE, ADJUST among them), staged changes with atomic rollback, and tool responses carrying risk assessment and next-action suggestions. Patent-pending and commercial, which will cap adoption, but the diagnosis is sound: the edit tool is fifteen lines of glue in most harnesses and it is load-bearing.

The cautionary read is Exploiting LLM Agent Supply Chains via Payload-Less Skills, which names the attack Semantic Compliance Hijacking: a malicious skill file containing no executable payload, only natural-language rules styled as compliance requirements, which the agent obligingly compiles into harmful behavior at runtime. Across three agent frameworks and three foundation models, peak success reached 77.67% for confidentiality breaches and 67.33% for remote code execution, while current scanners detected the manipulated skill files at a rate of 0.00%. Skills are becoming a package ecosystem with registries and one-line installs; every scanner in that ecosystem is still looking for code that isn’t there.

Watch three things from here: whether benchmark tables start reporting cost and variance next to pass rates, whether anyone publishes evals that can grade an orchestration endpoint whose topology is invisible, and which skill registry ships semantic intent validation before the first payload-less incident lands in the wild.