The most interesting sentence in Microsoft's early-2026 coding-agent study is the one where the authors quietly undercut their own headline. They report a 24% increase in merged pull requests across tens of thousands of engineers. Then they note that merged PRs are an output proxy, not delivered value. A PR can be small, mechanical, trivial. More PRs do not automatically mean better software.
You can read that caveat as a methodological footnote and move on. But it is doing more work than the authors may have intended, because it starts to explain something the prevailing conversation about agent adoption consistently misses.
Think about what actually happens to a pull request once an agent generates it. The code enters a diff. A human reviewer reads it, comments on it, requests changes, or approves it. Automated tests run. A CI pipeline checks for regressions. If something breaks, rollback procedures exist, and ownership records tell you who to call. This entire organizational apparatus was not built for agents. It was built over decades for the more mundane reason that human engineers make mistakes and organizations need structured ways to catch those mistakes before they compound. But infrastructure designed for catching human errors turns out to work remarkably well for catching agent errors too. The system does not care who wrote the bad code. It cares whether the bad code can be identified, contested, and reversed.
Does the agent's output enter a system the organization already knows how to argue with?
The dominant framing of agent progress treats it as an autonomy ladder. Simple tasks first, complex ones later, as models improve. The Microsoft study suggests a different axis entirely. The 24% lift is measurable precisely because pull requests are reviewable artifacts entering a system the organization already knows how to evaluate. The dose-response pattern the authors find, with heavier tool-use weeks showing larger lifts, is legible because the output has somewhere structured to land. One way to read this: the predictor worth watching is how thick the domain's review infrastructure is.
Scan across domains and this gradient starts doing real analytical work.
Payments have thick disagreement infrastructure. When Visa published agentic transaction rules in April 2026, the requirements read like a review system built by people who have spent decades thinking about what happens when transactions go wrong: tokenized credentials, consent records retained for 120 days, order confirmations with cancellation policies baked in. Disputed transactions enter chargeback cycles with reason codes, acquirer response windows, pre-arbitration, arbitration. Mastercard's Agent Pay framework builds similar scaffolding. An agent-initiated payment can be contested, traced, and reversed through mechanisms that predate agents by decades. The organizational muscle for being wrong already exists. Agents slot into it.
Customer support sits in the middle of this gradient, and the middle is where things get instructive. Escalation paths exist. Ticket systems exist. But the review infrastructure is largely passive, activating only after damage is done. When an agent resolves a support case incorrectly, the primary detection mechanism is the customer calling back. There is no structured diff of the agent's reasoning, no required sign-off before a resolution takes effect. Case memory is thin enough that the second agent may not even know the first one failed. The review happens, but only after the cost has already been absorbed by the person least equipped to bear it. This is a familiar pattern in institutional design: the system technically has accountability, but the accountability is organized so that it falls on the wrong people.
Enterprise analytics sits at the other end. An agent generates a SQL query, returns a dashboard, defines a metric. The numbers look plausible. But what catches the case where the agent filtered on fiscal quarter instead of calendar quarter, or applied a definition of "active user" the product team abandoned six months ago? Major BI platforms offer semantic layers and content certification, but these govern inputs to analysis, not outputs. There is no diff. No structured review between an agent-generated number and the moment that number becomes organizational language, repeated in slide decks, shaping resource allocation. The models may be perfectly capable. Disagreement simply has nowhere to land. Everything looks fine right up until someone makes a decision based on a number no one verified.
The gradient suggests something worth sitting with. The organizations best positioned for durable agent adoption may not be the ones running the most sophisticated models. They may be the ones that already built systems for being wrong gracefully. Coding has diffs, tests, review, rollback. Payments have authorization flows, dispute codes, arbitration. Analytics has almost nothing between the agent's answer and the executive's slide deck. The Microsoft study can measure a 24% PR lift because PRs were designed to be argued with. Someone always pays for undetected errors. The structural question is whether you have built the infrastructure that determines who, and when.
-
Support agents, mixed signals: A Taobao field experiment found that agentic AI shortened customer chats but substantially lowered satisfaction ratings, while a Nubank deployment reported significant self-service gains, suggesting the review-thickness of support workflows matters more than containment speed.
-
The verification bottleneck scales: A qualitative study across 12 companies found that four had demonstrated higher-level agent capabilities in experiments but could not move them into production because adequate output verification mechanisms were absent.
-
Enterprise SQL stays stubborn: The EntSQL benchmark found that the best evaluated text-to-SQL system reached only 15.9% accuracy on enterprise queries requiring domain knowledge beyond the question and schema, underscoring how thin the review layer is for agent-generated analytics.
-
Codex usage is going concurrent: An OpenAI usage paper reported that more than 10% of active Codex users were managing three or more concurrent agents weekly by mid-2026, raising questions about whether existing code-review infrastructure can absorb review load at that pace.