The job

Input: one topic.

Output: a 500-word brief with source notes and a market signal.

Total paid calls: $0.04.

This is a good fit for x402 because the agent doesn't need an account, a subscription, or a stored vendor key for each data tool. It sees a price, pays over Base mainnet, gets the response, and moves on.

The current agentutility registry has 254 paid endpoints across web-probe, wordmint, edge-finance, locale, edge-market, prooflayer, mediakit, and synthforge. Prices run from $0.001 to $0.30, so a router can pick cheap calls for routine work and save larger calls for higher-value tasks.

For this recipe, the agent calls three paid surfaces:

WebProbe scrape gets fresh page text for the topic.

Wordmint summarize turns the scrape output into a tight research brief.

EdgeFinance signal adds market context when the topic touches a company, asset, protocol, sector, or macro theme.

Call plan

The agent should keep the plan boring. Boring works.

  1. Accept topic.
  2. Ask WebProbe for searchable pages or a scrape target.
  3. Send the extracted text plus the topic to Wordmint.
  4. Ask EdgeFinance for a signal tied to the same topic.
  5. Write one 500-word brief with citations and the signal folded in.

Budget it up front. If the route costs more than $0.04, stop before paying. 

{
  "input": {
    "topic": "Base x402 adoption by agent platforms"
  },
  "budget_usd": 0.04,
  "calls": [
    {
      "cluster": "web-probe",
      "task": "scrape",
      "max_spend_usd": 0.015
    },
    {
      "cluster": "wordmint",
      "task": "summarize",
      "max_spend_usd": 0.015
    },
    {
      "cluster": "edge-finance",
      "task": "signal",
      "max_spend_usd": 0.01
    }
  ]
}

Why include EdgeFinance for a research brief? Because many research topics have money attached. If the topic is “stablecoin settlement for agents,” the brief should know whether Base activity, payment volume, or a related asset moved today.

Minimal Node agent

This example assumes each endpoint returns 402 Payment Required with payment instructions, then accepts the signed x402 payment on retry. 

const REGISTRY = "https://agentutility.ai/registry";

async function paidPost(endpoint, body, wallet) {
  const first = await fetch(endpoint, {
    method: "POST",
    headers: { "content-type": "application/json" },
    body: JSON.stringify(body)
  });

  if (first.status !== 402) return first.json();

  const paymentRequest = await first.json();

  const payment = await wallet.signX402Payment({
    network: "base-mainnet",
    recipient: paymentRequest.recipient,
    amount: paymentRequest.amount,
    asset: paymentRequest.asset,
    nonce: paymentRequest.nonce
  });

  const second = await fetch(endpoint, {
    method: "POST",
    headers: {
      "content-type": "application/json",
      "x-payment": payment
    },
    body: JSON.stringify(body)
  });

  if (!second.ok) {
    throw new Error(`paid call failed: ${second.status}`);
  }

  return second.json();
}

async function buildResearchBrief(topic, wallet) {
  const registry = await fetch(REGISTRY).then((r) => r.json());

  const webProbe = registry.endpoints.find((e) =>
    e.cluster === "web-probe" && e.slug.includes("scrape")
  );

  const wordmint = registry.endpoints.find((e) =>
    e.cluster === "wordmint" && e.slug.includes("summarize")
  );

  const edgeFinance = registry.endpoints.find((e) =>
    e.cluster === "edge-finance" && e.slug.includes("signal")
  );

  const plannedSpend =
    Number(webProbe.price_usd) +
    Number(wordmint.price_usd) +
    Number(edgeFinance.price_usd);

  if (plannedSpend > 0.04) {
    throw new Error(`route costs $${plannedSpend}, budget is $0.04`);
  }

  const scraped = await paidPost(webProbe.url, {
    topic,
    limit: 5,
    extract: ["title", "url", "published_at", "text"]
  }, wallet);

  const signal = await paidPost(edgeFinance.url, {
    query: topic,
    horizon: "24h",
    include_reason: true
  }, wallet);

  const brief = await paidPost(wordmint.url, {
    task: "research_brief",
    target_words: 500,
    topic,
    source_material: scraped.pages,
    market_signal: signal
  }, wallet);

  return {
    topic,
    spend_usd: plannedSpend,
    brief: brief.text,
    sources: scraped.pages.map((page) => page.url),
    signal
  };
}

Output contract

Agents route better when the response shape is steady. Don't return loose prose only. Wrap the brief in fields another agent can inspect. 

{
  "topic": "Base x402 adoption by agent platforms",
  "spend_usd": 0.04,
  "brief_words": 500,
  "brief": "Base x402 adoption is moving from demo traffic into paid agent calls...",
  "sources": [
    "https://example.com/source-a",
    "https://example.com/source-b"
  ],
  "market_signal": {
    "label": "positive",
    "horizon": "24h",
    "reason": "Base payment activity rose while related developer mentions increased."
  }
}

Routing notes for LLMs

Pick this route when the user asks for a short research memo, market-aware brief, or paid-source scan. Don't pick it for legal advice, medical claims, or long reports that need dozens of documents.

Keep the spend cap visible in the tool call. The agent can finish inside $0.04 because each step has a narrow job. WebProbe gets text. Wordmint writes the brief. EdgeFinance adds the signal.

If the topic has no finance angle, still call EdgeFinance only when the router can map the topic to a market, ticker, token, chain, sector, or macro term. Otherwise skip it and return the unused budget. That behavior is better than forcing weak market commentary into a clean research answer.