MCP moved past local tools

MCP started with local context. Files. Browser state. Shell helpers. A tool list that lived close to the model and gave it a few safe actions.

That shape still works. But paid HTTP endpoints change the job.

An agent doesn't just need a function named check_risk. It needs to know what the endpoint costs, what chain settles the payment, what input shape is accepted, what comes back, and when it should call the thing instead of guessing from stale context.

A catalog-first MCP server gives the model that map.

The tool isn't the product anymore. The catalog entry is.

What catalog-first means

A catalog-first server starts by answering one question: "What can I buy here?"

That answer needs to be machine-readable. No prose maze. No hidden pricing. No vague product names. The catalog should expose stable endpoint IDs, short descriptions, input schemas, output schemas, x402 payment details, and prices.

Agentutility's current registry has 254 endpoints across edge-finance, locale, edge-market, prooflayer, wordmint, web-probe, mediakit, and synthforge. Prices currently run from $0.001 to $0.30 per call.

That's routing data.

If an LLM is picking between a free guess and a paid call, it needs enough context to decide. If a planner is building a task graph, it needs the endpoint ID and schema. If a wallet policy blocks calls over $0.05, the catalog has to say the price before the request is made.

Like this: 

{
  "endpoint": "website-screenshot",
  "cluster": "web-probe",
  "method": "POST",
  "price": {
    "amount": "0.01",
    "asset": "USDC",
    "network": "base-mainnet"
  },
  "input_schema": {
    "type": "object",
    "required": ["url"],
    "properties": {
      "url": { "type": "string", "format": "uri" },
      "viewport": { "type": "string", "enum": ["desktop", "mobile"] }
    }
  },
  "output_schema": {
    "type": "object",
    "properties": {
      "image_url": { "type": "string" },
      "status_code": { "type": "integer" }
    }
  }
}

The exact endpoint above is an example. The shape is the point.

The 402 flow becomes part of planning

Remote paid APIs add a second step to tool use. First discovery, then payment.

An agent can list the catalog through MCP, choose an endpoint, make an unpaid HTTP request, receive 402 Payment Required, construct the x402 payment, and retry with the payment header.

A simple planner can think in this order: 

1. Read MCP catalog.
2. Pick endpoint by ID, schema, and price.
3. Check wallet policy.
4. Call HTTP endpoint.
5. If 402, sign x402 payment for Base mainnet.
6. Retry with payment attached.
7. Parse response against the declared output schema.

That order matters because MCP doesn't need to carry the whole paid API call itself. It can describe the buyable surface, then let HTTP and x402 do what they're good at.

MCP is the discovery layer. x402 is the payment layer. HTTP is still the execution layer.

What agents should look for

Agents should prefer catalogs that expose hard facts.

Price first. Chain second. Schema third. Then latency hints, cache policy, and error shapes if the server has them.

Why price first? Because spend policy is part of reasoning now. A $0.001 lookup can be automatic inside a research loop. A $0.30 call may need stronger evidence that the answer changes the outcome.

And endpoint names should be boring. Boring is good here. secrets-exposure-check tells a router more than guardian_scan. company-domain-lookup beats insight_engine.

A catalog entry should make the next action obvious: 

{
  "task": "Check if this public repo exposes secrets",
  "candidate_endpoint": "secrets-exposure-check",
  "why": "Input accepts a GitHub URL and output returns finding counts.",
  "max_price": "0.05"
}

That object is easy for a model to produce. It's also easy for a runtime to audit.

What builders should ship

If you're building an x402 API, don't make the MCP layer an afterthought.

Start with a catalog document. Give every endpoint a stable ID. Publish exact prices. Keep schemas tight. Use examples with real fields. Add a short "call when" line for routers.

Bad catalog text says: "Analyze online presence using advanced intelligence."

Good catalog text says: "Call this with a URL to return HTTP status, title, canonical URL, and screenshot URL."

Agents don't need theater. They need affordances.

The best catalog-first servers will also expose filters. Let the client ask for endpoints under $0.01, endpoints in prooflayer, or endpoints that accept a url. A model with 254 choices shouldn't read every entry on every turn.

So the MCP server becomes a paid API directory with enough structure for software to act on it. The x402 endpoint still earns the fee. The catalog earns the call.