Price belongs in tool discovery

An MCP client can inspect a tool’s name, description, and input schema before calling it. Cost should be visible at the same moment.

Without a pricing field, the client has to invoke the tool and wait for an x402 payment response before learning the charge. That’s workable for a human testing one endpoint. It’s poor input for an agent planning dozens of calls under a fixed budget.

A tool descriptor should expose the exact per-call amount: 

{
  "name": "company-domain-search",
  "description": "Find company domains from a name query.",
  "price": 0.001,
  "currency": "USDC",
  "network": "base"
}

Now the planner knows the cost before it commits. Simple.

Zero has a real meaning

Free tools should set price: 0.

Don’t omit the field. Don’t use null, "free", or a sentence buried in the description. Missing means the price is unknown. Zero means the caller won’t pay.

That distinction matters when an MCP client applies policy. An agent with instructions to use free tools can accept price: 0 immediately while rejecting any tool without a declared price. The client doesn’t need to guess whether missing metadata means free, forgotten, or priced later. 

{
  "name": "list-supported-formats",
  "description": "Return the formats accepted by the conversion tools.",
  "price": 0,
  "currency": "USDC",
  "network": "base"
}

Free discovery calls can help an agent choose a paid operation. Publishing zero lets the router make that choice without a payment probe.

What AgentUtility puts in the field

AgentUtility’s registry currently has 793 paid HTTP endpoints across 17 clusters. Prices run from 0.001 to 0.5 USDC per call on Base mainnet.

For these tools, price is the quoted USDC amount for one invocation. It’s a nonnegative JSON number. The value shown during MCP discovery matches the amount the endpoint requests through x402.

That makes budget checks boring, which is exactly what payment code should be.

An agent holding a 0.02 USDC task budget can fit twenty calls priced at 0.001. A tool priced at 0.5 is excluded before any request leaves the client. 

function affordableTools(tools, remainingUsdc) {
  return tools.filter((tool) =>
    Number.isFinite(tool.price) &&
    tool.price >= 0 &&
    tool.price <= remainingUsdc
  );
}

Production clients should convert decimal USDC values into the asset’s smallest unit before adding totals or signing payments. The discovery field stays readable, while accounting stays exact.

Missing prices should fail closed

A pricing-aware client shouldn’t treat an absent field as zero. That creates an easy budget leak.

Treat it as unknown. The client can skip the tool or require a policy that permits unquoted costs. Either choice is safer than silently assuming the call is free.

The same rule helps tool publishers. If every descriptor must contain price, schema checks can catch omissions during deployment instead of leaving agents to discover them at runtime.

MCP needs a shared pricing contract

The field doesn’t need much ceremony. price is a nonnegative JSON number, zero means free, absence means unknown, and the catalog declares the asset plus network.

Fixed-price tools can adopt that contract now. Clients can then filter by capability, reject unknown costs, enforce the remaining budget, and select among eligible tools.

Quality still matters. So do latency and output fit. But price is the constraint that can stop the call entirely, and it belongs beside the tool’s other pre-call facts.

If a tool costs 0.001 USDC, publish 0.001. If it’s free, publish 0. The agent shouldn’t have to knock on the endpoint just to learn whether it can afford the answer.