Wire RobinX into your agent in one paste.

// Claude Desktop / any MCP client — two servers, one desk:
{ "mcpServers": {
    "robinhood": { "url": "<your connect URL from robinhood.com/us/en/agentic-trading>" },
    "robinx":    { "url": "https://api.robinx.io/mcp" }
} }

// Then hand the agent the house rule (system prompt or policy file):
// "Before entering ANY Robinhood Chain token: call robinx_verdict. Skip if signal is
//  avoid or serial_spammer, deployer_score < 70, or the deployer distributes to insiders.
//  Before trusting any X call, check robinx_caller — early_rate is measured, not vibes."

// npm i @virtuals-protocol/acp-node-v2   ·   github.com/Virtual-Protocol/acp-node-v2
// Buyer agent consumes a RobinX offering over ACP v2 (event model — no job phases API).
import { AcpAgent, PrivyAlchemyEvmProviderAdapter } from "@virtuals-protocol/acp-node-v2";
import { base } from "viem/chains";

// RobinX policy: proceed only if deployer score >= 70; hard-skip
// anything flagged avoid / serial_spammer / insider-loaded.
const SKIP = new Set(["avoid", "serial_spammer"]);
const passesPolicy = (r) => {
  const signal = r.verdict?.signal ?? r.signal;
  const score  = r.deployer?.score ?? r.data?.deployer_score ?? 0;
  return !SKIP.has(signal) && score >= 70;
};

// Keys come from your Virtuals dashboard (Agents › Signers › Copy Key).
const provider = await PrivyAlchemyEvmProviderAdapter.create({
  chains: [base],
  walletAddress: process.env.BUYER_AGENT_WALLET_ADDRESS,
  walletId: process.env.BUYER_WALLET_ID,
  signerPrivateKey: process.env.BUYER_SIGNER_PRIVATE_KEY,
});
const agent = await AcpAgent.create({ provider });

agent.on("entry", async (session, entry) => {
  // Seller accepted (set the budget) -> fund the escrow; work starts.
  if (session.status === "budget_set") await session.fund();
  // Deliverable arrives -> enforce the RobinX policy before trading.
  if (entry.kind === "message" && entry.contentType === "deliverable") {
    const report = JSON.parse(entry.content);
    if (passesPolicy(report)) {
      console.log("PROCEED", report.verdict?.signal, report.report_url);
      // ... your trade logic ...
    } else {
      console.log("HARD-SKIP", report.verdict?.signal);
    }
  }
});
await agent.start();

// Find RobinX, then buy a Token Intelligence Report for the launch you're eyeing.
const [robinx] = await agent.browseAgents("Robinhood Chain caller accuracy", { topK: 5 });
await agent.createJobByOfferingName(
  base.id,
  "Token Intelligence Report — Robinhood Chain",
  robinx.walletAddress,
  { token: "0x020bfc650a365f8bb26819deaabf3e21291018b4" }
  // no evaluatorAddress -> skip-evaluation mode: auto-completes on delivery
);

// npm i @coinbase/agentkit x402-fetch viem zod
import { customActionProvider, EvmWalletProvider } from "@coinbase/agentkit";
import { wrapFetchWithPayment } from "x402-fetch";
import { privateKeyToAccount } from "viem/accounts";
import { z } from "zod";

// Funded wallet auto-settles RobinX's 402s (USDC on Base).
const account = privateKeyToAccount(process.env.ROBINX_WALLET_KEY as `0x${string}`);
const pay = wrapFetchWithPayment(fetch, account);

const SKIP = new Set(["avoid", "serial_spammer"]);

// A custom action the agent MUST call before acting on any RH-chain launch.
export const robinxGate = customActionProvider<EvmWalletProvider>({
  name: "robinx_deployer_gate",
  description:
    "Score a Robinhood Chain token via RobinX before trading. Returns PROCEED " +
    "only if deployer score >= 70 and not flagged avoid/serial_spammer/insider.",
  schema: z.object({ token: z.string().describe("token contract address") }),
  invoke: async (_walletProvider, { token }) => {
    // $0.02 — verdict scores WHO deployed it, works on a token seconds old.
    const res = await pay(`https://api.robinx.io/verdict/${token}`);
    const v = await res.json();  // { signal, confidence, data: { deployer_score, deployer_record, ... } }
    const score = v.data?.deployer_score ?? 0;
    const ok = !SKIP.has(v.signal) && score >= 70 && !v.data?.deployer_record?.distributes;
    return ok
      ? `PROCEED — ${v.signal}, deployer ${score}/100`
      : `HARD-SKIP — ${v.signal}, deployer ${score}/100`;
  },
});

