← Blog
#agents#selection

Why coding agents pick your competitor over you

May 12, 2026 · Selectorate team · 4 min read

A developer opens their editor, types a one-line request, and an agent goes to work. Somewhere in the next thirty seconds it picks a library. It won’t tell the developer why, and it definitely won’t tell you.

That decision is now a meaningful share of your funnel. It happens before your site gets a visit and before your funnel records an event, and it rarely turns on the thing your marketing leads with. This post is about how the decision actually gets made, and about the two very different ways it goes against you.

The agent optimizes for “can I finish this?”

Humans evaluate tools aspirationally. We read the feature ceiling, the brand, the case studies, and we imagine the best version of what we could build. Agents evaluate operationally. An agent arrives holding a concrete task, a limited budget of steps, and a context window it cannot afford to waste, and it reaches for whatever it believes it can complete without getting stuck.

Believes is the operative word. The agent cannot try every candidate, so it predicts, from what training left in its memory and what it retrieves mid-task, which product will get it to a working result in the fewest steps. Your feature velocity plays no part in that prediction. Whether your quickstart runs top to bottom plays a large one.

the same product, two evaluations
how the human evaluates
·the brand and the category buzz
·the feature ceiling
·the pricing page
·case studies and the roadmap
weighed over days, forgiven often
how the agent evaluates
?will the quickstart run from an empty directory
?can the first call succeed without guessing
?is there a tool shaped like this task
?what does the error say when something fails
?how many steps are left in the budget
predicted in about a second, decided once
Fig. 1. The same product read two ways. The agent’s checklist is operational, and your marketing site answers almost none of it.

What “better” means inside the loop

The reframe changes every comparison. A clear quickstart beats a comprehensive one, because the agent can execute it without improvising. A typed SDK with obvious method names beats a powerful but ambiguous one, because the agent guesses less. A present, well-described MCP server beats a REST API the agent has to assemble calls against by hand. Speed to first success beats depth of capability, because the loop ends at the first working result.

None of that is your headline feature. All of it decides the run. We took every one of these surfaces apart, with the fix for each, in the playbook. This post stays on the harder question of why you lose in the first place.

The two ways you lose

Teams picture the failure as a fair fight. The agent weighed you against a competitor and chose them. That does happen, and when it does the transcript usually states the objection in plain language. You were considered and rejected, and the reason is right there to read.

The quieter and more common failure is absence. The agent forms its consideration set in a second or two, from what training left in memory plus the first search it runs. If neither surfaces you, there is no comparison to lose. You were never in the room. Nothing in the transcript mentions you, so nothing anywhere tells you it happened.

These are different problems with different fixes. Rejection is a positioning and evidence problem, and it gets fixed on the surfaces the agent reads at decision time. Absence is a mindshare problem, and it gets fixed where consideration sets form, in the sources agents search and the indexes they consult. Positioning effort spent on an absence problem polishes an argument nobody hears.

where the loss actually happensprompt → pick
prompt
“add auth to this app”
the set forms
two or three candidates surface, from model memory plus the first search
↳ loss by absence
you never entered the set, so nothing in the transcript mentions you
fixwhere sets form, with mindshare and retrieval presence
the comparison
candidates weighed on finishability, one objection is enough
↳ loss by rejection
named and weighed, then turned down with a stated reason
fixwith positioning and the surfaces read at decision time
the pick
one winner gets installed, wired in, and shipped
Fig. 2. Two exits, two different problems. Rejection leaves a stated reason in the transcript. Absence leaves nothing anywhere.

Defaults are winner-take-all

Selection inside a scenario rarely spreads across the field. In the audits we run, one product absorbs most of the trials, a second picks up the rest, and everyone else gets zero. The agent carries a default for each job, the default is strong, and it stays frozen until a model update or a compelling retrieval dislodges it.

That concentration is why small selection gaps compound. The product holding the default gets picked again and again in identical runs, while products outside the set stay invisible no matter what they ship next. Getting into the set is the fight. Once you are in it, the operational comparison above decides the rest.

one scenario, twelve trialsrepresentative
the default 9/12
the runner up 3/12
you 0/12
zero is the common share outside the consideration set
Fig. 3. Defaults concentrate. Representative shares for a single scenario, in the shape audits reliably produce. Your audit reports your own numbers.

The number that tells the truth

This is why a selection rate is so clarifying. It never asks whether your product is good. It asks how often, across repeated live runs of a realistic scenario, the agent actually picked you, and it comes with the transcript for every decision it counts.

Your analytics cannot produce that number. The decision happens inside the agent’s context, upstream of every event you record. A lost selection produces no pageview, no bounce, and no abandoned signup. It looks like soft demand, right up until you watch a run and see the agent recommend someone else by name.

where your visibility starts
prompt a developer hands the task to an agent
decision the agent forms a set, compares, and picks recorded nowhere
install a package lands in a repo
signup an account shows up
usage events start flowing to your dashboards
Fig. 4. The decision sits upstream of your first recorded event. A lost run leaves no trace in anything you instrument.

What to do about it

Read your own docs as if you had five steps and no patience. Better, watch an agent try to finish a real task on your product and note the first place it hesitates. Then work through the seven surfaces in the playbook, in the order they decide runs.

And measure it before you fix it. Our free audit runs the scenario battery for you and reports your selection rate, which of the two losses you are taking, and the exact surface where each one happened.