The agent channel · measured
The agent weighed three options.
Yours wasn't one of them.
Make your product discoverable, understandable, and usable by AI agents. Selectorate measures how agents find, evaluate, and use your product, then rebuilds the docs, schemas, and MCP servers that drive the decision.
tested across claude code · cursor · codex
The problem
You optimized for humans and search engines. The buyer changed.
Every dashboard assumes a human made the decision. Increasingly, that decision is made by an AI agent, and it never shows up in your funnel.
Agents are the new decision-makers
AI agents increasingly decide which tools developers use. They search, compare, install, integrate, and move on, often without a human reviewing every option.
Your analytics never see those decisions
Traditional analytics stop at the developer. They can't tell you which products an agent considered, why it rejected yours, or where it switched to a competitor.
Small friction becomes lost adoption
A missing example, an unclear schema, or a confusing setup step is enough for an agent to move on. Unlike humans, agents rarely retry or ask for help. They simply choose something that works.
How it works
The system behind the score.
We built infrastructure that watches agents make buying decisions: isolated environments, orchestrated agent fleets, full-trace instrumentation, and verification against live deployments. Then we use what it finds to change the outcome.
Watch the decision happen.
The agents your customers use, on unscripted tasks, with zero prompting toward you. The system records everything.
Scenario engineering
We model the buying scenarios your customers hand to agents: the task, the constraints, the stack. The prompt never names you. The agent discovers, compares, and chooses on its own.
Isolated, orchestrated runs
Every run executes in a clean, isolated environment: no history, no cache, no cross-contamination between runs. Our harness orchestrates sub-agents across Claude Code, Cursor, and Codex, repeating each scenario across enough runs for statistical confidence.
Full-trace instrumentation
Agents run under instrumentation: every search, doc fetch, tool call, and install attempt is captured. We record the consideration set, the rejection reasons, and the switch moments.
Deploy-verified decisions
What the agent built gets deployed and exercised: which product is wired in, whether the integration runs, whether it survives live calls. Decisions are scored on running code.
Two scores: selection × execution
Selection: how often agents choose you over named competitors. Execution: how often they succeed with you once chosen. Every failure classified by cause, every number linked to its runs.
Change what agents see.
Different failures need different surgery. The audit tells us which.
Selection fixes: GEO, SEO & positioning
If agents never consider you, we fix how they find you: GEO for what models know, SEO for the queries agents issue mid-task, and the positioning that puts you in the consideration set before a single doc is read.
Execution fixes: the surfaces agents read
If agents pick you and stall, we rebuild what failed them: docs, quickstarts, tool descriptions, schemas, error messages, MCP servers. Ranked by expected impact on your numbers.
Re-run. Same system.
The pipeline that found the problem verifies the fix.
Before / after, same instrument
Fresh isolated runs of the same scenarios. You get the before/after selection and execution rates, with the transcript for every delta.
Continuous re-measurement
Models update, competitors ship, selection rates drift. On retainer, the pipeline runs monthly: fresh scores, new failure modes, and the next ranked fix list.
What you get
Two engagements, one system.
The pipeline above is packaged as two services: the audit measures, the retainer fixes and proves.
How agents evaluate you today: selection and execution, scored on deploy-verified runs. Representative benchmark below; your audit reports your own product's numbers.
Selection rate: how often agents picked you over a competitor
240 runs · 3 agents
Runs where the agent picked you but your setup silently failed
auth · schema · docs
Prioritized, specific fixes, ranked by selection-rate impact
tool descriptions · MCP · docs
Every number links to the run that produced it: the full transcript and the deployed result. Open the run, see the decision.
We execute the fix list, then the pipeline re-runs and reports the movement. The audit finds the gap. The retainer closes it and proves it.
GEO, SEO, and positioning: the signals that put you in the agent's consideration set.
Docs, schemas, tool descriptions, and MCP servers, rebuilt so agents finish what they start.
Monthly re-runs of the same scenarios, with before/after rates and a refreshed fix list.
A report without execution is homework.
GEO tools tell you where you stand in ChatGPT and Claude, then the work lands back on you. Selectorate owns the measurement and the execution as one system.
Selection is half the job.
Getting chosen puts the agent at your front door. Keeping the customer depends on whether the agent ships working code with you. We score both, and we fix both.
Who it's for
Built for the teams agents reach for first.
If your buyer is a developer (or increasingly, the agent working on that developer's behalf), the agent channel is already deciding your win rate. We help you see it and move it.
Free audit
See exactly how agents evaluate your product.
We'll run the pipeline against your product and send you a first read, free of charge: where agents pick you, where they pass, and the transcripts behind it. No access to your code required. The complete audit and the retainer take it from there.