Trust Layer API

Parameters

Response Fields

Register a custom action that gates transactions on trust score. The action fetches the counterparty's assessment before your agent moves any funds.

// trustcheck-action.ts — drop into your ElizaOS plugins folder
import { Action, IAgentRuntime, Memory } from "@elizaos/core";

const TRUST_API = "https://api.thetrustlayer.xyz";

export const trustCheckAction: Action = {
  name: "TRUST_CHECK",
  description: "Check counterparty trust score before transacting",
  
  async handler(runtime: IAgentRuntime, message: Memory) {
    const agentId = message.content.agentId; // e.g. "base:1378"
    const amount = message.content.amount;
    
    const res = await fetch(`${TRUST_API}/trust/${agentId}`);
    const trust = await res.json();
    
    // Hard stop on high risk
    if (trust.risk_level === "high" || trust.sybil_risk === "high") {
      await runtime.messageManager.createMemory({
        content: { text: `Blocked: ${agentId} flagged as high risk (score: ${trust.trust_score})` },
        roomId: message.roomId,
        userId: runtime.agentId,
      });
      return false;
    }
    
    // Cap exposure
    if (amount > trust.recommended_max_exposure_usd) {
      message.content.amount = trust.recommended_max_exposure_usd;
    }
    
    return true; // safe to proceed
  },

  async validate(runtime: IAgentRuntime, message: Memory) {
    return message.content.agentId && message.content.amount;
  },
};

Define a LangChain tool your agent can call whenever it needs to evaluate a counterparty. Works with any model that supports tool calling.

# trustlayer_tool.py
import requests
from langchain_core.tools import tool

TRUST_API = "https://api.thetrustlayer.xyz"

@tool
def check_agent_trust(agent_id: str, transaction_usd: float) -> str:
    """Check an ERC-8004 agent's trust score before transacting.
    Use this whenever you need to send money to or receive services from an agent.
    agent_id format: 'chain:id' e.g. 'base:1378'"""
    
    resp = requests.get(f"{TRUST_API}/trust/{agent_id}")
    trust = resp.json()
    
    score = trust["trust_score"]
    risk = trust["risk_level"]
    sybil = trust["sybil_risk"]
    flags = trust.get("anomaly_flags", [])
    max_exp = trust["recommended_max_exposure_usd"]
    
    if risk == "high" or sybil == "high":
        return f"BLOCK: {agent_id} is high risk (score={score}, sybil={sybil}, flags={flags})"
    
    if transaction_usd > max_exp:
        return f"REDUCE: cap exposure at ${max_exp} (score={score}, requested=${transaction_usd})"
    
    return f"OK: {agent_id} cleared (score={score}, risk={risk}, sybil={sybil})"

# Add to your agent
# tools = [check_agent_trust, ...your_other_tools]
# agent = create_tool_calling_agent(llm, tools, prompt)

Give your CrewAI agents a trust-checking tool they can use during task execution.

# trustlayer_crewai.py
import requests
from crewai.tools import tool

TRUST_API = "https://api.thetrustlayer.xyz"

@tool("TrustLayer Check")
def trustlayer_check(agent_id: str) -> str:
    """Look up the trust score and risk level for an ERC-8004 agent.
    Returns score, risk assessment, sybil risk, and any anomaly flags.
    agent_id format: 'chain:id' e.g. 'base:1378'"""
    
    resp = requests.get(f"{TRUST_API}/trust/{agent_id}")
    t = resp.json()
    
    summary = f"Agent {agent_id}: score={t['trust_score']}/100"
    summary += f", risk={t['risk_level']}, sybil={t['sybil_risk']}"
    summary += f", max_exposure=${t['recommended_max_exposure_usd']}"
    
    if t.get("anomaly_flags"):
        summary += f", warnings={t['anomaly_flags']}"
    
    if t.get("cross_chain_scores"):
        cc = t["cross_chain_scores"]
        summary += f", cross_chain_score={cc['unified_score']}"
    
    return summary

# Use in your crew
# from crewai import Agent
# trader = Agent(
#     role="DeFi Trader",
#     tools=[trustlayer_check],
#     goal="Execute trades only with trusted counterparties"
# )

One fetch call. No SDK needed.

async function shouldTrust(counterpartyId, amountUsd) {
  const res = await fetch("https://api.thetrustlayer.xyz/trust/" + counterpartyId);
  const t = await res.json();

  if (t.risk_level === "high" || t.sybil_risk === "high") return { ok: false, reason: "high_risk" };
  if (amountUsd > t.recommended_max_exposure_usd) return { ok: false, reason: "over_exposure" };

  const badFlags = t.anomaly_flags.filter(f => 
    f.includes(":high") || f.startsWith("spam") || f.startsWith("review_bombing")
  );
  if (badFlags.length > 0) return { ok: false, reason: "manipulation", flags: badFlags };

  return { ok: true, score: t.trust_score, maxExposure: t.recommended_max_exposure_usd };
}

// Usage
const check = await shouldTrust("base:1378", 50);
if (!check.ok) console.log("Skipping —", check.reason);