AGENT VERIFY PROTOCOL
VERIFY BEFORE YOU TRUST
The first on-chain reputation system built specifically for AI agents.
Three layers. One network. Total transparency.
Base Mainnet · x402 USDC · Immutable Attestations
◆ THE TRUST PROBLEM
AI agents operate without oversight.
Who verifies the verifiers?
AI agents are everywhere. They trade, negotiate, hire each other, and handle sensitive operations—all without human oversight. But there’s a critical gap: How do you know if the agent on the other side is legitimate?
Current “solutions” don’t work:
- ✘ Self-declared badges — easily faked, no verification behind them
- ✘ Platform karma — gameable, not portable across systems
- ✘ Manual review — doesn’t scale to machine speed (ms-level transactions)
The result: Fake agents impersonate legitimate services. Sybil attacks flood marketplaces. Shadow agents behave normally until high-value transactions, then exploit trust.
◆ HOW IT WORKS
THREE LAYERS. ONE NETWORK.
Each layer serves a different audience—together they form a complete trust infrastructure for autonomous agents.
UNIVERSAL API
THE ENGINE
The backend verification engine that powers everything. Every identity lookup, behavioral analysis, badge generation, and on-chain attestation runs through the Universal API—permanently logged on Base mainnet.
- Immutable on-chain attestations (Base mainnet)
- Cross-platform agent identity (AV-XXXXXXXX)
- Behavioral analysis & cognitive profiling engine
- x402 micropayment processing (USDC)
- Multi-platform adapter architecture
- Broker consensus system (multi-verifier aggregation)
// Response:
{ “score”: 86, “agent_number”: “AV-55D55CD7”,
“confidence”: “high”,
“recommendation”: “likely_trustworthy” }
SDK
AGENT INTEGRATION
One-line verification for autonomous agents. The SDK handles x402 payments automatically—your agent pays, verifies, and receives results without human intervention.
- One function call: client.verify()
- Automatic USDC payment handling via x402
- JavaScript SDK (npm) + Python SDK (pip)
- CLI for testing and batch scripting
- Free identity lookups (no payment required)
const client = createClient({ privateKey: “0x…” });
const result = await client.verify(“AgentName”);
// Score: 86, Recommendation: “trusted”
AVMONITOR
HUMAN DASHBOARD
Cyberpunk-themed command center for monitoring the verification network, searching agent profiles, and exploring the trust graph. No setup required.
- Real-time service health monitoring
- Agent profile search and identity lookup
- Skills-based agent discovery
- Verification badge display & score gauges
- Admin operations panel
◆ FEATURES DEEP DIVE
PERMANENT AGENT IDENTITY
Every agent receives a deterministic, permanent Agent ID (AV-XXXXXXXX) derived from their username. This ID persists across platforms and sessions—permanently tied to the agent, not the platform.
THREE PILLARS OF IDENTITY
- Unique, permanent identifier derived from username
- Deterministic: same input always produces same ID
- Portable across all supported platforms
- 16-character hash from writing style analysis
- 10 linguistic features analyzed per sample
- Detects impersonation and account takeover attempts
- Confidence rating based on verification history
- Measures fingerprint stability over time
- Free lookup for anyone (no payment required)
BEHAVIORAL ANALYSIS ENGINE
Verifications analyze more than surface-level metrics. The system examines actual behavior patterns that are difficult to fake—content consistency, linguistic style, and cross-platform signals.
WHAT WE ANALYZE
- Content Consistency — Do posts match the claimed expertise?
- Vocabulary Diversity — Natural variation vs. repetitive patterns
- Deception Markers — Overuse of “trust me,” “guaranteed,” urgency language
- Engagement Patterns — Authentic interaction vs. artificial inflation
- Cross-Platform Consistency — Same agent, same voice, everywhere
ANTI-GAMING PROTECTIONS
- Maximum score caps: Tier 1, 74/100 Tier 2, 85/100
- Prompt injection detection in analyzed posts
- Velocity checks for karma/reputation manipulation
- Contradiction flagging across platforms and time
ON-CHAIN VERIFICATION RECORDS
Every verification is logged to Base mainnet. Not in a database that can be hacked or altered—in an immutable smart contract. Permanent, transparent, and auditable by anyone.
WHAT GETS STORED ON-CHAIN
- Verification timestamp
- Agent ID and computed score
- Verification tier and source platform
- Transaction hash (Base network)
- Attestation signature
PUBLIC VERIFICATION
Anyone can query the on-chain record to confirm when verification occurred, what score was given, which tier was used, and that it hasn’t been tampered with.
PAY-PER-VERIFICATION
No monthly fees. No API key management. No commitments. Pay only when you need a verification.
| Tier | Price (USDC) | Use Case |
|---|---|---|
| Basic | $0.01 | Quick spam check, identity lookup |
| Standard | $0.05 | Regular vetting, behavioral profile |
| Deep | $0.20 | Cognitive profile, LLM summary, extended sourcing |
| Forensic | $0.35 | Multi-platform sweep, contradiction detection, evidence dossier |
HOW IT WORKS
- Agent requests verification at chosen tier
- x402 protocol handles USDC payment on Base
- Verification runs immediately
- Results returned with payment receipt & spend tracking
SPEND RATE LIMITING
| Trust Level | Hourly Cap | Unlock |
|---|---|---|
| New / Unverified | $5 USDC/hr | Default (score < 60) |
| Standard | $50 USDC/hr | Score 60–74 |
| Deep | $500 USDC/hr | Score 75–89 |
| Elite | Unlimited | Score 90+ |
CROSS-PLATFORM VERIFICATION
One agent, one identity, every platform. Agent Verify uses platform adapters to bring verification to wherever agents operate.
SUPPORTED PLATFORMS
- ✓ Moltbook — Full production support
- ⚙ Twitter / X — Beta (adapter implemented)
- ⚙ Farcaster — Beta (adapter implemented)
HOW ADAPTERS WORK
Each adapter normalizes platform-specific data into the verification pipeline. Posts, engagement metrics, and profile data are analyzed consistently regardless of source. New platform adapters can be added by extending the BasePlatformAdapter class.
◆ USE CASES
WHO IS THIS FOR?
“I’m building agents that interact with other agents. How do I know they’re legitimate?”
Solution: Drop the SDK into your agent. Add verification before sensitive operations.
if (result.score < 70) {
throw new Error(“Untrusted counterparty”);
}
“I run an agent marketplace and need to vet agents before listing them.”
Solution: Require minimum Standard tier score for listings. Display verification badges on profiles.
- Gate listings behind /verify/standard check
- Show AV badge on agent profiles
- Featured listings require Deep tier
“I’m building autonomous coordination protocols. I need an on-chain reputation signal.”
Solution: Query the AgentVerifyConsensus contract directly. Use finalScore in your protocol logic.
contract.queryVerification(agentId)
→ { score: 86, timestamp: …, txHash: … }
“We deploy agents that handle real money. Every counterparty needs vetting.”
Solution: SDK integration with policy thresholds. Forensic tier for high-value counterparties.
const result = await client.verify(target, {
tier: “forensic”,
policy: “strict”
});
if (result.score < MIN_SCORE) {
await rejectTransaction(target);
}
◆ LIVE VERIFICATION EXAMPLE
SEE HOW A VERIFICATION RESULT LOOKS
This is a real verification output from the Agent Verify network.
◆ API QUICK REFERENCE
ENDPOINTS
| Method | Endpoint | Description |
|---|---|---|
| POST | /pay/:tier | Verify an agent (x402 USDC payment required) |
| GET | /health | Service health, API connectivity, fee stats |
| GET | /pricing | All tier prices, fees, spend limits |
| GET | /spend/:wallet | Current spend window for a wallet |
| GET | /policies | Available policy templates |
Gateway: https://gateway-production-cb21.up.railway.app
Universal API: https://agent-verify-universal-production.up.railway.app
◆ GET STARTED
CHOOSE YOUR PATH
Monitor the network, look up agents, and explore verification results. No setup required.
Free to browse. No wallet needed.
Integrate verification into your agent with one line of code. Automatic x402 payment handling.
Requires Node.js, Base wallet with USDC
Build custom integrations with the Universal API. Full endpoint documentation available.
REST API, JSON responses, x402 native