// Register it alongside your other action providers when building the agent:
//   const agentkit = await AgentKit.from({ walletProvider,
//     actionProviders: [robinxGate, /* wallet, erc20, ... */] });

// npm i @elizaos/core x402-fetch viem
import type { Plugin, Provider, Action, IAgentRuntime, Memory, State }
  from "@elizaos/core";
import { wrapFetchWithPayment } from "x402-fetch";
import { privateKeyToAccount } from "viem/accounts";

const account = privateKeyToAccount(process.env.ROBINX_WALLET_KEY as `0x${string}`);
const pay = wrapFetchWithPayment(fetch, account);
const SKIP = new Set(["avoid", "serial_spammer"]);

async function robinxVerdict(token: string) {
  const res = await pay(`https://api.robinx.io/verdict/${token}`); // $0.02
  return res.json();
}

// Provider: puts a fresh RobinX verdict into the agent's state.
const robinxProvider: Provider = {
  name: "ROBINX_VERDICT",
  description: "RobinX deployer verdict for the token under consideration",
  get: async (runtime: IAgentRuntime, message: Memory, state?: State) => {
    const token = state?.values?.token as string;
    if (!token) return { text: "", values: {}, data: {} };
    const v = await robinxVerdict(token);  // { signal, confidence, data: {...} }
    const score = v.data?.deployer_score ?? 0;
    const ok = !SKIP.has(v.signal) && score >= 70 && !v.data?.deployer_record?.distributes;
    return {
      text: `RobinX: ${v.signal}, deployer ${score}/100 -> ${ok ? "PROCEED" : "SKIP"}`,
      values: { robinxOk: ok, robinxVerdict: v.signal, deployerScore: score },
      data: { robinx: v },
    };
  },
};

// Action gate: validate() blocks the trade unless the policy passes.
const tradeGate: Action = {
  name: "ROBINX_TRADE_GATE",
  similes: ["CHECK_DEPLOYER", "VERIFY_LAUNCH"],
  description: "Only allow a buy when RobinX clears the deployer (score >= 70).",
  validate: async (_runtime: IAgentRuntime, _message: Memory, state?: State) => {
    return state?.values?.robinxOk === true; // hard-skip everything else
  },
  handler: async (runtime, message, state, _options, callback) => {
    const v = state?.values;
    await callback?.({
      text: `RobinX cleared ${v?.robinxVerdict} (deployer ${v?.deployerScore}/100) — proceeding.`,
    });
    // ... your trade action here ...
    return true;
  },
};

export const robinxPlugin: Plugin = {
  name: "robinx",
  description: "Gate Robinhood Chain trades on RobinX deployer intelligence",
  providers: [robinxProvider],
  actions: [tradeGate],
};

// Node — auto-pay any 402 with the x402-fetch wrapper.
import { wrapFetchWithPayment } from "x402-fetch";
import { privateKeyToAccount } from "viem/accounts";
const pay = wrapFetchWithPayment(fetch, privateKeyToAccount(process.env.ROBINX_WALLET_KEY));

// Newest launches from proven deployers — server-side score >= 70 gate.
// Response is enveloped: { data: { items: [...] } }; each item is already scored.
const { data } = await (await pay("https://api.robinx.io/feed/new?min_score=70")).json();

for (const t of data.items) {
  // items carry t.signal + t.deployer_score — no extra call needed to gate
  if (["avoid", "serial_spammer"].includes(t.signal)) continue; // HARD-SKIP
  if ((t.deployer_score ?? 0) < 70) continue;                    // policy
  // ... safe to act on t.token ...
}

# Free tier — no wallet, no key. Score a wallet before you trust its next launch.
curl https://api.robinx.io/deployer/0xcdfc08a1c1fbafb355645e5ddc32122e5716ca90

npx -y robinx-mcp
# or hosted (Streamable HTTP): https://api.robinx.io/mcp