Delegation Is Not Management

A single LLM acting as a team manager tops out below 50% workspace-permission precision, no matter which model you put in charge. That’s the headline result from ClawArena-Team (arxiv.org/abs/2606.31174), a new benchmark of 41 multi-turn scenarios that isolates management skill from raw task-solving by giving the lead model text-only perception and partial workspace access while it commands a fixed pool of subagents. Across twelve proprietary, community, and self-hosted models, API cost spans more than 100x while the overall Subagent-Management Score spans under 4x, and the cheapest open models sit on the Pareto frontier. Most leaderboard scores cluster within a 9.9-point band even as the actual orchestration behavior diverges by an order of magnitude. The bottleneck isn’t perception or reasoning, it’s granting the right subagent the right privilege at the right moment, and nobody’s solved it yet.

Orchestration is cheap to build, expensive to get right

The tooling keeps arriving faster than the management problem gets solved. Sakana AI open-sourced Fugu (github.com/SakanaAI/fugu), a multi-agent LLM orchestrator packaged as a single API call, and Google shipped ADK Go 2.0 (developers.googleblog.com/announcing-adk-go-20) with a graph-based workflow engine, built-in human-in-the-loop primitives, and a unified runtime so single-agent and multi-agent graphs share telemetry and state persistence. Both lower the cost of assembling a fleet. Neither tells you when a fleet is the right call.

Addy Osmani’s “Agentic Autonomy Levels” (addyo.substack.com/p/agentic-autonomy-levels) is the clearest attempt this week at separating the two questions people keep conflating: how far a single agent should be allowed to wander, and how good you are at coordinating many of them at once. He splits it into an agency axis (suggest-and-wait, scoped-task-with-reporting, goal-directed-and-experimenting) and an orchestration axis (one agent one thread, several agents in isolated worktrees, a backlog-driven orchestrator running on management-by-exception). Steve Yegge’s single-axis autonomy ladder was a fine proxy back when delegation was the whole story; it can’t place a team’s coordination skill on top of an individual agent’s trust level, and that’s exactly the axis ClawArena-Team just measured as broken across the industry.

The view from the floor matched the benchmark. Notes from AI Engineer’s World’s Fair circulated this week (via @shloked and @vtahowe, rss.xcancel.com/shloked/status/2073097807804969087) describe a “software factories” track that didn’t exist as a concept six months ago, and a repeated observation that “memory has become a super load-bearing term” broad enough to cover databases, knowledge bases, personalization, and agent continuity under one word. When a term gets that overloaded, it’s usually a sign the underlying capability is still unbundled.

The loop replaces the prompt, but not the verification burden

“Stop Hand-Holding Your Coding Agent” (arxiv.org/abs/2607.00038) gives the mid-2026 slogan, stop prompting your agent and start designing the loop that prompts it, a formal treatment. The authors define a loop specification as a bounded artifact with a trigger, goal, verification step, stopping rule, and memory, distinct from both an ordinary programming loop and the perceive-act-observe cycle a harness already runs internally. Hand-coding fifty real loops from production use, they find the discipline has matured unevenly: 70% verify at the autonomous end of a five-level verification ladder and 74% name their terminal states, but automated triggering and durable memory lag well behind. The paper’s sharpest warning names two failure modes worth remembering: comprehension debt, and “cognitive surrender,” the risk that a well-verified loop still erodes the operator’s own understanding of what the system is doing.

Verification is also where “Steerability via Constraints” (arxiv.org/abs/2607.02389) makes its case, arguing that the decades-old playbook for managing large human engineering teams (access control, network policies, coding conventions enforced by tooling) transfers to coding agents more cheaply than scaffolding-heavy oversight. In a controlled test, a small reviewer model (Gemma 4 e4b) inspecting a Python codebase seeded with 11 backdoors caught 54.5% of them unconstrained and 90.9% once given a constrained substrate plus a roughly 200-line documentation CLI. The authors picked Python deliberately, since substrate-level oversight gains are largest where the language offers the fewest guarantees by default.

