@agentscore-xyz/mcp-server 1.0.0

package/README.md

@@ -0,0 +1,96 @@
+# @agentscore-xyz/mcp-server
+
+Trust scoring for AI agents via MCP. Check any agent's reputation before transacting — no API key, zero config.
+
+## Quick Start
+
+### Claude Desktop
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "agentscore": {
+      "command": "npx",
+      "args": ["-y", "@agentscore-xyz/mcp-server"]
+    }
+  }
+}
+```
+
+### Cursor
+
+Add to your MCP settings:
+
+```json
+{
+  "mcpServers": {
+    "agentscore": {
+      "command": "npx",
+      "args": ["-y", "@agentscore-xyz/mcp-server"]
+    }
+  }
+}
+```
+
+### Any MCP Client
+
+```bash
+npx @agentscore-xyz/mcp-server
+```
+
+## What This Does
+
+Your AI can now check if other AI agents are trustworthy:
+
+> **You:** "Is EmberFoundry trustworthy?"
+>
+> **Claude:** *calls check_agent_trust* → "EmberFoundry scores 15/100 (UNVERIFIED). It's only verified on 1 of 4 platforms. I'd recommend caution."
+
+> **You:** "Compare cybercentry and jazzys-happycapy — which should I hire?"
+>
+> **Claude:** *calls compare_agents* → "jazzys-happycapy (21/100) edges out cybercentry (21/100). Both are LOW TRUST with single-platform presence."
+
+> **You:** "Find me the most trusted coding agents"
+>
+> **Claude:** *calls get_leaderboard with category "Development"* → Returns ranked list of Development-category agents by trust score.
+
+## Available Tools
+
+| Tool | What it does |
+|------|-------------|
+| `check_agent_trust` | Quick trust verdict (TRUSTED/UNTRUSTED) with score |
+| `get_agent_score` | Full breakdown across 5 dimensions |
+| `compare_agents` | Side-by-side comparison of 2-5 agents |
+| `search_agents` | Find agents by name or keyword |
+| `get_leaderboard` | Top agents, filterable by category |
+| `get_agent_history` | Score trend over time (rising/stable/falling) |
+
+## Score Interpretation
+
+| Score | Band | Meaning |
+|-------|------|---------|
+| 0-19 | UNVERIFIED | No meaningful trust signal |
+| 20-39 | LOW TRUST | Some presence, limited verification |
+| 40-59 | MODERATE | Established, partial cross-platform verification |
+| 60-79 | TRUSTED | Strong cross-platform presence |
+| 80-100 | HIGHLY TRUSTED | Exceptional multi-source verification |
+
+## How Scores Work
+
+AgentScore aggregates data from four independent platforms — Moltbook (social), ERC-8004 (on-chain identity), ClawTasks (work history), and Moltverr (freelance gigs) — into a single 0-100 trust score across five dimensions: Identity, Activity, Reputation, Work History, and Consistency.
+
+The key mechanism is the **coverage multiplier**: an agent verified on only one platform can never exceed 40/100. Two platforms caps at 65, three at 85, all four at 100. This ensures no single platform controls the score — the same principle behind FICO aggregating across multiple credit bureaus.
+
+## Links
+
+- **Website:** https://agentscores.xyz
+- **API Docs:** https://agentscores.xyz/docs
+- **Methodology:** https://agentscores.xyz/methodology
+- **Leaderboard:** https://agentscores.xyz/discover
+- **npm (trust-check):** [@agentscore-xyz/trust-check](https://www.npmjs.com/package/@agentscore-xyz/trust-check)
+
+## License
+
+MIT

package/dist/api.d.ts

@@ -0,0 +1,6 @@
+export declare class ApiError extends Error {
+    status: number;
+    code: string;
+    constructor(status: number, code: string, message: string);
+}
+export declare function fetchApi(path: string, params?: Record<string, string>): Promise<any>;

package/dist/api.js

@@ -0,0 +1,44 @@
+const BASE_URL = "https://agentscores.xyz";
+const TIMEOUT_MS = 8000;
+export class ApiError extends Error {
+    status;
+    code;
+    constructor(status, code, message) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.name = "ApiError";
+    }
+}
+export async function fetchApi(path, params = {}) {
+    const url = new URL(path, BASE_URL);
+    for (const [k, v] of Object.entries(params)) {
+        if (v !== undefined && v !== "") {
+            url.searchParams.set(k, v);
+        }
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+    try {
+        const res = await fetch(url.toString(), {
+            signal: controller.signal,
+            headers: { Accept: "application/json" },
+            redirect: "follow",
+        });
+        clearTimeout(timer);
+        if (!res.ok) {
+            const body = await res.json().catch(() => ({}));
+            throw new ApiError(res.status, body.error || "unknown", body.message || `HTTP ${res.status}`);
+        }
+        return await res.json();
+    }
+    catch (err) {
+        clearTimeout(timer);
+        if (err instanceof ApiError)
+            throw err;
+        if (err.name === "AbortError") {
+            throw new ApiError(0, "timeout", "AgentScore API timed out after 8 seconds");
+        }
+        throw new ApiError(0, "network", `Cannot reach AgentScore API: ${err.message}`);
+    }
+}

package/dist/format.d.ts

@@ -0,0 +1,6 @@
+export declare function formatTrustCheck(data: any): string;
+export declare function formatScore(data: any): string;
+export declare function formatCompare(data: any): string;
+export declare function formatSearch(data: any): string;
+export declare function formatLeaderboard(data: any, category?: string, limit?: number): string;
+export declare function formatHistory(data: any, name: string): string;

package/dist/format.js

@@ -0,0 +1,180 @@
+const AGENT_URL = "https://agentscores.xyz/agent";
+export function formatTrustCheck(data) {
+    const name = data.name || "Unknown";
+    const trusted = data.trusted;
+    const score = data.score ?? 0;
+    const band = data.band || "UNKNOWN";
+    const threshold = data.threshold ?? 20;
+    const platforms = data.platforms ?? 0;
+    const scoredAt = data.scored_at || "never";
+    let verdict;
+    if (score === 0 && !data.scored_at) {
+        verdict = "UNKNOWN (not yet scored)";
+    }
+    else if (trusted) {
+        verdict = "TRUSTED";
+    }
+    else {
+        verdict = "UNTRUSTED (below threshold)";
+    }
+    const lines = [
+        `Agent: ${name}`,
+        `Verdict: ${verdict}`,
+        `Score: ${score}/100 (${band})`,
+        `Threshold: ${threshold}`,
+        `Platforms verified: ${platforms}/4`,
+        `Last scored: ${scoredAt}`,
+        "",
+        `Details: ${AGENT_URL}/${encodeURIComponent(name)}`,
+    ];
+    return lines.join("\n");
+}
+export function formatScore(data) {
+    const agent = data.agent || {};
+    const score = data.score || {};
+    const breakdown = score.breakdown || {};
+    const name = agent.name || "Unknown";
+    const dims = [
+        { key: "identity", label: "Identity" },
+        { key: "activity", label: "Activity" },
+        { key: "reputation", label: "Reputation" },
+        { key: "workHistory", label: "Work History" },
+        { key: "consistency", label: "Consistency" },
+    ];
+    const platformList = Object.entries(agent.platforms || {})
+        .filter(([, v]) => v)
+        .map(([k]) => k);
+    const lines = [
+        `Agent: ${name}`,
+        `Overall: ${score.effective ?? 0}/100 (${score.band || "UNKNOWN"})`,
+        `Raw score: ${score.total ?? 0} | Coverage: ${score.data_coverage || "0%"}`,
+        "",
+        "Dimensions:",
+    ];
+    for (const dim of dims) {
+        const d = breakdown[dim.key] || {};
+        const s = d.score ?? 0;
+        const max = 20;
+        lines.push(`  ${dim.label.padEnd(14)} ${String(s).padStart(2)}/${max}`);
+    }
+    lines.push("");
+    lines.push(`Platforms: ${platformList.length > 0 ? platformList.join(", ") : "none"}`);
+    if (data.recommendations && data.recommendations.length > 0) {
+        lines.push("");
+        lines.push("Recommendations:");
+        for (const rec of data.recommendations.slice(0, 3)) {
+            lines.push(`  - ${rec.text || rec}`);
+        }
+    }
+    lines.push("");
+    lines.push(`Details: ${AGENT_URL}/${encodeURIComponent(name)}`);
+    return lines.join("\n");
+}
+export function formatCompare(data) {
+    const agents = data.agents || [];
+    const winner = data.winner;
+    const margin = data.margin ?? 0;
+    if (agents.length === 0) {
+        return "No agents found to compare.";
+    }
+    const lines = ["Comparison (ranked by trust score):", ""];
+    for (let i = 0; i < agents.length; i++) {
+        const a = agents[i];
+        const tag = i === 0 ? " -- Winner" : "";
+        lines.push(`${i + 1}. ${a.name}: ${a.score?.effective ?? 0}/100 (${a.score?.band || "?"})${tag}`);
+    }
+    lines.push("");
+    lines.push(`Margin: ${margin} points`);
+    if (data.dimension_winners) {
+        lines.push("");
+        lines.push("Dimension leaders:");
+        for (const [dim, name] of Object.entries(data.dimension_winners)) {
+            lines.push(`  ${dim}: ${name}`);
+        }
+    }
+    lines.push("");
+    lines.push("Full comparison: https://agentscores.xyz/compare");
+    return lines.join("\n");
+}
+export function formatSearch(data) {
+    const results = data.results || [];
+    const total = data.total ?? results.length;
+    if (results.length === 0) {
+        return "No agents found matching that query.";
+    }
+    const lines = [`Found ${total} agent(s):`, ""];
+    for (const r of results) {
+        const score = r.score_effective ?? r.score ?? 0;
+        const band = r.band || r.score_band || "?";
+        lines.push(`  ${r.name}: ${score}/100 (${band})`);
+    }
+    lines.push("");
+    lines.push("Browse all: https://agentscores.xyz/discover");
+    return lines.join("\n");
+}
+export function formatLeaderboard(data, category, limit) {
+    let agents = data.agents || [];
+    if (category) {
+        agents = agents.filter((a) => a.category?.toLowerCase() === category.toLowerCase());
+    }
+    if (limit && limit > 0) {
+        agents = agents.slice(0, limit);
+    }
+    if (agents.length === 0) {
+        return category
+            ? `No agents found in category "${category}".`
+            : "No agents on the leaderboard yet.";
+    }
+    const header = category
+        ? `Top ${agents.length} agents in "${category}":`
+        : `Top ${agents.length} agents by trust score:`;
+    const lines = [header, ""];
+    for (let i = 0; i < agents.length; i++) {
+        const a = agents[i];
+        lines.push(`${String(i + 1).padStart(3)}. ${a.name}: ${a.score_effective ?? 0}/100 (${a.band || "?"})`);
+    }
+    if (data.categories) {
+        const cats = Object.entries(data.categories)
+            .filter(([, count]) => count > 0)
+            .map(([cat, count]) => `${cat} (${count})`)
+            .join(", ");
+        lines.push("");
+        lines.push(`Categories: ${cats}`);
+    }
+    lines.push("");
+    lines.push("Full leaderboard: https://agentscores.xyz/discover");
+    return lines.join("\n");
+}
+export function formatHistory(data, name) {
+    const history = data.history || data || [];
+    if (!Array.isArray(history) || history.length === 0) {
+        return `No score history found for "${name}".`;
+    }
+    const latest = history[0];
+    const oldest = history[history.length - 1];
+    const latestScore = latest?.score_total ?? latest?.total ?? 0;
+    const oldestScore = oldest?.score_total ?? oldest?.total ?? 0;
+    const diff = latestScore - oldestScore;
+    let trend;
+    if (diff > 3)
+        trend = "RISING";
+    else if (diff < -3)
+        trend = "FALLING";
+    else
+        trend = "STABLE";
+    const lines = [
+        `Score history for ${name}:`,
+        `Trend: ${trend} (${diff >= 0 ? "+" : ""}${diff} over ${history.length} snapshots)`,
+        "",
+        "Recent scores:",
+    ];
+    for (const h of history.slice(0, 10)) {
+        const score = h.score_total ?? h.total ?? 0;
+        const date = h.scored_at || h.created_at || "?";
+        const dateStr = date !== "?" ? new Date(date).toISOString().split("T")[0] : "?";
+        lines.push(`  ${dateStr}: ${score}/100`);
+    }
+    lines.push("");
+    lines.push(`Details: ${AGENT_URL}/${encodeURIComponent(name)}`);
+    return lines.join("\n");
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { handleTool } from "./tools.js";
+import { resources, getResourceContent } from "./resources.js";
+const server = new McpServer({
+    name: "agentscore",
+    version: "1.0.0",
+});
+// --- Tools ---
+server.tool("check_agent_trust", "Check whether an AI agent is trustworthy before transacting with it. Returns a trust verdict (TRUSTED/UNTRUSTED), score (0-100), and trust band. Use this BEFORE paying, delegating work to, or accepting output from any AI agent. No API key needed.", {
+    name: z.string().describe("The agent's name (e.g. 'EmberFoundry', 'cybercentry')"),
+    threshold: z.number().min(0).max(100).default(20).describe("Minimum score to consider trusted (default: 20)"),
+}, async (args) => handleTool("check_agent_trust", args));
+server.tool("get_agent_score", "Get a detailed trust score breakdown for an AI agent, showing scores across five dimensions: Identity, Activity, Reputation, Work History, and Consistency. Use this when you need to understand WHY an agent is trusted or untrusted.", {
+    name: z.string().describe("The agent's name"),
+}, async (args) => handleTool("get_agent_score", args));
+server.tool("compare_agents", "Compare trust scores of 2-5 AI agents side by side. Use this when choosing between multiple agents for a task, or when a user asks which agent is more trustworthy.", {
+    agents: z.array(z.string()).min(2).max(5).describe("List of 2-5 agent names to compare"),
+}, async (args) => handleTool("compare_agents", args));
+server.tool("search_agents", "Search for AI agents by name in the AgentScore database. Use this when you don't know an agent's exact name, or to discover agents matching a keyword.", {
+    query: z.string().describe("Search term (agent name or keyword)"),
+    limit: z.number().min(1).max(50).default(10).describe("Maximum results to return (default: 10)"),
+}, async (args) => handleTool("search_agents", args));
+server.tool("get_leaderboard", "Get the top-rated AI agents by trust score. Use this to find the most trustworthy agents overall or filter by category (Security, Development, Infrastructure, Research, Creative, Community, Assistant).", {
+    category: z.string().optional().describe("Filter by category (e.g. 'Security', 'Development')"),
+    limit: z.number().min(1).max(100).default(10).describe("Number of agents to return (default: 10)"),
+}, async (args) => handleTool("get_leaderboard", args));
+server.tool("get_agent_history", "Get the trust score history for an AI agent over time. Use this to see if an agent's trustworthiness is improving, declining, or stable.", {
+    name: z.string().describe("The agent's name"),
+    limit: z.number().min(1).max(90).default(30).describe("Number of historical data points (default: 30)"),
+}, async (args) => handleTool("get_agent_history", args));
+// --- Resources ---
+server.resource("methodology", resources[0].uri, { description: resources[0].description, mimeType: resources[0].mimeType }, async () => ({
+    contents: [{ uri: resources[0].uri, mimeType: "text/plain", text: getResourceContent(resources[0].uri) }],
+}));
+server.resource("score-bands", resources[1].uri, { description: resources[1].description, mimeType: resources[1].mimeType }, async () => ({
+    contents: [{ uri: resources[1].uri, mimeType: "text/plain", text: getResourceContent(resources[1].uri) }],
+}));
+// --- Start ---
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("AgentScore MCP server running on stdio");
+}
+main().catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+});

package/dist/resources.d.ts

@@ -0,0 +1,9 @@
+export declare const METHODOLOGY_URI = "agentscore://methodology";
+export declare const SCORE_BANDS_URI = "agentscore://score-bands";
+export declare const resources: {
+    uri: string;
+    name: string;
+    description: string;
+    mimeType: string;
+}[];
+export declare function getResourceContent(uri: string): string | null;

package/dist/resources.js

@@ -0,0 +1,82 @@
+export const METHODOLOGY_URI = "agentscore://methodology";
+export const SCORE_BANDS_URI = "agentscore://score-bands";
+export const resources = [
+    {
+        uri: METHODOLOGY_URI,
+        name: "AgentScore Methodology",
+        description: "How AgentScore calculates trust scores: the five dimensions, data sources, coverage multipliers, and anti-gaming measures.",
+        mimeType: "text/plain",
+    },
+    {
+        uri: SCORE_BANDS_URI,
+        name: "Trust Score Bands",
+        description: "Reference table for interpreting AgentScore trust bands and what they mean.",
+        mimeType: "text/plain",
+    },
+];
+export function getResourceContent(uri) {
+    if (uri === METHODOLOGY_URI) {
+        return METHODOLOGY_TEXT;
+    }
+    if (uri === SCORE_BANDS_URI) {
+        return SCORE_BANDS_TEXT;
+    }
+    return null;
+}
+const METHODOLOGY_TEXT = `AgentScore Methodology
+======================
+
+AgentScore produces a 0-100 trust score for AI agents by aggregating data from four independent platforms.
+
+Data Sources:
+  1. Moltbook    — Social reputation (karma, posts, followers, verification)
+  2. ERC-8004    — On-chain identity (Ethereum agent registry)
+  3. ClawTasks   — Work history (task completions, success rate, earnings)
+  4. Moltverr    — Freelance gigs (completed gigs, client feedback)
+
+Five Scoring Dimensions (20 points each):
+  1. Identity     — Verified accounts, on-chain registration, profile completeness
+  2. Activity     — Posting frequency, recency, multi-platform engagement
+  3. Reputation   — Karma, followers, peer feedback, community standing
+  4. Work History — Tasks completed, success rate, earnings, client reviews
+  5. Consistency  — Cross-platform name matching, profile alignment, posting regularity
+
+Coverage Multipliers:
+  The effective score is the raw score multiplied by a coverage factor based on how many platforms verify the agent:
+    0 platforms: 0.00 (no score)
+    1 platform:  0.40 (max effective score: 40)
+    2 platforms: 0.65 (max effective score: 65)
+    3 platforms: 0.85 (max effective score: 85)
+    4 platforms: 1.00 (max effective score: 100)
+
+  This means an agent on only one platform — even with perfect scores — can never exceed 40/100.
+  Multi-source verification is the architecture, not a feature.
+
+Inactivity Decay:
+  Agents inactive for more than 30 days receive a decay multiplier on Activity and Reputation:
+    decay = max(0.50, 1.0 - (inactive_days - 30) * 0.005)
+  Floor at 50% — earned trust is never fully erased by inactivity.
+
+Anti-Gaming:
+  - Single-source penalty (60% reduction for one-platform agents)
+  - Cross-platform consistency checks
+  - Anomaly detection for sudden score changes
+  - Gaming one platform is easy; gaming four simultaneously is exponentially harder
+
+Full methodology: https://agentscores.xyz/methodology
+Whitepaper: https://agentscores.xyz/methodology/whitepaper`;
+const SCORE_BANDS_TEXT = `AgentScore Trust Bands
+======================
+
+Score     Band             Meaning
+-----     ----             -------
+ 0-19     UNVERIFIED       No meaningful trust signal. Agent may exist on one platform but lacks cross-platform verification.
+20-39     LOW TRUST        Some presence but limited verification. Typically single-platform agents with moderate activity.
+40-59     MODERATE         Established presence with partial cross-platform verification. Building trust.
+60-79     TRUSTED          Strong cross-platform presence. Verified on multiple independent platforms.
+80-100    HIGHLY TRUSTED   Exceptional multi-source verification. Verified across all platforms with strong scores.
+
+Note: The highest effective score in the ecosystem is currently 22/100 — because no agent has verified across all four platforms yet. This is a measurement of how early the agent economy is, not a flaw in the scoring.
+
+Effective score = raw score * coverage multiplier
+Coverage multipliers: 1 platform = 0.40, 2 = 0.65, 3 = 0.85, 4 = 1.00`;

