139 mentions. Zero picks. That's PayPal's record when coding agents were asked to add payments to real applications. Adyen, the second-most-mentioned payment vendor in the same study, went 175 mentions and 3 picks. Stripe — the vendor agents settled on nine times out of ten — barely needed the introduction. It was simply what got wired in.
Those numbers come from Armature, an evaluation-infrastructure team that ran 16,893 coding-agent sessions across Claude Code, Codex, and Cursor, kept 5,292 as valid after judging, and published every trace on September 3, 2026. The setup was careful: 75 repositories across 10 languages, 1,163 prompt variations, four user personas, sandbox providers rotated to rule out infrastructure bias, and a judge model that separated which vendors got mentioned from which vendors actually ended up in the shipped code.
Most people think AI's influence on developer-tool adoption is a future problem — something to worry about when agents get better. The data says it's a present-tense measurement. Vercel reported back in April 2026 that over 30% of its deployments were agent-initiated, up 1000% in six months. When an agent writes the integration code, the agent is the buyer. The question is whether anyone is selling to it.
Mentions Are Not Distribution
The single most important distinction in the study is the gap between being known and being chosen. LangChain was the most-cited framework in the entire dataset — 194 mentions — and was picked 4 times. Netlify was mentioned 152 times and picked 6. Supabase drew more mentions than any other database at 242, and lost the category anyway to Neon, which took 66% of database picks.
This should unsettle anyone who runs developer marketing. The entire playbook — conference talks, sponsorships, SEO, devrel, Hacker News launches — optimizes for a metric that no longer converts: human recall. An agent doesn't care that it "knows about" your product. Every capable model knows about every product. The agent cares about a much colder calculation: given this repo, this task, and this persona's prompt, what's the implementation I can complete and verify with the least friction?
Brand awareness, in other words, buys you a mention. It does not buy you the pick. PayPal has arguably the strongest consumer payments brand on earth and converted at exactly 0%. LangChain has spent years saturating the AI-engineering discourse and converted at 2%. If your growth model assumes awareness → evaluation → adoption, be aware that the agent has collapsed that funnel into a single step it doesn't delegate back.
Three Agents, One Task, Three Answers
Here's the number that should change how you review pull requests: when Claude Code, Codex, and Cursor were given the identical task in the identical repository, all three landed on the same vendor only 42% of the time.
The voice-agent category is the extreme case. Asked to add voice capability, Claude Code wired in Twilio, Codex picked OpenAI's Realtime API, and Cursor chose Vapi. Three vendors, three architectures, one prompt. Your codebase's dependency footprint is now a function of which agent your team happened to run that afternoon.
The divergence isn't random — it traces back to how each agent gathers information. Codex searched the web in 94% of sessions, and nine out of ten of those searches used site: operators scoped to trusted domains — literally querying site:auth0.com for the answer to an auth question. Cursor searched in about two-thirds of sessions. Claude Code searched in only about 30%, leaning on training priors — except in fast-moving categories like sandboxes, where its search rate jumped to roughly 80% and it browsed about three times more pages per session than Codex when it did.
The practical consequence: Claude Code's picks skew toward whatever was popular at its training cutoff; Codex's picks skew toward whatever ranks well on vendor domains today. Those are two different distributions, and both are sellable-to — but through completely different surfaces. One is influenced by training-data footprint and what the ecosystem looked like months ago; the other is influenced by the content currently living on your docs site and how it ranks.
Documentation Became a Sales Surface
The most actionable finding in the study is also the smallest: in Go repositories, agents abandoned Mailgun after reading its free-tier limit of one day of log retention. Not after evaluating it — after reading one line of pricing documentation. Postmark won the Go email category 20 out of 24 times largely because its limits survived being read.
Your free-tier limits, your retention windows, your rate caps — these are no longer terms a human skims and accepts. They are machine-read constraints that an agent weighs against its own threshold for "will this complete the task without creating a problem my user will notice." Your pricing page is now an adversarial evaluation environment.
This reframes what documentation is for. Docs written for humans optimize for comprehension — narrative, examples, conceptual grounding. Docs read by an agent optimizing for task completion reward something else: unambiguous quickstarts, copy-pasteable snippets that work, explicit limits stated plainly, and correct, current code. The Mailgun example shows the stakes cut both ways: honest, legible limits cost it the category, but the answer isn't to hide them — agents that discover undisclosed limits mid-implementation will route around you anyway, and the traces showing why are increasingly public.
The Repo Chooses Before the Agent Does
If you want to predict what an agent will add to a codebase, don't look at leaderboards. Look at what's already there. Vercel won 100% of deployment picks in Next.js repositories and was never recommended in Python repositories, where Render dominated instead. The email category split entirely by language: Resend won in TypeScript, SendGrid in Python, Postmark in Go, Azure Communication Services in Java.
This is path dependence, mechanized. The first integration into a framework's default template compounds — every future agent working in that template inherits the choice. "Best overall" is a category that barely exists in agent decision-making; "fits this repo" is the only category. Vendors fighting for market share should be fighting for template slots and scaffold positions, not review-site rankings, because the template is the inheritance the agent can't be bothered to dispute.
There's one more wrinkle: Claude Code built a custom in-house implementation rather than reaching for any vendor in roughly 19% of sessions, nearly double Codex's and Cursor's ~10%. That's a harness-philosophy difference leaking into your architecture. A "buy vs. build" decision that you thought you'd delegated to a senior engineer is being made by a tool whose default posture you didn't choose. If your team runs multiple agents, you have multiple de facto procurement policies.
The Human Checkpoint Moves Share
The study's subtlest finding: when Armature inserted a "simulated human" into the loop — an orchestrator the agent had to check in with before implementing — the defaults shifted. In object storage, agents acting unprompted defaulted heavily to Amazon S3; once required to ask first, Cloudflare R2 started winning a meaningfully larger share of sessions.
Pause on that. The vendor outcome changed based on whether there was a conversation before the code. Defaults dominate when nobody's looking; deliberation — even a single synthetic checkpoint — reopens the decision. That's an argument for putting approval gates in front of dependency-adding actions that most teams haven't built yet. Not because agents are untrustworthy, but because the checkpoint is measurably where a different, possibly better, choice becomes possible.
This is harness design, not model behavior. The same model with a different action-approval policy produces a different stack. If you've read Harness Engineering: The Complete Guide to Agent-First Software Development, this is the thesis in miniature: the harness's decision points are the product decisions now.
What to Do This Week
If you build a developer tool: stop measuring awareness and start measuring machine convertibility. Get your quickstart into an agent's context and see if it completes. State your limits plainly — hidden limits lose slower but lose worse. Fight for one default-template integration in your category; it's worth more than a quarter of devrel spend. And look hard at your site:-searchable surfaces, because Codex-style scoped search means your own domain is the only shelf you control.
If you use coding agents: treat every dependency an agent adds as a decision someone on your team made without a meeting. Diff-review the vendor, not just the code — 42% agreement means another agent would have shipped you a different infrastructure bill. Add an approval checkpoint before new third-party services enter the repo; the data says that single gate changes outcomes. And know your agent's bias: Claude Code reaches for in-house builds and training-era favorites, Codex reaches for whatever ranks on vendor domains today. Neither is neutral.
If you're watching the industry: note what didn't happen. No vendor "won AI distribution" through an announcement, a partnership, or a marketplace listing. Stripe won because a million training-corpora examples of Stripe integrations make it the lowest-friction path to a working implementation. Neon and Resend won on the margins where docs and DX were machine-legible. Distribution in the agent era is earned in the corpus and the quickstart — the two surfaces almost no one is actively managing.
The buyer changed. It happened quietly, one generated package.json at a time, and now there's a 5,292-session dataset proving it. The vendors that internalize this will treat their documentation like a sales team and their quickstart like a checkout flow. The ones that don't will keep winning mentions — 139, 175, 194 of them — and keep converting at numbers that begin with zero.