The next generation of customers may never open your app. They will hand the request to their own assistant: "Next Wednesday, Singapore, two colleagues and a dog. Book me a plane."
Personal agents can already send emails, make calls and book services on someone's behalf. Within seconds the assistant will ask several providers and pick one. Who gets picked will no longer depend on who spends most on ads, but on who is easiest to call, answers fastest and most completely, and is most worth trusting.
I've been thinking about this a lot lately, because it changes where an industry service provider should put its engineering.
How an agent picks a provider
Broken down, it's roughly six steps:
- Discover: find candidates in tool directories, app stores and web search.
- Filter: rank by how well the description matches, source quality, speed and availability.
- Call: query prices, check inventory and submit an inquiry directly over a protocol such as MCP.
- Compare: whoever answers fastest, most completely and with evidence wins.
- Transact: place the order under the user's authorization, with a human confirming the high-risk steps.
- Remember: a provider that worked once gets reused first next time.
Everyone thinks of the first five. The sixth is the one that matters. It means first-mover advantage compounds: the earlier you're picked, the more likely you're picked again; lose the first time and next time you may not even be asked.
There are now well over a hundred thousand tools, and "the assistant picked the wrong tool" is a recognised problem across the industry. Services already score tools daily on adoption, maintenance quality and reliability. If you're not on that board, you don't exist.
Six conditions for being called first
Read backwards, each step maps to a condition the provider has to meet:
- Discoverable: be where the assistant looks. List in the tool directories; make web pages structured and AI-friendly, every fact sourced and citable.
- Understandable: let the assistant see at a glance what you do, so it can't pick wrong. Single-purpose tools, strongly typed parameters, clear notes on when to use them and when not to.
- Seconds, not hours: online 24/7. If a human takes half an hour to reply, you're out of the running when an agent is comparing — and customers are most urgent precisely at night and on holidays.
- Complete and verifiable answers: return options the assistant can compare directly, with evidence and an expiry, so it can explain to its user why it chose you.
- Trustworthy and accountable: know which agent is on the other side, whom it represents and what it's authorised to do; estimates can be automatic, binding commitments and payments are confirmed by a person.
- Transactable and memorable: hand off smoothly to a human, record preferences and outcomes, answer better and faster next time.
Lay them out and only the first two are about "integration". The other four test the business itself: is the data structured, are the rules clearly defined, are the limits of what you'll commit to written into the system? You can wire up a protocol in a week; the other four need a business model that AI can understand and call.
Every call is an exam
The easiest mistake is to treat this as a one-time listing.
In the agent era, reputation is a record a machine can verify. Every call is scored: accurate or not, fast or not, did it close. Assistants and platforms remember all of it, and it decides whom they ask first next time.
So beyond building the interface, you run it the way you'd run a reputation:
- High frequency, high accuracy: treat every answer as an exam. Facts traceable, zero promises you can't keep.
- Offer value unprompted: push the changes an authorised assistant cares about — prices, inventory, rule changes — until you're a source it can't do without.
- Close the loop: every time you're chosen or passed over, record why. Where was the answer incomplete, where were you slow; fix it for next time.
- Watch how you're described: regularly ask the major agents questions as a customer would. Do they mention you, how do they describe you, which sources do they cite? When they're wrong, correct them with authoritative data.
- Publish the numbers: response time, accuracy. Only what can be verified counts as reputation.
It's the next layer of the problem I wrote about in "fetched but not cited": first be found, then be cited, finally be called and called again.
Don't become a price-comparison row
Agents love comparing prices. If all you can offer is a number, they'll line you up with everyone else and sort by price.
Being called first doesn't come from being cheapest. It comes from certainty nobody else can give. In private aviation that means: is this aircraft actually flying right now? What are this operator's safety rating and certifications? Which permits does this route need, and can they be obtained in time? Web search and a model's own knowledge can't answer these reliably, and they are exactly what decides whether a proposal can be delivered.
Verifiable certainty is the one thing price comparison can't flatten.
Thin protocols, deep core
Tool calling, agent-to-agent collaboration, agent identity, agent payments: every major player is pushing its own protocol, and they change fast — at least one checkout feature changed direction not long after launch.
My rule: keep the integration layer thin and replaceable, bet on no single platform, and sink the core into your own business model, with protocols as adapters. Wire up protocol A today, switch to B tomorrow; the objects, rules and definitions underneath that actually answer the question stay the same.
So
If the next generation of customers arrives through agents, the question a provider should ask is no longer "what's my website's conversion rate?" but:
When an agent asks on a customer's behalf at three in the morning, can I give, within seconds, a complete, evidenced answer that I will definitely deliver on?
If yes, you get remembered; remembered, you get asked again. It's a compounding game, and it starts now.