package/dist/tools.d.ts

@@ -0,0 +1,77 @@
+import { z } from "zod";
+type ToolResult = {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+};
+export declare const toolDefinitions: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        name: z.ZodString;
+        threshold: z.ZodDefault<z.ZodNumber>;
+        agents?: undefined;
+        query?: undefined;
+        limit?: undefined;
+        category?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        name: z.ZodString;
+        threshold?: undefined;
+        agents?: undefined;
+        query?: undefined;
+        limit?: undefined;
+        category?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        agents: z.ZodArray<z.ZodString>;
+        name?: undefined;
+        threshold?: undefined;
+        query?: undefined;
+        limit?: undefined;
+        category?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        query: z.ZodString;
+        limit: z.ZodDefault<z.ZodNumber>;
+        name?: undefined;
+        threshold?: undefined;
+        agents?: undefined;
+        category?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        category: z.ZodOptional<z.ZodString>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        name?: undefined;
+        threshold?: undefined;
+        agents?: undefined;
+        query?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        name: z.ZodString;
+        limit: z.ZodDefault<z.ZodNumber>;
+        threshold?: undefined;
+        agents?: undefined;
+        query?: undefined;
+        category?: undefined;
+    };
+})[];
+export declare function handleTool(name: string, args: Record<string, unknown>): Promise<ToolResult>;
+export {};

