AI Agents

A sharp answer to benchmark saturation and leakage: instead of fixed tasks, two coding agents evaluate each other over mirrored Red-Blue turns. Red implements a feature with tests, embeds a subtle bug with sealed trigger tests, and the PR is only admitted if a blind repair succeeds — ruling out unsolvable tasks. Blue then reviews without being told a bug exists. Across 11 participants, 15 repos, five languages, 1,500 turns, leaders split: GPT-5.5+Codex repairs 98.3% of defects; Opus 4.8 authors the hardest tasks.

A genuinely useful piece of interpretability work on tool calling. The authors reduce noisy agentic prompts to minimal contrastive pairs where swapping an execution verb (write) for an analysis verb (discuss) flips the tool-call decision, then trace that decision to a single vector that's causally necessary and sufficient and generalizes to multi-turn τ²-Bench trajectories. The mechanism: the scaffold sets a tool-call prior, and analysis verbs suppress it via features signaling tool use is unnecessary. Clean methodology, concrete causal claims.

Repository-scale codegen reframed around reusable "Code Primitives" — executable components carrying interface contracts, dependency closures, validation tests, and provenance, with a resident LLM adapting each to the target repo. The LEGO pipeline activates relevant primitives, integrates them, resolves cross-component constraints, and revises against tests. On a new 522-task reconstruction benchmark, the best of 13 backbones scores only 0.318 and zeroes 41% of tasks; LEGO lifts all 13 by 0.147 on average and GPT-5.6-terra by 61.4%. The absolute ceilings show how hard whole-repo construction still is.

A pointed negative result on LLM-generated regression tests. Across 145 merged PRs in SciPy, Qiskit, and pandas, 8-17% of generated tests are fault-enforcing — they assert buggy behavior as correct — versus only 2.4-4.8% that reveal faults. Worse, these tests persist: after subsequent commits, 83-91% still pass and stay relevant, and when accumulated across PRs the developer-written suite catches only 14-30% of them. The core failure mode is structural: generating tests from code under test encodes whatever faults the code already has.

Test-based patch selection for SWE-agent ensembles, reframed as optimizing a test suite until it discriminates competing patches. TestGRAD borrows from gradient descent with momentum: a differential loss rewards tests that separate candidates, full-CRUD "gradients" let it read, create, update, and delete tests rather than only add/remove, and Failure Pattern Momentum mines frequent failure sequences to avoid repeating non-discriminative directions. It reaches 84.2% Pass@1 with a 4-agent ensemble on SWE-bench Verified, beating the best baseline's 80.6% by 3.6pp.

A YC launch offering agent sandboxes at roughly $0.37/month, with free-tier infrastructure cost of $0.05-$0.10 per user. It's a vendor pitch, but the cost techniques are concrete and worth reading: agent harnesses burst CPU during init then idle, so you can oversubscribe and pack by RAM, run on gVisor rather than full VMs, and host on non-hyperscaler hardware. The economics are the interesting part, not the product.

An analysis piece arguing that AI coding agents produce more code without producing proportionally more shipped software — the bottleneck moves to review, integration, and verification rather than generation. It struck a nerve on HN (337 points). The thesis matches what most teams running coding agents already feel, but it's opinion and anecdote, not instrumented measurement: no throughput data, no before/after on merged features. Read it as a well-articulated prior, not evidence.

An open-source tool pointing agents at reverse-engineering tasks, from app behavior down to native binaries. The use case is genuinely novel — most agent tooling targets greenfield codegen, not disassembly and behavioral analysis of compiled artifacts, which demands very different tool orchestration. Detail is thin at this stage: the repo is the main artifact, with no writeup on how it handles the long-horizon, high-ambiguity loop of RE work. Promising direction, early days.

A macOS voice assistant built by a 9th grader that routes trivial tasks (opening apps, Spotify, web queries) locally in under a second and sends complex ones to claude -p, so it runs on an existing Pro/Max plan with no API key. The design detail worth noting: it caches successful task steps and replays them without the model, cutting a 30-second workflow to 5-8 seconds. Consumer-leaning, but the shortcut-caching pattern is a real latency win.

Linus Torvalds is reportedly using Claude Code on a substantial kernel improvement. As a signal it's notable — the kernel is about as unforgiving a codebase as exists, and Torvalds is not an easy convert — but the coverage is thin on specifics: what the change is, how much the agent actually contributed versus scaffolding, and what review looked like. File under credible datapoint, not case study.

A conference recap of Anthropic's pitch for "dynamic workflows" — borrowing Unix/Linux composition ideas to let Claude agents take on larger projects without flooding developers with coordination overhead. The framing is promising for anyone building multi-agent orchestration, but this is a summary blurb with no concrete mechanism: no scheduling model, no description of how work gets decomposed or handed off, no evals. Worth watching for the actual writeup.

Python 3.15 ships, and the headline for agent builders is PEP 810 explicit lazy imports: lazy import json defers the import until first use. Simon Willison notes his LLM CLI already recommends manual lazy imports so plugins don't drag expensive dependencies into every startup. Making this a language primitive matters for cold-start latency in agent harnesses and plugin systems, where import graphs balloon fast. The rest is a standard release summary.