The week’s pattern is that agent output has outrun the machinery around it. Anthropic rebuilt source control because Git could not keep up with its merge rate, one practitioner replaced a prose rule with a hook that fails the commit, and a new benchmark asks whether an agent-built agent does what was asked. If agents write most of your code, the surrounding systems need the same engineering as the agents themselves.
Anthropic replaced Git because the merge rate changed
Anthropic’s engineering post on redesigning source control, covered by Simon Willison, puts numbers on the shift. In May 2026 the company averaged about 2,500 code changes merged per day. By September it was over 30,000. The post says main branch history is close to 100 GB, and CI alone performs roughly 25 million checkouts a day, before counting developer environments, agent sandboxes and research jobs. A naive Git fetch at that scale, the authors estimate, would move over 600 PB a day.
Their answer is a custom system called Scion and a code review system called Antique, built by a team of seven over a migration of about five months. One design choice stands out: offline support was dropped because Claude is the heaviest user and is always online. Willison suspects more capable models drove much of the velocity increase; the post’s chart marks public release dates, so that link is his inference, not Anthropic’s finding.
Most teams are nowhere near this scale, but the direction applies. The Concurrent Agent Isolation Framework asks what breaks when many writers share one tree, and The Maintainability Debt Curve asks whether throughput is degrading the substrate. Both questions arrive sooner than the migration does.
A hook beats a rule file
In a post quoted by Willison, Geoffrey Huntley describes an agent that sometimes ignores his diagnostics library. He could update AGENTS.md, but the file drifts from reality. Instead he wrote a pre-commit hook that scans the git diff for direct calls to observability modules that bypass the diagnostics module, fails the commit, and injects a prompt telling the agent to use the library. His result: ten out of ten.
That is one practitioner’s report on one task, not a measurement. The mechanism is the useful part. A prose instruction is a request. A hook is a gate that reads the actual change, and its failure message doubles as the correction. This is The Intelligence Loop in a few lines of shell: a recurring agent failure becomes a permanent check instead of a reminder. Pair it with The Human Gate Protocol when the failure is expensive enough that a person, not a script, must decide.
Where the human sits matters more than how many gates exist
Latent Space’s write-up of autonomy and safety for financial agents from AI Engineer New York has one lesson: safe autonomy depends on where controls and human judgment are placed, not on how many restrictions you impose. Two Sigma’s John Feminella warned that approval fatigue, a person approving everything, slows work and can add risk. Two Sigma uses composable controls that each do one job, with deterministic rules for clear cases and classifiers for ambiguous ones, so that people see only the most important requests.
Bloomberg’s Andrey Rybka listed the defenses: scoped identities and credentials, tool-call controls, outbound traffic restrictions, audit trails, budgets and kill switches, enforced deterministically outside the model, with every call checked and logged. He also cited an incident in which an agent treated instructions hidden in a marketplace review as a command to stock a product. Anthropic’s Keon Shahab described a trust layer of identity and permissions, a sandbox with an approval layer, and ongoing checks that the agent still works when variables change.
These are conference talks from vendors and operators, so read them as design input rather than evidence. They fit the Autonomy Calibration Ladder: graduate autonomy by task risk and observed behavior, and spend human attention where it changes the outcome.
AgentSWE asks whether the agent you got is the agent you wanted
AgentSWE, at 215 upvotes on Hugging Face Daily Papers, targets a growing practice: commissioning coding agents to build agents fitted to a user’s workflow. The authors’ concern is a quiet assumption, that the delivered agent will serve the requirement rather than merely appear to. Their benchmark has 25 tasks across three stages, creating an agent from a natural-language requirement, editing production agent codebases, and optimizing toward a measurable target, each framed as a commission rather than a coding exercise.
I have only the abstract, so I will not quote results. The framing is the contribution. An agent that passes a demo but does not serve the requirement is exactly the gap The Verifier Gaming Surface Framework audits: where can the agent defeat the gate instead of doing the work? When one agent builds another, the acceptance test has to come from outside both.
Thinking modes that do not switch off
Thinking Inertia (232 upvotes) studies the opposite of a thinking mode: what models do when told not to think. The authors argue common proxies, such as a disabled thinking mode or a short trace, are unreliable, because disabled modes may still emit reasoning and long traces may be filler. They instead split each response into a pre-answer trace and a final answer, and score it with measures such as an Empty-Thinking Rate for strict answer-only compliance. The abstract is truncated in my source, so I cannot report their findings.
The practical takeaway is narrow. If your cost or latency budget assumes no reasoning tokens, verify that from the response, not from the setting. That is The Token Budget Framework: cost is an engineering input you measure.
The throughline
Each item moves a check out of the place where it can drift. A hook replaces a rule file, deterministic controls replace blanket approvals, and an outside acceptance test replaces the agent’s own report. The field is converging on the same point: reliability is built into the system around the agent.
The frameworks behind these controls are laid out for engineers at curiochat.ai/software-engineer/.