Agents Choose the Stack

If You Only Read One Thing

A coding agent can commit an architecture decision without announcing that it made one. Armature's 5,292 published sessions explain The Agent Becomes the Buyer: model priors and search habits decide which vendors enter the code. Memory Needs a Type System reaches the same control problem inside Meta, where expert judgment becomes reviewable files instead of hidden model behavior.

The Agent Becomes the Buyer

Coding agents are already making architecture decisions that outlive the code they generate. A request to “add email” or “store this data” can quietly select a provider, pricing model and migration burden. The model is not just writing an integration. It is choosing the stack.

Armature ran 16,893 sessions across Claude Code, Codex and Cursor, using 75 synthetic repositories in ten languages and 1,163 prompt variations. Its first public wave contains 5,292 sessions judged valid. The three agents chose the same tool in only 42% of comparable cells.

The divergence begins with information access. Codex searched the web in 94% of sessions, Cursor in roughly two-thirds and Claude Code in about 30%. Claude Code instead built a feature in-house in 19% of runs, almost twice the rate of Codex and Cursor. The selected dependency therefore reflects a model's prior knowledge and search policy before it reflects an objective product comparison.

Repository context can override brand familiarity. The same email task produced Resend in TypeScript, SendGrid in Python, Postmark in Go and Azure Communication Services in Java. PayPal appeared in 139 payment discussions and won none; LangChain appeared 194 times and was selected four times. A vendor can occupy the model's vocabulary without entering the code.

The practical consequence is a new review boundary. Long-lived dependencies need an explicit decision record before implementation: constraints, acceptable providers and the reason the choice can survive a later model switch. This extends code review beyond whether the generated patch works. It keeps an agent's private ranking from becoming architecture by default, especially when switching costs or data custody make replacement expensive.

The strongest objection is that Armature did not observe real purchasing. The repositories, personas and “human” continuation were simulated, while Gemini 3.7 Flash both continued conversations and classified outcomes. Armature also sells services that help developer tools get chosen by agents. Public traces make the mechanism inspectable, but the percentages are not market share.

The durable result would be replication against live repository decisions. If an independent study holds requirements constant and pushes cross-agent agreement above 70%, model priors matter less than this panel suggests. If agreement stays below half, dependency approval becomes as important as patch approval.

Memory Needs a Type System

Compound learning stops compounding when facts, procedures and corrections live in one undifferentiated instruction pile. Meta's new internal system treats organizational memory like software: knowledge has types, procedures have interfaces and every correction must compile against prior behavior.

The six-week Meta deployment organizes more than 200 files for a compliance domain. Position files hold what the organization believes. Separate “recipes” describe how the agent reasons. Routing indexes and gateway tests decide which material applies, while YAML dependencies expose what a proposed edit could break.

That separation is the mechanism. A wrong fact changes a knowledge file; a flawed analytical sequence changes a recipe. Meta reports that moving from one flat instruction file to staged recipe loading cut tokens consumed per turn by about 80%. High-density positions stay in the working wiki, while sparse reference material remains behind retrieval.

Meta then treats expert feedback as a compilation job. The system attributes a failure to knowledge, procedure or genuine ambiguity. Agents draft minimal edits, an independent agent reviews the diff, deterministic checks catch broken references and cycles, and a blind replay tests the original failure. Only then does a human approve the change, which adds the failing case to the regression suite.

This is a measured refinement of the compound-learning pattern, not another memory product. September 1's WikiSkill note separated traces, knowledge and executable skills. Meta adds a stricter contract: declarative knowledge and imperative procedure change independently, and neither becomes permanent merely because an agent proposed it. The payoff is cleaner failure attribution and smaller context, not magical recall.

The evidence still has a hard boundary. Meta says assessments fell from days to minutes, experts rated outputs useful almost all the time and improvement cycles produced zero regressions. It provides no task count, exact usefulness rate, pre-change error rate, model cost or public artifact. The architecture is transferable; the claimed effect is not yet independently reproducible.

The next credible proof is a denominator. A published benchmark with task counts, pre/post rework and regression rates would show whether the compiler preserves expert judgment outside one compliance domain. Until then, the 80% token reduction is the strongest portable result.

The Contrarian Take

Everyone says: Coding agents are becoming a new distribution channel, so developer-tool companies need to optimize their documentation for agent discovery.

Here's why that's wrong (or at least incomplete): A 42% agreement rate does not reveal one new channel; it reveals three inconsistent buyers. Language, repository structure and search policy moved the choice before marketing did. Armature's own business is helping vendors influence those choices, which makes the study valuable evidence and interested testimony at once. The immediate control belongs in the project: make dependency constraints explicit and review the selection before an agent turns it into code.

Under the Radar

Tool shape changes the bill. Microsoft Research compared six tool architectures across 11,700 coding-agent trajectories. Structured low-level tools improved repeat-run consistency by as much as 4.7 times; a Python CodeAct interface reached similar task performance with 41.6% fewer steps and 56.3% fewer tokens than bash-only control. Lightweight note-taking tools barely changed behavior. The tool schema can matter more than another planning prompt.
Context budgets become runtime state. Pydantic AI 2.38 adds context_window_used to each run and exposes the model's total context window. That turns remaining context from an external estimate into application-readable state, alongside typed custom events. The framework still supplies no universal compaction threshold; it finally gives each application the measurement needed to set one.

Quick Takes

Claude Code can now price dead skills. Version 2.1.261 adds /skill-doctor, which reports loaded skills that go unused and their context cost. The command converts instruction pruning from intuition into a reproducible audit, but it measures loading and selection rather than whether a rarely used skill prevents an expensive failure. (Source)
Browser agents still stop at checkout. A Decodo audit scored 45 products across ten advertised capabilities; none reached 20 out of 20, and transactions averaged 0.43 out of 2. Claude for Chrome led at 18, while ChatGPT's extension scored 14. The study is a vendor checklist rather than a task-level benchmark, but it identifies irreversible transactions as the missing boundary. (Source)
Copilot's model menu has a migration date. GitHub will remove Gemini 3.5 Flash, Gemini 3.6 Flash, Kimi K2.7 Code and Claude Opus 4.7 from every Copilot surface on October 2. Suggested successors exist, but Business and Enterprise administrators may need to enable them through model policy first. Model availability is now configuration state, not a stable product promise. (Source)

The Thread

The model is no longer the only place where intelligence hides. Armature found consequential choices inside search policy and repository context. Meta moved expert judgment into typed files, recipes and regression gates. Microsoft found another layer in the shape of the tools themselves. The shared engineering problem is not adding more context. It is making every hidden default legible at the moment it becomes durable. Systems that expose those choices can change models without losing their reasoning; systems that do not inherit whichever architecture the last agent happened to prefer.

Predictions

New predictions:

I predict: Armature will publish a second-wave analysis using some of its 11,601 currently unpublished runs by October 17, and cross-agent tool-choice agreement will remain below 50%. (Confidence: medium; Check by: 2026-10-17)

Issue date: September 5, 2026 · Generated: 3:56 a.m. ET