The Vision
"If Ethereum decentralized money, Intuition is decentralizing trust in information."
We live in an era of AI agents operating everywhere — coding, trading, creating, interacting on our behalf. But:
How do you know which agent to trust?
AgentScore is the answer. An open, on-chain reputation system where anyone can stake tTRUST tokens to signal confidence in an AI agent or skill. Every signal is permanent, transparent, and economically meaningful — no fake reviews, no platform bias.
Where We're Going
AgentScore is evolving beyond a human marketplace:
- Today — Humans register agents and stake on trust
- Tomorrow — AI agents query trust scores to pick collaborators
- Next — Agents evaluate each other — trust grows autonomously
We're building the first Intuition dApp where AI is both the producer and consumer of trust data.
What's on the Platform
AgentScore handles three types of on-chain entities, all powered by Intuition Protocol atoms and triples:
🤖 Agents
AI agent identities registered as Intuition Atoms. Each agent gets a unique on-chain ID, a live Trust Score (0–100), and a staking vault. Anyone can stake tTRUST to back agents they believe in. Early stakers get more shares per tTRUST — bonding curve economics reward conviction.
⚡ Skills
Specific capabilities exposed by an agent (e.g. Code Generation, RAG Search, Image Analysis). Registered as Atoms and scored independently — a skilled agent should be backed at both the agent level and skill level.
💬 Claims
Verifiable triples (Subject → Predicate → Object) expressing structured relationships:
- Agent X [has skill] Code Generation
- Agent Y [is trusted by] CommunityDAO
- Skill Z [competes with] Skill W
Claims are also stakeable — support or oppose any statement with real tTRUST.
How Trust Scores Work
AgentScore uses a Hybrid Trust Score combining economic confidence with multi-dimensional quality metrics:
AGENTSCORE (objectScore)
objectScore = trustScore × 0.60 + qualityScore × 0.40
The published AGENTSCORE. Returned as score.objectScore in all API responses.
When qualityScore is not available (list context), use score.trustScore as fallback.
The Trust Score already encodes the oppose/support balance — a score below 50 means
oppose dominates. No additional soft gate is applied (removed to prevent
triple-penalization of the same signal).
trustScore (Economic Confidence)
base = supportRatio
confidence = 1 - e^(-totalStake / tau)
anchoredScore = 50 + (base - 50) × confidence
Anchored at 50 until sufficient economic stake accumulates. More stake = higher confidence = score moves further from 50.
qualityScore (4-Pillar Composite)
| Component | Weight | What it measures |
|---|
| Signal Ratio | 40% | Time-weighted support ratio (90-day half-life decay) |
| Staker Diversity | 25% | Unique stakers count (whale resistance) |
| Sustained Stability | 25% | Days maintaining >50% trust ratio |
| Price Retention | 10% | Current on-chain share price vs ATH |
All pricing data read directly from MultiVault contract — no local approximations.
Available on detail (/api/v1/agents/:id/trust) and card (/api/v1/agents/:id/card)
endpoints. Null on list endpoints (signal history not fetched in bulk).
Agent Tiers
An agent's tier is derived only from attestations: distinct live attesters (wallets with
shares > 0 on is skilled in → canonical-domain triples) and tTRUST attested on those triples.
Backing on the agent's atom vault never changes its tier, and a single wallet can never lift an
agent above Unverified (docs/AGENTSCORE_CORE_THESIS.md §6, src/lib/agent-tier.ts).
| Tier | Distinct live attesters | tTRUST attested |
|---|
| ⭐ Verified | ≥ 3 | ≥ 0.1 |
| ✓ Trusted | ≥ 2 | ≥ 0.05 |
| ○ Unverified | otherwise | — |
REST/MCP return it as tier with tierBasis: "attestations".
Vault Tiers (skills, claims, IntuForge projects)
Skills, claims and IntuForge projects keep the stake-based ladder (calculateTier in
src/lib/trust-tiers.ts). It is not an agent tier.
| Tier | Threshold | Description |
|---|
| ○ Unverified | 0 stakers | No signals yet |
| ◐ Sandbox | 3+ stakers, 0.1+ tTRUST | Early community activity |
| ✓ Trusted | 10+ stakers, 1+ tTRUST, 60%+ ratio | Solid conviction |
| ⭐ Verified | 25+ stakers, 5+ tTRUST, 75%+ ratio, 30+ days | High community confidence |
Architecture
┌──────────────────────────────────────────────────────────┐
│ FRONTEND │
│ Next.js 14 · TypeScript · Tailwind │
│ │
│ ┌─────────┬─────────┬─────────┬─────────┬──────────────┐ │
│ │ Landing │ Agents │ Skills │ Claims │ Profile │ │
│ │ Page │ Explorer│ Explorer│ Registry│ Badges │ │
│ └─────────┴─────────┴─────────┴─────────┴──────────────┘ │
│ ┌─────────┬─────────┬─────────┬─────────┬──────────────┐ │
│ │Register │ Docs │Leaderboard│Domains│ Evaluators │ │
│ └─────────┴─────────┴─────────┴─────────┴──────────────┘ │
│ │
│ wagmi v2 + viem + on-chain-pricing.ts │
└──────────┬────────────────────────┬───────────────────────┘
│ WRITE │ READ
▼ ▼
┌──────────────────────┐ ┌──────────────────────────────┐
│ AgentScore │ │ Intuition GraphQL API │
│ FeeProxy Contract │ │ + MultiVault on-chain reads │
│ 0x2f76...ec41 │ │ │
│ │ │ currentSharePrice() │
│ fee (0.02 + 2.5%) │ │ previewDeposit() │
│ → feeRecipient │ │ previewRedeem() │
│ rest → MultiVault │ │ convertToAssets() │
└──────────┬────────────┘ └──────────────────────────────┘
▼
┌──────────────────────────────────────────────────────────┐
│ INTUITION PROTOCOL │
│ │
│ ┌────────────┐ ┌──────────────┐ ┌──────────────────┐ │
│ │ ATOMS │ │ TRIPLES │ │ MULTIVAULT │ │
│ │ • Agents │ │ [Subject] │ │ • Bonding curves │ │
│ │ • Skills │ │ [Predicate] │ │ • Deposit/Redeem │ │
│ │ • Users │ │ [Object] │ │ • Share pricing │ │
│ └────────────┘ └──────────────┘ └──────────────────┘ │
│ │
│ Intuition Network L3 (Chain 13579) │
└──────────────────────────────────────────────────────────┘
Fee Model
AgentScore monetizes through Intuition's FeeProxy pattern — one of the first dApps to implement it in production alongside Sofia and Inturank.
How it works
All write operations (register, stake) route through our FeeProxy smart contract. The proxy takes a fee and forwards the rest to MultiVault.
| Operation | Fee | Route |
|---|
| Register Agent (createAtom) | 0.02 tTRUST + 2.5% | FeeProxy → MultiVault |
| Register Skill (createAtom) | 0.02 tTRUST + 2.5% | FeeProxy → MultiVault |
| Create Claim (createTriple) | 0.02 tTRUST + 2.5% | FeeProxy → MultiVault |
| Stake / Buy Shares (deposit) | 0.02 tTRUST + 2.5% | FeeProxy → MultiVault |
| Redeem / Sell Shares | FREE | MultiVault directly |
Fee is collected instantly in the same transaction — no claiming, no epochs.
Smart Contracts
On-Chain Pricing
Unlike applications using local bonding curve approximations, AgentScore reads all pricing data directly from MultiVault contract:
| Function | Purpose |
|---|
currentSharePrice() | Live marginal price per share |
previewDeposit() | Exact shares for deposit amount |
previewRedeem() | Exact proceeds for share amount |
convertToAssets() | Position valuation |
- 15-second cache prevents RPC spam
- Automatic fallback to local approximation if RPC fails
- 2% slippage protection using on-chain
previewDeposit quotes
Features
Core Platform
| Feature | Status |
|---|
| Agent Registry (on-chain Atoms) | ✅ Live |
| Skill Registry (on-chain Atoms) | ✅ Live |
| Claims Registry (on-chain Triples) | ✅ Live |
| Staking via MultiVault bonding curves | ✅ Live |
| Buy / Sell shares panel | ✅ Live |
| On-chain pricing (MultiVault reads) | ✅ Live |
| Slippage protection (2% tolerance) | ✅ Live |
Trust & Reputation
| Feature | Status |
|---|
| Hybrid Trust Score (AGENTSCORE) | ✅ Live |
| Composite Trust Score (4 pillars) | ✅ Live |
| Time-weighted reputation decay (90-day half-life) | ✅ Live |
| Agent Tiers from attestations (Unverified → Trusted → Verified) | ✅ Live |
| Bonding curve charts with on-chain price marker | ✅ Live |
| Trust History chart | ✅ Live |
| Community Sentiment visualization | ✅ Live |
User Experience
| Feature | Status |
|---|
| User profiles with achievement badges | ✅ Live |
| Leaderboard (multi-metric scoring) | ✅ Live |
| My Agents / Supporting tabs | ✅ Live |
| Badge system (Newcomer → Legend, 6 tiers) | ✅ Live |
| Activity feed | ✅ Live |
| Platform Documentation (/docs) | ✅ Live |
| Terms of Service & Privacy Policy | ✅ Live |
Monetization
| Feature | Status |
|---|
| FeeProxy integration (0.02 tTRUST + 2.5%) | ✅ Live |
| Instant fee collection per transaction | ✅ Live |
| Fee breakdown in UI (transparent pricing) | ✅ Live |
| Contract links in footer | ✅ Live |
Integrations
| Feature | Status |
|---|
Trust API (14 REST endpoints at /api/v1/) | ✅ Live |
MCP Server (12 tools for AI agents at /api/mcp/mcp) | ✅ Live |
Bonding Curve Economics
Every vault runs an independent bonding curve managed by Intuition's MultiVault contract:
- Early believers get more shares per tTRUST — price rises with each buy
- Sell anytime — redeem shares at current curve price, no lock-up period
- On-chain pricing — all prices read directly from contract, no approximations
- Transparent fee — platform fee shown before every transaction
User stakes 1 tTRUST on Agent X:
├── Platform fee: 0.045 tTRUST (0.02 fixed + 2.5%)
├── Protocol fee: built into bonding curve
└── Deposited: 0.955 tTRUST → MultiVault
└── Shares: credited to user's wallet
Tech Stack
| Layer | Technology |
|---|
| Framework | Next.js 14 (App Router) |
| Language | TypeScript |
| Styling | Tailwind CSS + shadcn/ui + Framer Motion |
| Web3 | wagmi v2 + viem |
| Protocol | Intuition Protocol SDK (@0xintuition/sdk) |
| Pricing | On-chain reads from MultiVault (currentSharePrice, previewDeposit, previewRedeem) |
| Smart Contracts | AgentScore FeeProxy + Intuition MultiVault |
| Trust Scoring | Hybrid model (Economic confidence + Composite quality metrics) |
| Data | Intuition GraphQL API + on-chain contract reads (15s cache) |
| Registration Tracking | localStorage + first position holder detection |
| Deployment | Vercel (Production + Preview) |
🤖 For AI Agents
AgentScore is fully agent-readable. If you are an AI agent or building one:
/llms.txt — Quick-start guide for LLMs: agentscore-gilt.vercel.app/llms.txt. Sourced live from the same code that enforces the API's behavior (endpoint list, cache policy, trust disclaimer), so it can't drift out of date./skill.md — Install AgentScore as a Claude/agent-framework skill: agentscore-gilt.vercel.app/skill.md. Byte-identical to this repo's SKILL.md — one HTTP GET checks any agent's reputation before you trust or transact with it./.well-known/agent.json — A2A auto-discovery manifest: agentscore-gilt.vercel.app/.well-known/agent.json- MCP Server —
https://agentscore-gilt.vercel.app/api/mcp/mcp (12 tools)
- REST API —
https://agentscore-gilt.vercel.app/api/v1 (14 endpoints)
- Agent Cards —
/api/v1/agents/{id}/card (A2A-compatible JSON per agent)
- Trust breakdown as plain text —
GET /api/v1/agents/{id}/trust with Accept: text/plain or ?format=text returns a compact one-line-per-field rendering for agent harnesses that don't parse JSON well.
For agents working on this codebase, see CLAUDE.md.
Quick example: find trusted code-gen agents
curl "https://agentscore-gilt.vercel.app/api/v1/trust/query?skill=code_generation&minTrust=70"
Quick example: connect via MCP
{
"mcpServers": {
"agentscore": {
"url": "https://agentscore-gilt.vercel.app/api/mcp/mcp"
}
}
}
Trust gate: ask before you pay or delegate
One yes/no, under your policy, with the reason — who vouches, for what, and how old the data is:
- REST:
GET /api/v1/agents/{id}/gate?minTier=trusted or ?minPeople=1&area=Crypto%20%2F%20Onchain
- MCP:
should_i_trust({ agentId, minTier }) or should_i_trust({ agentId, minPeople, area })
decision is allow, deny or unknown. unknown means AgentScore couldn't read the data right now — treat it as no. The default policy is { minTier: "trusted" } (at least 2 distinct people and 0.05 tTRUST vouched). The gate adds no scoring of its own: it reads distinct live attesters per area and the attestation tier, and no parameter or payment changes a decision. A function to paste (fetch only, no dependencies): examples/trust-gate.ts.
Demo — OPEN CLAW chooses who to pay: npm run demo:gate asks should_i_trust about two real testnet agents for the task "Summarise the latest Intuition testnet activity" (Captain Dackie, which one person vouches for in Crypto / Onchain, and AgentNews, which nobody vouches for), prints both decisions with their reasons and data age, then the payment step — simulated: nothing is paid or sent. Set AGENTSCORE_URL to point it at another server.
The demo's policy is { minPeople: 1, area: "Crypto / Onchain" }, not the default trusted. Trusted needs two independent people vouching, and today no agent on testnet has that — the honest current state, not a bug. Under the default both candidates are denied (npm run demo:gate -- --default). Captain Dackie says it takes x402 payments, but publishes no x402 endpoint on Intuition, so the demo prints the request it would send with that endpoint marked as missing — none is invented.
Getting Started
Prerequisites
- Node.js 18+
- npm or yarn
- MetaMask or compatible wallet
Installation
# Clone the repository
git clone https://github.com/Kryptoremontier/agentscore.git
cd agentscore
# Install dependencies
npm install
# Copy environment variables
cp .env.example .env.local
# Start development server
npm run dev
Environment Variables
# WalletConnect (get from https://cloud.walletconnect.com)
NEXT_PUBLIC_WC_PROJECT_ID=your_project_id
# Network: 'testnet' or 'mainnet'
NEXT_PUBLIC_NETWORK=testnet
Useful Scripts
npm run dev # Start dev server
npm run dev:clean # Clear .next cache and start fresh (fixes HMR issues)
npm run build # Production build
npm start # Run production server
npm run demo:gate # Trust gate demo: OPEN CLAW chooses who to pay (no payment is made)
Roadmap
Phase 1 ✅ Complete: Trust Marketplace
- Core UI/UX with gold/dark design system
- Agent, Skill, Claims registration (on-chain Atoms & Triples with type tagging)
- Staking via FeeProxy (createAtom/createTriple/deposit route through FeeProxy; redeem goes direct to MultiVault)
- FeeProxy monetization (0.02 tTRUST + 2.5% per operation)
- On-chain pricing (MultiVault contract reads, bonding curves)
- Hybrid Trust Score (AGENTSCORE): 60% economic confidence + 40% quality metrics; no soft gate
- Composite Trust Score (4 pillars): signal ratio (40%), staker diversity (25%), stability (25%), price retention (10%)
- 7-layer anti-manipulation: log diversity, min stake threshold, variance checks, diversity-weighted ratio, whale detection, accuracy-weighted staking, and attestation gate
- Contextual Trust Scoring: per-skill trust breakdown via triple vaults — each
[Agent] [hasAgentSkill] [Skill] triple scored independently
- Agent Domains: domain leaderboards with per-domain agent rankings — "who is best FOR this skill?"
- Accuracy-Weighted Staking (Evaluator System): staker track record determines influence weight (0.5x–1.5x), evaluator tiers (Newcomer→Scout→Analyst→Oracle→Sage), /evaluators leaderboard
- Radar chart for agents with 3+ skills (visual skill profile)
- Navigation redesign: left sidebar (always expanded) + mobile bottom tab bar
- Momentum indicators + Trust Sparkline (trend visibility on agent cards and detail panels)
- findOrCreateAtom(): mainnet-ready atom reuse (links to existing atoms instead of creating duplicates)
- 90-day reputation half-life (time-weighted signals with freshness bonus)
- Trust Tiers (Unverified → Sandbox → Trusted → Verified) — since Etap 4b-tier this vault ladder applies to skills, claims and IntuForge only; agent tiers come from attestations
- User profiles, badges, leaderboard
- Slippage protection (2% tolerance from on-chain quotes)
- Platform documentation, Terms of Service, Privacy Policy
- Testnet deployment on Vercel
Phase 2 🔧 In Progress: Mainnet + Intelligence Layer
2.1 Mainnet Migration
- Branded AgentScoreFeeProxy (separate deploy, not shared with other apps)
- Gnosis Safe multisig for fee recipient
- Link to existing skills.sh atoms via findOrCreateAtom()
- Tau parameter calibration (0.1 testnet → 50 mainnet)
- Custom domain (agentscore.xyz)
2.2 Agent Identity Verification
- Optional social links at registration (GitHub, X, Website, Discord)
- Stored as on-chain triples:
[Agent] [hasGithub] [url], [Agent] [hasTwitter] [@handle]
- Verified badge for agents with 2+ verified social accounts (6+ months old)
- Future: ZK-verified attestations (Gitcoin Passport or similar)
- Credibility multiplier on Trust Tiers (verified = boost, unverified = baseline)
2.3 Trust API + MCP Server ✅ Live
- Trust API: 13 REST endpoints at
/api/v1/
- MCP Server: 12 tools at
/api/mcp/mcp
- Integration with Sofia MCP (EigenTrust, personalized trust, trust paths) — Planned
- Interactive API documentation (/api-docs) — Planned
2.4 Accuracy-Weighted Staking ✅ Live (moved to Phase 1)
- Staker track record determines influence weight (0.5x–1.5x) — Live
- Evaluator tiers: Newcomer→Scout→Analyst→Oracle→Sage — Live
- /evaluators leaderboard — Live
- Graph-based trust quality layer on top of EigenTrust traversal — Planned
- Economic Sybil resistance: building weight requires many correct evaluations across many agents — Planned
2.5 Skill Standardization
- Canonical skill list synced with skills.sh mainnet atoms
- Skill search and autocomplete at registration (no free-text duplicates)
- Domain categories and tags for grouping
Phase 3 🌐 Planned: Autonomous Trust Graph
- Proof of Performance protocol (agents evaluate agents, not just humans)
- Task delegation & outcome reporting API
- Trust Validators (weighted signals for experienced evaluators)
- Performance scoring (5th pillar in Composite Trust)
- Trust Path Explorer (visualize WHY someone is trusted, not just the score)
- Graph-based trust propagation via EigenTrust integration
- Cross-domain trust flows (reputation portability between domains)
- SDKs for agent frameworks (LangChain, CrewAI, ElizaOS)
Phase 4 🔮 Future: Ecosystem Infrastructure
- DAO governance transition for protocol parameters (fee rates, tier thresholds)
- Cross-protocol reputation portability
- Partner integrations (agent frameworks, AI platforms)
- Enterprise trust scoring API (B2B trust-as-a-service)
- ERC-8004 compatibility — AgentScore as reputation provider for Trustless Agents standard
- SENSE integration (prediction market feeds into agent trust evolution timeline)
Contributing
Contributions are welcome under the project's BUSL 1.1 License.
By submitting a pull request, you agree that your contribution will be
licensed under the same terms as the rest of the project.
git checkout -b feature/your-feature
git commit -m 'Add your feature'
git push origin feature/your-feature
# Open a Pull Request
License
AgentScore is licensed under the Business Source License 1.1 (BUSL 1.1).
- You CAN: read the source, fork, modify, contribute, run for non-production use,
use for personal projects, integrate via API/MCP, build educational tools.
- You CANNOT: offer a hosted commercial service that competes with AgentScore
using this code (until 2030-05-05).
- On 2030-05-05 the license automatically converts to MIT — fully permissive.
For commercial licensing inquiries before the Change Date, open an issue on the
project repository.
This is the same license model used by Uniswap V3, Sentry, MariaDB, and CockroachDB.
Links
Acknowledgments
Today, humans stake on agents they believe in. Tomorrow, agents query trust scores to pick collaborators. Next — agents evaluate each other and the trust graph grows itself.
This is programmable trust — built on Intuition.
