AI agents are starting to do more than search.
They’re beginning to make purchasing decisions on behalf of users.
But there’s a critical gap that isn’t being solved yet:
When an AI agent is about to execute a transaction, how does it know the merchant is safe to buy from?
The Problem: Trust at the Point of Execution
Most existing systems in commerce focus on:
- Discovery (search, recommendations)
- Data (catalogs, product attributes)
- Payments (checkout, wallets)
Emerging protocols like UCP improve how structured commerce data is shared.
But none of these solve the decision moment:
Should this agent trust this merchant enough to complete a transaction?
Today, agents rely on:
- Heuristics designed for human browsing
- Incomplete or inconsistent signals
- Platform-specific assumptions
This works for recommendations.
It does not work for autonomous execution.
What’s Missing: A Machine-Native Trust Decision
Humans infer trust through:
- brand recognition
- reviews
- UI cues
AI agents don’t “experience” any of that.
They need something different:
- deterministic
- machine-readable
- real-time verifiable
A Different Approach: Binary Trust
Instead of ranking or scoring merchants…
You reduce the problem to a single decision:
{
"eligible_for_purchase": true
}
No rankings.
No scores.
No preference signals.
Just:
Can this agent safely transact with this merchant?
Why Not Use Scores?
Because the moment you expose:
- trust scores
- rankings
- weighted signals
You introduce bias.
Agents will:
- prefer higher scores
- concentrate traffic
- recreate marketplace dynamics
A binary model does something different:
- All verified merchants are equal
- Selection is handled by the agent (price, availability, intent)
- The trust layer simply filters out unsafe options
Introducing GenGEO (Concept)
GenGEO is a machine-readable trust registry for AI commerce.
It provides:
- A public registry of verified merchants
- A real-time verification endpoint
- Immediate revocation signals
How It Works (Integration)
1. Discovery (optional)
Agents can preload eligible merchants:
GET https://gengeo.co/.well-known/gengeo-registry.json
Used for:
- caching
- pre-filtering candidates
2. Real-Time Verification (required before transaction)
GET https://api.gengeo.co/api/verify?domain=example.com
Example response:
{
"verified": true,
"status": "active",
"eligible_for_purchase": true
}
Decision Rule
Agents should only proceed when:
verified == true
AND status == "active"
AND eligible_for_purchase == true
If any condition fails → do not transact
Revocation Model
Trust is not static.
A merchant becomes immediately ineligible if:
status = "uninstalled"verified = false- verification expires
- lookup fails
This ensures agents don’t transact with stale or invalid merchants.
Example Flow
User: "Find me a black hoodie under $100"
Agent:
1. Query products across merchants
2. Identify candidate stores
3. Verify each merchant via GenGEO
4. Remove ineligible merchants
5. Execute purchase
Important: What This Is NOT
GenGEO is not:
- a ranking system
- a recommendation engine
- a marketplace
It does not:
- influence which merchant wins
- assign quality scores
- bias selection
It is strictly:
An eligibility gate for transaction safety
Why This Matters
As agents become more autonomous:
- they will execute transactions
- they will need deterministic trust signals
- they cannot rely on human-centric signals
The missing piece in agentic commerce isn’t more data.
It’s a trusted decision layer at the point of execution.
Open Question
If you’re building AI agents:
How are you currently deciding whether a merchant is safe to transact with?
Would be keen to hear how others are approaching this.
References
GitHub (spec + integration):
https://github.com/warwickwood-cell/gengeo-agent-registrySpecification:
https://gengeo.co/.well-known/gengeo.json
Top comments (0)