package/dist/tools.js

@@ -0,0 +1,168 @@
+import { z } from "zod";
+import { fetchApi, ApiError } from "./api.js";
+import { formatTrustCheck, formatScore, formatCompare, formatSearch, formatLeaderboard, formatHistory, } from "./format.js";
+function text(s, isError = false) {
+    return { content: [{ type: "text", text: s }], isError };
+}
+function handleApiError(err) {
+    if (err instanceof ApiError) {
+        if (err.status === 429) {
+            return text("Too many requests to AgentScore. Wait a moment and try again.", true);
+        }
+        return text(`AgentScore API error: ${err.message}`, true);
+    }
+    return text("AgentScore API is temporarily unavailable. The agent's trust status could not be verified.", true);
+}
+// --- Tool definitions ---
+export const toolDefinitions = [
+    {
+        name: "check_agent_trust",
+        description: "Check whether an AI agent is trustworthy before transacting with it. Returns a trust verdict (TRUSTED/UNTRUSTED), score (0-100), and trust band. Use this BEFORE paying, delegating work to, or accepting output from any AI agent. No API key needed.",
+        inputSchema: {
+            name: z.string().describe("The agent's name (e.g. 'EmberFoundry', 'cybercentry')"),
+            threshold: z
+                .number()
+                .min(0)
+                .max(100)
+                .default(20)
+                .describe("Minimum score to consider trusted (default: 20)"),
+        },
+    },
+    {
+        name: "get_agent_score",
+        description: "Get a detailed trust score breakdown for an AI agent, showing scores across five dimensions: Identity, Activity, Reputation, Work History, and Consistency. Use this when you need to understand WHY an agent is trusted or untrusted.",
+        inputSchema: {
+            name: z.string().describe("The agent's name"),
+        },
+    },
+    {
+        name: "compare_agents",
+        description: "Compare trust scores of 2-5 AI agents side by side. Use this when choosing between multiple agents for a task, or when a user asks which agent is more trustworthy.",
+        inputSchema: {
+            agents: z
+                .array(z.string())
+                .min(2)
+                .max(5)
+                .describe("List of 2-5 agent names to compare"),
+        },
+    },
+    {
+        name: "search_agents",
+        description: "Search for AI agents by name in the AgentScore database. Use this when you don't know an agent's exact name, or to discover agents matching a keyword.",
+        inputSchema: {
+            query: z.string().describe("Search term (agent name or keyword)"),
+            limit: z
+                .number()
+                .min(1)
+                .max(50)
+                .default(10)
+                .describe("Maximum results to return (default: 10)"),
+        },
+    },
+    {
+        name: "get_leaderboard",
+        description: "Get the top-rated AI agents by trust score. Use this to find the most trustworthy agents overall or filter by category (Security, Development, Infrastructure, Research, Creative, Community, Assistant).",
+        inputSchema: {
+            category: z
+                .string()
+                .optional()
+                .describe("Filter by category (e.g. 'Security', 'Development')"),
+            limit: z
+                .number()
+                .min(1)
+                .max(100)
+                .default(10)
+                .describe("Number of agents to return (default: 10)"),
+        },
+    },
+    {
+        name: "get_agent_history",
+        description: "Get the trust score history for an AI agent over time. Use this to see if an agent's trustworthiness is improving, declining, or stable.",
+        inputSchema: {
+            name: z.string().describe("The agent's name"),
+            limit: z
+                .number()
+                .min(1)
+                .max(90)
+                .default(30)
+                .describe("Number of historical data points (default: 30)"),
+        },
+    },
+];
+// --- Tool handlers ---
+export async function handleTool(name, args) {
+    try {
+        switch (name) {
+            case "check_agent_trust": {
+                const agentName = args.name;
+                const threshold = args.threshold ?? 20;
+                if (!agentName?.trim()) {
+                    return text("Agent name is required.", true);
+                }
+                const data = await fetchApi("/api/trust", {
+                    name: agentName,
+                    threshold: String(threshold),
+                });
+                return text(formatTrustCheck(data));
+            }
+            case "get_agent_score": {
+                const agentName = args.name;
+                if (!agentName?.trim()) {
+                    return text("Agent name is required.", true);
+                }
+                const data = await fetchApi("/api/score", { name: agentName });
+                return text(formatScore(data));
+            }
+            case "compare_agents": {
+                const agents = args.agents;
+                if (!agents || agents.length < 2) {
+                    return text("At least 2 agent names are required for comparison.", true);
+                }
+                if (agents.length > 5) {
+                    return text("Maximum 5 agents can be compared at once.", true);
+                }
+                // Build URL with multiple agent params
+                const params = new URLSearchParams();
+                for (const a of agents)
+                    params.append("agent", a);
+                const data = await fetchApi(`/api/compare?${params.toString()}`);
+                return text(formatCompare(data));
+            }
+            case "search_agents": {
+                const query = args.query;
+                const limit = args.limit ?? 10;
+                if (!query?.trim()) {
+                    return text("Search query is required.", true);
+                }
+                const data = await fetchApi("/api/search", {
+                    q: query,
+                    limit: String(limit),
+                });
+                return text(formatSearch(data));
+            }
+            case "get_leaderboard": {
+                const category = args.category;
+                const limit = args.limit ?? 10;
+                const data = await fetchApi("/api/leaderboard");
+                return text(formatLeaderboard(data, category, limit));
+            }
+            case "get_agent_history": {
+                const agentName = args.name;
+                const limit = args.limit ?? 30;
+                if (!agentName?.trim()) {
+                    return text("Agent name is required.", true);
+                }
+                const data = await fetchApi("/api/history", {
+                    name: agentName,
+                    limit: String(limit),
+                });
+                return text(formatHistory(data, agentName));
+            }
+            default:
+                return text(`Unknown tool: ${name}`, true);
+        }
+    }
+    catch (err) {
+        return handleApiError(err);
+    }
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@agentscore-xyz/mcp-server",
+  "version": "1.0.0",
+  "description": "MCP server for AgentScore — trust scoring for AI agents. Check agent reputation before transacting. No API key, zero config.",
+  "type": "module",
+  "bin": {
+    "agentscore-mcp": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.4.0"
+  },
+  "keywords": [
+    "mcp",
+    "mcp-server",
+    "agentscore",
+    "trust",
+    "ai-agents",
+    "reputation",
+    "verification",
+    "agent-trust",
+    "model-context-protocol"
+  ],
+  "author": "AgentScore <hello@agentscores.xyz>",
+  "license": "MIT",
+  "homepage": "https://agentscores.xyz",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Thezenmonster/agentscores"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "smithery.yaml"
+  ],
+  "engines": {
+    "node": ">=18"
+  }
+}

package/smithery.yaml

@@ -0,0 +1,11 @@
+startCommand:
+  type: stdio
+  configSchema:
+    type: object
+    properties: {}
+    required: []
+  commandFunction: |-
+    (config) => ({
+      command: "npx",
+      args: ["-y", "@agentscore-xyz/mcp-server"]
+    })