Integrate Money Mind in one step

Statistical adjudication for autonomous agents, pay-per-call in USDC over x402 on Base. No account, no API key, no invoice. We sell judges, not strategies: every endpoint answers one question about whether a number is real, and may answer no.

Why buy instead of burning tokens on it yourself? The arithmetic — e.g. 500 judge-nano validations/day is $5/day here vs ~$25/day in tokens (estimates, assumptions stated there).

The shelf

ToolPriceWhat it answers
judge_batch$0.01 per seriesTriage up to 1,000 backtest return series through a selection-correction gate in one call. Survivors ranked best-first. Use before spending inference on full evaluation of search winners.
judge_nano$0.01Single-gate selection correction for one winning backtest: is this winner real, or the best of n_tested tries? Verdict NO or PROVISIONAL only.
judge_lite$0.05Three-gate verdict on a return series: selection family-wise p, deflated Sharpe, date-clustered t. REAL / PROVISIONAL / NO with killed_by reasons.
factcheck$0.03Check one claim against 2-4 source URLs. Returns cited passages and a verdict: consistent | conflicting | insufficient_evidence.
extract$0.02Fetch a web page three independent ways, cross-check, confidence-score, and write a tamper-evident attestation. Refuses protected, login and CAPTCHA pages without charging.

Full machine-readable spec: /openapi.json · manifest: /.well-known/x402 · every endpoint serves a runnable example at GET /{endpoint}.

Option A — MCP (MCP-native agents)

Remote MCP server, JSON-RPC 2.0, 17 tools: POST https://money-mind-extract.onrender.com/mcp

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "judge-batch",
    "arguments": {
      "series": [
        {
          "returns": [
            0.8,
            -0.3,
            1.2,
            0.5
          ],
          "n_tested": 20,
          "label": "candidate-a"
        }
      ]
    }
  }
}

Paid tools route through x402: the response carries the 402 challenge; pay and retry. tools/list is free.

Option B — OpenAI-style function definitions

Drop these into any function-calling stack; each name maps to POST https://money-mind-extract.onrender.com/{endpoint} with the arguments as the JSON body.

[
  {
    "type": "function",
    "function": {
      "name": "judge_batch",
      "description": "Triage up to 1,000 backtest return series through a selection-correction gate in one call. Survivors ranked best-first. Use before spending inference on full evaluation of search winners.",
      "parameters": {
        "type": "object",
        "properties": {
          "series": {
            "type": "array",
            "maxItems": 1000,
            "items": {
              "type": "object",
              "properties": {
                "returns": {
                  "type": "array",
                  "items": {
                    "type": "number"
                  }
                },
                "n_tested": {
                  "type": "integer"
                },
                "label": {
                  "type": "string"
                }
              },
              "required": [
                "returns",
                "n_tested"
              ]
            }
          }
        },
        "required": [
          "series"
        ]
      }
    }
  },
  {
    "type": "function",
    "function": {
      "name": "judge_nano",
      "description": "Single-gate selection correction for one winning backtest: is this winner real, or the best of n_tested tries? Verdict NO or PROVISIONAL only.",
      "parameters": {
        "type": "object",
        "properties": {
          "returns": {
            "type": "array",
            "items": {
              "type": "number"
            }
          },
          "n_tested": {
            "type": "integer"
          }
        },
        "required": [
          "returns",
          "n_tested"
        ]
      }
    }
  },
  {
    "type": "function",
    "function": {
      "name": "judge_lite",
      "description": "Three-gate verdict on a return series: selection family-wise p, deflated Sharpe, date-clustered t. REAL / PROVISIONAL / NO with killed_by reasons.",
      "parameters": {
        "type": "object",
        "properties": {
          "returns": {
            "type": "array",
            "items": {
              "type": "number"
            }
          },
          "n_tested": {
            "type": "integer"
          },
          "dates": {
            "type": "array",
            "items": {
              "type": "string"
            }
          }
        },
        "required": [
          "returns",
          "n_tested"
        ]
      }
    }
  },
  {
    "type": "function",
    "function": {
      "name": "factcheck",
      "description": "Check one claim against 2-4 source URLs. Returns cited passages and a verdict: consistent | conflicting | insufficient_evidence.",
      "parameters": {
        "type": "object",
        "properties": {
          "claim": {
            "type": "string"
          },
          "urls": {
            "type": "array",
            "minItems": 2,
            "maxItems": 4,
            "items": {
              "type": "string"
            }
          }
        },
        "required": [
          "claim",
          "urls"
        ]
      }
    }
  },
  {
    "type": "function",
    "function": {
      "name": "extract",
      "description": "Fetch a web page three independent ways, cross-check, confidence-score, and write a tamper-evident attestation. Refuses protected, login and CAPTCHA pages without charging.",
      "parameters": {
        "type": "object",
        "properties": {
          "url": {
            "type": "string"
          },
          "extraction_target": {
            "type": "string"
          }
        },
        "required": [
          "url"
        ]
      }
    }
  }
]

Option C — LangChain

from langchain_core.tools import StructuredTool
import requests

BASE = "https://money-mind-extract.onrender.com"

def judge_batch(series: list[dict]) -> dict:
    """Triage backtest winners: {series: [{returns, n_tested, label?}]}.
    Returns survivors ranked best-first. $0.01/series via x402."""
    r = requests.post(f"{BASE}/judge-batch", json={"series": series})
    # On HTTP 402, pay with any x402 v2 client and retry with the
    # PAYMENT-SIGNATURE header — the 402 body carries everything needed.
    return r.json()

tools = [StructuredTool.from_function(judge_batch)]

Option D — CrewAI

from crewai.tools import BaseTool
import requests

BASE = "https://money-mind-extract.onrender.com"

class JudgeBatchTool(BaseTool):
    name = "judge_batch"
    description = ("Triage up to 1,000 backtest series through a "
                   "selection gate, $0.01/series. Input: "
                   "{series: [{returns, n_tested, label?}]}")

    def _run(self, series: list[dict]) -> dict:
        r = requests.post(f"{BASE}/judge-batch",
                          json={"series": series})
        return r.json()  # pay the 402 via your x402 client, then retry

Option E — Raw HTTP + x402

  1. POST the endpoint with your JSON body → HTTP 402 with an accepts array (price, asset, payTo, network eip155:8453).
  2. Pay with any x402 v2 client (EIP-3009 transferWithAuthorization, USDC on Base). No ETH needed — the facilitator broadcasts.
  3. Retry the same POST with the PAYMENT-SIGNATURE header → verdict + on-chain receipt.

Honest limits: judges can say NO and will; protected, login and CAPTCHA pages are refused and never charged; a self-payment proves the rail, not demand — ours did, and we say so.