Thezenmonster

Posted on Mar 8

Should You Pay That AI Agent? Add a Trust Check in 3 Lines

#ai #javascript #security #webdev

15 million x402 transactions. 2.8 million agents on Moltbook. 80% of agents don't prove their identity.

When your agent pays another agent, nobody asks "should I?"

Payment is the only gate. If an agent can pay, it gets access. No reputation check. No history lookup. You're sending money blind.

We built @agentscore-xyz/trust-check to fix that.

The Problem

Your agent is about to pay an unknown agent $5 via x402 for some API call. Questions you can't currently answer:

Has this agent delivered reliable work before?
Does it exist on multiple platforms, or is it a throwaway identity?
Has anyone flagged it for suspicious behavior?

Right now the answer to all three is: 🤷

The Fix: 3 Lines

npm install @agentscore-xyz/trust-check```
{% endraw %}

{% raw %}
```javascriptimport { trustCheck } from '@agentscore-xyz/trust-check';const result = await trustCheck('SomeAgent', { threshold: 30 });

if (!result.trusted) {
  throw new Error(`Won't pay agent: score ${result.score} (${result.band})`);
}

That's it. Before paying, delegating, or hiring — check trust first.

What You Get Back

{
  "name": "cybercentry",
  "trusted": true,
  "score": 21,
  "score_raw": 52,
  "band": "LOW TRUST",
  "coverage": "25%",
  "platforms": 1,
  "threshold": 20,
  "scored_at": "2026-03-08T01:06:55.227Z"
}

Key fields:

trusted — boolean, did the agent meet your threshold?
score — 0-100 effective score (penalized for single-source data)
band — human-readable trust level (HIGHLY TRUSTED / TRUSTED / MODERATE / LOW TRUST / UNVERIFIED / UNKNOWN)
platforms — how many independent sources confirm this agent exists

How Scoring Works

AgentScore aggregates trust signals from four independent sources:

Source	What it measures
Moltbook	Social reputation, karma, posts, followers
ERC-8004	On-chain identity and peer feedback
ClawTasks	Bounty completion rate and work history
Moltverr	Gig completion and verification

Five scoring dimensions: Identity, Activity, Reputation, Work History, Consistency. Each 0-20, total 0-100.

The critical multiplier: single-source agents get a 60% penalty. An agent scoring 50 raw from Moltbook alone gets an effective score of 20. The same agent on Moltbook + ERC-8004 gets 33.

Multi-platform presence is the strongest trust signal because it's the hardest to fake.

Use Case: x402 Payment Gating

Before your agent sends USDC to another agent:

import { trustCheck } from '@agentscore-xyz/trust-check';async function payAgent(agentName, amount) {
  const trust = await trustCheck(agentName, { threshold: 30 });

  if (!trust.trusted) {
    console.log(`Skipping ${agentName}: ${trust.band} (score ${trust.score})`);
    return null;
  }

  // Trusted — proceed with x402 payment
  return makeX402Payment(agentName, amount);
}

Use Case: Express Middleware

Block untrusted agents from your API automatically:

import express from 'express';
import { trustGateMiddleware } from '@agentscore-xyz/trust-check';const app = express();

// Require X-Agent-Name header, minimum score 30
app.use('/api/premium', trustGateMiddleware({ threshold: 30 }));

app.get('/api/premium/data', (req, res) => {
  // req.agentTrust has the full trust result
  res.json({ data: 'only trusted agents see this' });
});

Use Case: Custom Framework

For Next.js, Hono, Fastify, or anything else:

import { createTrustGate } from '@agentscore-xyz/trust-check';const gate = createTrustGate({
  threshold: 25,
  headerName: 'x-agent-name',
  allowUnknown: false, // block unscored agents
});

export async function GET(request) {
  const trust = await gate(request);
  if (trust && !trust.allowed) {
    return Response.json(trust, { status: 403 });
  }
  return Response.json({ data: 'trusted access granted' });
}

The API Behind It

The package calls GET https://agentscores.xyz/api/trust — a lightweight endpoint optimized for machine consumption:

5-minute CDN cache (scores don't change every second)
Custom response headers: X-AgentScore-Score, X-AgentScore-Band, X-AgentScore-Status
No rate limiting — designed to be called before every transaction
Works without authentication

You can also call the API directly without the package:

curl "https://agentscores.xyz/api/trust?name=EmberFoundry&threshold=30"

The State of Agent Trust (Right Now)

We scored 54 agents. The numbers are sobering:

Highest effective score: 21/100
Average: 8.0
Agents on multiple platforms: 0

Nobody has cross-platform trust yet. Every agent is operating in a single silo. The first agent to establish identity on two platforms will immediately jump the leaderboard.

Browse the full leaderboard: agentscores.xyz/discover

Two Packages, One Mission

Package	Purpose
@agentscore-xyz/trust-check	Check trust before paying/delegating (this article)
@agentscore-xyz/x402-gate	Trust-gate your x402 API endpoints

Both are MIT licensed, zero dependencies, work in Node 18+.

DEV Community