Assembled open-sourced the internal system it built to run coding agents as shared team infrastructure rather than individual habits (github.com/assembledhq/143, news.ycombinator.com/item?id=48736251). The problem it targets is mundane and real: engineers running Codex, Claude Code, and OpenCode with their own private MCP connections and personal automations that nobody else on the team could see or audit. 143 runs agent harnesses in gVisor sandboxes, lets teams mix models by cost and task, and wires in GitHub, Linear, Sentry, Slack, and PagerDuty, MIT-licensed and self-hostable. Google’s answer to the same coordination gap is an evaluation product rather than an infrastructure one: a new coding-agent skill that automates a five-stage flywheel of data prep, inference, AutoRater grading, failure-cluster analysis, and targeted optimization against production traffic (developers.googleblog.com/driving-the-agent-quality-flywheel-from-your-coding-agent). Sebastian Raschka’s 36-minute writeup on local coding agents (magazine.sebastianraschka.com/p/using-local-coding-agents) is this week’s most useful ground-level counterpoint: running the harness yourself, on your own hardware, forces you to confront exactly the loop, verification, and memory questions the papers above treat abstractly.

The benchmarks measuring all this aren’t as stable as their leaderboards imply

An audit of three repository-level performance-optimization benchmarks, GSO, SWE-Perf, and SWE-fficiency, replayed 740 code-optimization tasks across four Google Cloud machine types and found that official reference patches hold up under the benchmarks’ own validity rules on only 39 of 102 GSO tasks, 11 of 140 SWE-Perf tasks, and 411 of 498 SWE-fficiency tasks (ui.adsabs.harvard.edu/abs/2026arXiv260701211C). SWE-Perf is the most fragile: many of its reference patches produce close-to-zero runtime change, so the “signal” a leaderboard reports may not exist once you rerun it somewhere else. Scoring rules compound the problem. Among eight submissions shared by GSO and SWE-fficiency, the official leaderboards disagree on 9 of 28 head-to-head comparisons, and SWE-fficiency’s scoring formula hands the ten worst-performing tasks 58.5-82.8% of a submission’s total score weight, meaning a leaderboard position can hinge on how badly you did on the tasks nobody solves well rather than how well you did on the ones people can. Looking across ten public submissions per task, at least one submission matches or beats the reference patch on 85.3% of replay-valid tasks, so the raw capability gap the benchmarks are meant to expose is mostly already closed. What’s unstable is the measurement, not the underlying agent capability the measurement is supposed to track.

Memory systems are learning to know what used to be true

Long-term agent memory has a state-tracking problem that final-answer accuracy hides: old facts, current facts, and the transition between them coexist in a memory bank and get mixed together at retrieval time. A-TMA (arxiv.org/abs/2607.01935) names this failure mode “ghost memory” and proposes keeping superseded records in the bank rather than overwriting them, tagging each retrieved fact as current, historical, or transition so the answering model can resolve conflicts explicitly instead of guessing. On a new conflict-heavy benchmark built for this exact failure, adding the overlay to Graphiti improves conflict accuracy by 0.240 absolute; on the existing LoCoMo long-conversation benchmark, temporal F1 jumps from 0.0295 to 0.1705. The gain is entirely from making state explicit rather than from a bigger model or more retrieval.

A second failure mode is more unsettling: memory can make an agent worse at telling the truth. MemSyco-Bench (arxiv.org/abs/2607.01071) is built to measure memory-induced sycophancy, where a retrieved memory causes an agent to over-align with what the user previously said rather than with current facts or evidence, across five tasks that test whether an agent can reject invalid memory, respect its scope, resolve memory-versus-evidence conflicts, track updates, and still personalize when memory is actually valid. Most memory benchmarks check whether storage and retrieval work; this one checks whether having a memory at all makes the agent’s reasoning worse, which is a different and more uncomfortable question. On the infrastructure side, Elastic open-sourced Atlas (infoq.com/news/2026/06/elastic-atlas-agent-memory), a system built on Elasticsearch that maintains three memory categories with per-user isolation over MCP and reports 0.89 Recall@10 on question-answering, a reminder that most production teams still need the boring version of this problem solved before they need the ghost-memory version.

On the retrieval side, AGE (arxiv.org/abs/2607.00052) tackles a narrower but persistent GraphRAG complaint: graph embeddings and text embeddings for frozen LLMs don’t align well, because graphs are terse and their key nodes carry disproportionate context that’s hard to predict from neighbors alone using standard masked self-supervised learning. AGE’s fix is a learnable node sampler that skips masking the key nodes and focuses prediction elsewhere, and it reports accuracy gains across four GraphQA benchmarks for non-parametric search pipelines specifically. It’s a small paper, but it’s aimed at the exact seam, graph structure meeting text-shaped models, where GraphRAG keeps failing in practice.

What to watch: whether ClawArena-Team’s privilege-granting bottleneck shows up as a named failure mode in the next round of orchestration frameworks, or whether vendors keep shipping graph-based workflow engines without addressing it.