Plugin: Wallet reputation scoring for counterparty trust assessment

[jacobsd32-cpu]

Problem

GOAT gives agents 200+ financial tools and multi-chain wallet access, but no way to assess who they're transacting with. When an agent is about to send a payment, provide liquidity, or interact with another wallet — there's no trust signal to inform the decision.

This is especially important as agent-to-agent commerce grows. A lending agent extending credit needs different risk thresholds than a simple payment agent.

Proposal

Add a wallet reputation scoring plugin powered by DJD Agent Score.

The API returns a 0–100 trust score across 5 behavioral dimensions, derived from on-chain activity on Base:

Dimension	What it measures
Identity	Multi-chain attestations (ENS, stETH, governance tokens)
Behavior	Transaction frequency, diversity, gas efficiency
Reliability	Balance stability, payment consistency
Viability	Balance trajectory, longevity
Capability	Contract interactions, DeFi protocol usage

Plugin sketch

import { PluginBase, createTool } from "@goat-sdk/core";

class WalletReputationPlugin extends PluginBase {
  constructor() {
    super("walletReputation", []);
  }

  supportsChain = () => true; // Scoring works for any wallet

  getTools() {
    return [
      createTool({
        name: "check_wallet_reputation",
        description: "Score a wallet's on-chain reputation (0-100) before transacting",
        parameters: {
          wallet: { type: "string", description: "Wallet address to score" },
        },
        execute: async ({ wallet }) => {
          const res = await fetch(
            `https://djd-agent-score.fly.dev/score/basic/${wallet}`
          );
          return res.json();
        },
      }),
      createTool({
        name: "check_reputation_detailed",
        description: "Get detailed wallet reputation with dimension breakdown",
        parameters: {
          wallet: { type: "string", description: "Wallet address to score" },
        },
        execute: async ({ wallet }) => {
          const res = await fetch(
            `https://djd-agent-score.fly.dev/score/full/${wallet}`
          );
          return res.json();
        },
      }),
    ];
  }
}

Usage with any GOAT agent

import { WalletReputationPlugin } from "@goat-sdk/plugin-wallet-reputation";

const tools = getOnChainTools({
  wallet: myWallet,
  plugins: [
    new WalletReputationPlugin(),
    // ... other plugins
  ],
});

// Agent can now check reputation before sending payments:
// "Check the reputation of 0x... before sending 100 USDC"

Key features

• Free tier: 3 scores/day, no API key needed
• x402 micropayments: Pay-per-request via USDC on Base for higher volume
• TypeScript SDK: npm install djd-agent-score-client
• Sybil detection: Flags wash trading, gas manipulation, circular flows
• ERC-8004: Scores also published on-chain for trustless access

This fits GOAT's plugin architecture well — lightweight, optional, and composable with existing financial tools. Happy to help build this out or submit a PR!

[douglasborthwick-crypto]

The DJD Agent Score is a solid behavioral reputation layer — behavioral patterns, balance trajectory, protocol usage all aggregated to 0–100. Worth flagging a complementary use case though: when an agent needs to enforce a specific condition rather than check an aggregate score (e.g., "does this counterparty hold ≥100 USDC before I extend credit" or "does this agent hold a governance token to access this service tier"), you want a direct boolean rather than interpreting a score threshold.

InsumerAPI handles that layer — it's an ECDSA-signed condition evaluator across 32 chains. The GOAT plugin pattern would look like this:

createTool({
  name: "check_wallet_conditions",
  description: "Verify specific on-chain conditions for a counterparty wallet",
  parameters: {
    wallet: { type: "string", description: "EVM wallet address" },
  },
  execute: async ({ wallet }) => {
    const res = await fetch("https://api.insumermodel.com/v1/attest", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "X-API-Key": process.env.INSUMER_API_KEY!,
      },
      body: JSON.stringify({
        wallet,
        conditions: [
          {
            type: "token_balance",
            contractAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
            chainId: 1,
            threshold: 100,
            decimals: 6,
            label: "USDC >= 100 on Ethereum",
          },
        ],
      }),
    });
    const { data } = await res.json();
    return data; // { pass: boolean, conditions: [...] }
  },
}),

The response is ECDSA-signed and verifiable via JWKS — so an agent can pass the attestation downstream without the recipient needing to re-query. 32 chains (EVM + Solana + XRPL), token balances, NFT ownership, EAS attestations.

The two work well together: DJD score for aggregate behavioral reputation, InsumerAPI for specific on-chain condition gates that need a verifiable proof rather than a score. Public templates list at GET https://api.insumermodel.com/v1/compliance/templates (no auth) shows what EAS schemas are pre-indexed if that's useful for your use case.

Free key at insumermodel.com/developers/.

[iJaack]

Great issue — the trust signal gap is real, especially as agent-to-agent payments scale.

Worth flagging an alternative data source here: WalletIQ covers the same behavioral profile surface but across 5 EVM chains (not just Base) and indexes 75+ DeFi protocols. The response format maps directly to your proposed dimensions:

Your Dimension	WalletIQ field
Identity	wallet_age, ens_name, labels
Behavior	transaction_count, defi_interactions, protocols_used
Reliability	last_activity, active_days
Capability	defi_protocols (75+: Uniswap, AAVE, Pendle, Morpho, etc.)
Risk	risk_score (0–100), flags

The x402 path is agent-native — no API key, no signup, just pay $0.005 USDC per lookup via x402 on Base:

import { PluginBase, createTool } from "@goat-sdk/core";

class WalletIQPlugin extends PluginBase {
  constructor() {
    super("walletiq", []);
  }

  supportsChain = () => true;

  getTools() {
    return [
      createTool({
        name: "profile_wallet",
        description: "Get full wallet intelligence profile (age, DeFi usage, risk score, labels) before transacting",
        parameters: {
          address: { type: "string", description: "EVM wallet address to profile" },
        },
        execute: async ({ address }) => {
          // x402 flow: initial request returns 402, client signs USDC payment, retries
          const res = await fetch(
            `https://walletiq.dev/api/v1/x402/profile/${address}`,
            {
              headers: {
                // include x-payment header after signing 0.005 USDC on Base
              },
            }
          );
          return res.json();
        },
      }),
    ];
  }
}

Live at walletiq.dev/docs. Happy to help wire up the x402 payment flow into a proper GOAT plugin if there's interest — the pattern is the same as DJD's proposal, just multi-chain and with a richer protocol breakdown. Sample response for any address available on request.