SwiftNodes RPC

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds two genuinely useful behavioral facts beyond the annotations: the required 'Authorization: Bearer <key>' header and the privacy guarantee that key values are never returned.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Three short sentences, front-loaded with the returned data, then the auth requirement, then the privacy caveat. Every sentence earns its place and nothing is redundant.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema, the description compensates by enumerating the returned fields (plan, rate limits, usage, key restrictions) so the agent knows what to expect. Auth requirements are stated and the privacy behavior is documented, leaving no material gap for a zero-parameter read.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Zero parameters, so the baseline is 4. The description correctly implies the account is resolved from the auth key rather than any argument, adding a small amount of meaning without inventing parameter semantics that don't exist.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb+resource ('The caller's SwiftNodes plan') and enumerates the exact payload: plan, rate limits, monthly request usage, and IP/origin key restrictions. That enumeration separates it cleanly from siblings like get_pricing (catalog pricing) and get_method_support.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is implied — an agent infers this is the tool to call to inspect its own quota and plan state — but the description never says when to prefer it over get_pricing or how it relates to the other account-adjacent siblings. No exclusions or prerequisites beyond the auth header.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds that it surfaces live status and block height, which implies a live network read, but says nothing about auth needs, freshness, or failure behavior for unknown chains.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single front-loaded sentence that names the resource first and then lists the returned fields. No filler, no redundancy, nothing that could be cut without losing information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema, the description usefully enumerates the returned fields, which is exactly the gap it should fill for a read-only lookup tool. Minor omissions remain (error behavior on an unrecognized chain, what 'live status' values mean), keeping it short of a 5.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Only one parameter and schema description coverage is 100%; the schema already explains that chain accepts a slug, name, or chain ID with concrete examples. The description adds no syntax or matching-precedence detail beyond that, so baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific resource (one chain) and enumerates exactly what it returns: chain ID, live status, block height, and HTTP/WebSocket/archive endpoint URL templates. The phrase 'One chain' implicitly separates it from list_chains, though the sibling is not named explicitly.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no when-to-use or when-not-to-use guidance, and no alternatives are named. An agent must infer from 'One chain' that this is the single-chain lookup versus list_chains, but nothing tells it when the endpoint detail here is preferable to probe_endpoint or rpc_call.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so safety is covered. The description adds genuinely new behavior: data is 'probed weekly through the customer request path,' which tells the agent the values can be stale and how they were sourced. No contradiction with the read-only annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, zero filler. The freshness caveat and both call forms are front-loaded, and no sentence repeats the name or annotations.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Covers the two call shapes, the data source, and refresh cadence. A tool at this complexity needs little more; only a note on how per-chain detail is keyed (chain id vs name) or staleness tolerance would close the remaining gap.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% and the single optional param has its own example ('trace_filter', 'eth_getProof'), so the schema does the work. The description adds only that omitting the param yields an overview and supplying it yields per-chain detail, which is marginal but real.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific resource (JSON-RPC method support matrix) and verb (get), and names the scoping dimension (per-chain). Nothing in the sibling list covers the same ground; get_chain and list_chains enumerate chains, not method support, so the agent can route cleanly.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly names both invocation modes and what each returns: no args for the overview, {method} for per-chain detail. That is clear context for choosing a call shape, though it doesn't name an alternative tool or state when not to use it.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint, so the safety profile is fully covered. The description adds content-level context (billing model, what is excluded) but says nothing about the shape, granularity, or currency of what comes back.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two short clauses, front-loaded with the resource, then the qualifier that prevents misreading. Nothing is padded, though the fragment style leaves the action verb implicit.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a no-arg, read-only lookup with no output schema, the description covers the essentials by naming the pricing fields returned and clarifying that usage-based billing is out of scope. It stops short of describing the response structure (single plan vs. list, currency, units) that an agent might want without an output schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a no-param tool is 4. The description correctly does not invent parameter semantics.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description names the resource (SwiftNodes plans) and enumerates the pricing dimensions it covers (flat monthly price, HTTP and WebSocket rate limits), which is enough to tell it apart from siblings like get_account, get_chain, or rpc_call. It never uses an explicit verb such as 'returns', so the retrieval intent is inferred rather than stated.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is implied: call this when you need SwiftNodes plan pricing. The negative clauses ('no compute units, no per-request billing') usefully head off a wrong expectation, but there is no explicit when-to-use statement or reference to an alternative tool for other billing questions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare read-only, idempotent, open-world, non-destructive, so the safety profile is covered. The description adds real operational context beyond that: a single API key covers all chains, and archive access is requestable via ?archive=1. It does not say whether the list is paginated or how 'live status' is determined.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

One densely packed sentence, front-loaded with the verb and scope, and the parenthetical about the shared API key is placed where it matters. No filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema, the description usefully enumerates the return fields, which is exactly what an agent needs for a discovery endpoint. Minor gaps remain around pagination and the optional filters, but nothing critical for correct invocation of a zero-required-param list tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% with both parameters fully described in the schema, so the baseline is 3. The description mentions neither the query filter nor evm_only; its ?archive=1 note describes a chain attribute rather than an input parameter, so it adds no parameter guidance.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Specific verb ('List') plus resource ('every blockchain SwiftNodes serves'), with the scope word 'every' implicitly contrasting with the singular sibling get_chain. It also enumerates the returned attributes (name, slug, chain ID, live status, WebSocket/archive availability), so an agent knows exactly what it gets.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is implied by the enumeration scope — reach for this to discover chains, then get_chain for one. But there is no explicit when/when-not guidance or named alternative, so the agent must infer the routing against get_chain and probe_endpoint.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint/idempotentHint/openWorldHint, so the safety profile is covered. The description adds real behavioral value by spelling out what each mode returns (chain ID, block height, archive capability, latency vs. raw call result), though it says nothing about error behavior for unreachable endpoints.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Three short sentences with the primary purpose front-loaded, followed by the two precise call shapes. No filler and no redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema, the description carries the return-value burden and discharges it adequately for both modes (chain ID, block height, archive capability, latency; or raw call result). For a read-only probe tool with annotations covering safety, this is close to complete; only failure/error semantics are missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is only 33% (method and params are undocumented in the schema), so the description must compensate. It effectively does: it explains that method+params perform that RPC call and return the result, and that url alone triggers diagnostics. It stops short of noting that method/params are ignored when omitted.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

"Diagnose any public EVM JSON-RPC endpoint" gives a specific verb (diagnose) and resource (EVM JSON-RPC endpoint), and the two mode descriptions make the surface clear. It does not distinguish itself from the sibling rpc_call, whose function it partially overlaps in the second mode.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

It clearly states the two usage shapes — url alone for diagnostics, url+method+params for a raw call — which tells the agent exactly when each behavior applies. It stops short of naming rpc_call as an alternative or saying when to prefer that sibling.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the readOnly/destructive/idempotent annotations, the description discloses auth mechanics (Authorization: Bearer key passed to the MCP server), billing/quota behavior (counts against the key's plan), and an enforcement rule (signing/sending methods are refused). These are exactly the runtime traits an agent cannot infer from structured fields.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Three tight sentences: purpose first, then auth/billing, then the safety limitation. No filler, and the most consequential constraint is stated explicitly rather than buried.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a generic passthrough RPC tool with no output schema and full annotation coverage, the description covers identity, auth, billing, and the refusal boundary. It does not describe response shape or error behavior, but the free-form method/params nature makes that largely the upstream's concern.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% with each of the four properties documented inline, including chain slug examples and the archive-paid-plan note. The description adds no parameter-level meaning beyond that, so the baseline of 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (Make a JSON-RPC call) and resource (any SwiftNodes chain) with the caller's API key, and the read-only restriction further narrows what it does. An agent can distinguish this from get_chain, probe_endpoint, and get_method_support without opening any schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives clear operating context: the call is authenticated with the caller's key, is billed against that key's plan, and read-only methods that send or sign are refused. It does not explicitly compare against siblings like probe_endpoint or get_method_support, so the when-not guidance is implicit rather than named.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.