nigerian-reference-data

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

With no annotations, the description carries the burden: it does usefully disclose pricing and that a spot-price USD conversion is performed, which implies a live external price dependency. It does not state that the call is read-only, what happens for an address with zero balance or on an unsupported network, or anything about rate limits/failure modes.

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 tight sentence plus a cost prefix; no padding and the resource being read is front-loaded. The price fragment sits first, which is acceptable for a paid endpoint but slightly delays the core purpose.

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?

There is no output schema, and the description does say what comes back at a high level: the native balance plus its USD value at spot price. Combined with a fully documented 2-param schema, that is nearly complete; only edge-case behavior for unsupported networks or empty balances is 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 description coverage is 100%, so both 'address' (0x-prefixed EVM address) and 'network' (enum with default base) are already documented. The description only adds the note that the native token varies by chain (ETH/POL), which is mild added meaning; 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 verb+resource: reads the native-token (ETH/POL) balance of an EVM address and adds a USD spot valuation. It implicitly separates from the sibling chain_token (token balances) because it names 'native-token', but it never explicitly contrasts with that sibling.

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 only guidance is the cost signal ('$0.001 per call'), which implies this is a paid call to be used deliberately. There is no explicit statement of when to pick this over chain_token or chain_networks, nor any prerequisite such as needing a valid address per supported chain.

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?

With no annotations, the description carries the behavioral burden and usefully discloses the $0.001 per-call cost plus the returned fields. It does not explicitly state read-only behavior, permissions, or rate limits, though the 'block header' framing strongly implies a read operation.

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 compact sentence front-loads pricing and then states the resource, selection mode, and returned fields. Every element earns its place with 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?

For a low-complexity, two-parameter read tool with full schema coverage and no output schema, the description gives enough return-value context to call it correctly. It is slightly incomplete because it does not distinguish this tool from related siblings.

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 schema already has 100% description coverage for both parameters, including the 'latest' default and network default. The description reinforces that the tool works by number or latest, but adds no syntax or format detail beyond the schema.

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 clearly identifies the resource as a block header and states the two selection modes: by number or latest. It also lists key returned fields, which helps distinguish it from a mere block-number lookup. It stops short of explicitly naming sibling alternatives such as chain_block_number.

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 implies the tool is for retrieving block-header details, but gives no explicit when-to-use guidance or exclusions. It does not tell the agent when to choose chain_block over siblings like chain_block_number or chain_gas.

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?

With no annotations, the description carries the full burden, and it does add genuinely useful context: this is a paid call ($0.001) settled in USDC via x402, and it is scoped to the latest block only. It stops short of stating that it is a read-only, non-destructive operation and gives no hint of response format (decimal vs hex), latency, or failure behavior for an unpaid request.

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 compact sentences with no filler. The pricing sentence is front-loaded ahead of the purpose, which is defensible for a pay-per-call tool but slightly delays the core 'what does it do' answer.

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 single optional enum parameter, no output schema, and no annotations, the description covers the resource, the chain scope, and the billing model. The only real omission is the numeric format of the returned block number, which is low-risk for this tool's simplicity.

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 enum already documents the four valid values plus the 'default base' behavior, so the schema does the heavy lifting. The description restates the chain names (adding the friendly 'Arbitrum One' label) but contributes no additional semantics such as whether an unsupported network errors or falls back.

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 a specific resource (latest block number) and enumerates the four supported chains, so an agent knows exactly what value comes back. It does not explicitly distinguish itself from the close sibling chain_block, which presumably returns block data for a given height/hash, but the word 'latest' does most of that disambiguation work.

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 statement of when to use this versus chain_block, chain_gas, or chain_networks, despite three plausible overlapping siblings. The agent must infer usage from the resource name and the chain list alone; no exclusions or prerequisites (e.g. payment setup) are spelled out.

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?

With no annotations present, the description carries the behavioral burden and does add one genuinely useful trait: metered cost of $0.001 per call. It says nothing about data freshness/caching, whether the read can fail for an unsupported chain, or what a paid call actually returns, so a significant gap remains for a tool with zero annotation coverage.

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 compact sentences, zero filler: the pricing note leads and the payload description follows. Everything the agent needs at a glance is front-loaded.

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?

There is no output schema, so the description must sketch the return values, and it does: gas price plus transfer cost in both native token and USD. It stops short of stating the gas price unit (e.g. gwei) or the freshness of the reading, which are the two things an agent would still wonder about.

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 single parameter has 100% schema description coverage with an explicit enum and a documented default ('Chain to read (default base)'), so the schema does all the work. The description adds no detail about supported chains or default behavior beyond it, which is the expected baseline.

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 a specific resource and two distinct outputs: the current gas price on a chain and the cost of a plain native transfer, with the denomination stated ('in native token and USD'). That is concrete enough to separate it from siblings like chain_balance and chain_tx without opening the 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?

There is no explicit when-to-use or when-not-to-use guidance, and no sibling is named as an alternative. Usage is only implied by the resource ('read current gas price'), plus the '$0.001 per call' note that hints the call is metered and should be spent deliberately.

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?

With no annotations at all, the description carries the full burden, and 'Free — no payment required' is a genuinely useful disclosure about auth/billing behavior that isn't in any structured field. However, it omits that the call is read-only, static, side-effect free, and does not require a chain argument, so the safety profile remains implicit.

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, the exact supported values, and the billing caveat. No filler, no repetition of the title.

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?

Although there is no output schema, the description enumerates the return content (chain names plus chain ids), which is exactly what the agent needs to know to use the result as input to sibling tools. For a zero-param static catalog call, nothing essential is 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?

Zero parameters, so the schema baseline is 4. Nothing about parameters needs explaining, and the description spends no words on them.

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 and resource ('List the chains this API can read') and enumerates the exact members (Base, Ethereum, Arbitrum One, Polygon). Its enumerative, catalog-style purpose is clearly distinct from the operational siblings (chain_balance, chain_tx, chain_gas) that act on a single chain.

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 only implied: an agent can infer it should call this to discover valid chain names/ids before calling chain_balance, chain_tx, etc. But the description never says when to use it, that it should be called first, or that its output supplies arguments for the sibling tools.

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?

With no annotations, the description carries the burden of behavioral disclosure. It usefully states the cost of $0.001 per call and names the returned fields, and the operation is clearly a read. However, it does not explicitly state read-only behavior, error conditions, or what happens with invalid or unverified contracts.

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?

The description is two short sentences with no wasted text. The pricing and return-content information are front-loaded and immediately useful.

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 simple three-parameter read tool with full schema coverage, the description is mostly complete: it names the returned metadata and balance and discloses cost. It lacks sibling differentiation and explicit read-only/error behavior, but no critical calling information is 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 description coverage is 100%, so the token, holder, and network parameters are already well documented in the schema. The description adds only broad framing (token metadata and one holder's balance) and does not add syntax, format, or network-selection guidance beyond the schema.

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 states a specific resource and output set: ERC-20 token metadata (symbol, name, decimals) plus one holder's balance. This is clear enough to distinguish it from generic chain reads, though it does not explicitly contrast itself with the sibling chain_balance tool.

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 explicit guidance on when to use this tool versus chain_balance or other chain_* siblings. An agent can infer that this is for ERC-20 token balances rather than native balances, but the description provides no alternatives, prerequisites, or exclusions.

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?

No annotations, so the description carries the full burden. It usefully discloses cost ($0.001 per call) and the return fields, but says nothing about behavior for unknown, pending, or failed-to-index hashes, nor about error handling.

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 sentence, front-loaded with the price, then the resource, its input, and its output fields. No wasted words.

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 listing the returned fields, and it discloses pricing. The only gap is that multi-chain support (network param) is left entirely to the 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?

Schema coverage is 100% and the schema documents both hash and the network enum with default base, so baseline 3 applies. The description adds a bit of meaning via 'fee in native token and USD', hinting that values are chain-dependent, though it never mentions the network parameter itself.

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 (transaction receipt) with the key input (by hash) and enumerates the returned fields. This clearly distinguishes it from chain_block, chain_balance, and chain_token siblings.

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 it with a transaction hash to get that transaction's receipt. No explicit when-to-use/when-not guidance or reference to alternatives such as chain_block is given.

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?

With no annotations, the description carries the full behavioral burden and does well by disclosing cost per call, the check-digit algorithm, and the critical limitation that this is format validation only. It does not explicitly confirm read-only behavior or describe the response shape.

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 no wasted language. Cost, purpose, and the key limitation are front-loaded and easy to scan.

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 simple two-parameter validation tool with a fully described schema, the description covers purpose, cost, and the main limitation. Because there is no output schema, it could be stronger by stating what the validation result looks like.

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 description coverage is 100%, so both parameters are already documented in the schema. The description restates the 10-digit account number and 3-digit bank code formats but adds no extra parameter semantics such as bank code lists or error conditions.

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 states a specific verb and resource: validate a 10-digit NUBAN account number against a 3-digit CBN bank code using the check-digit algorithm. This is clearly distinguishable from the sibling chain_* and ng_* tools.

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 gives a clear usage boundary: format validation only, and explicitly warns that it does not confirm account existence. It does not name an alternative tool for existence checks, so it falls short of full when/when-not/alternatives guidance.

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?

With no annotations provided, the description carries the full disclosure burden and does so well: it states the per-call cost, clarifies that only validity is returned, and explicitly rules out database lookup and personal data exposure. That is exactly the behavioral context an agent needs before calling this tool.

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 compact sentences front-load the cost, then state purpose and behavioral boundaries. Every sentence adds useful information with no repetition or waste.

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 simple two-parameter format-validation tool with full schema coverage, the description is complete enough to call correctly. Since there is no output schema, it appropriately states that the return is validity only.

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 description coverage is 100%, so the schema already documents both parameters and the type enum. The description lists the supported identity types, which aligns with the enum but does not add format details such as digit length or pattern expectations for each type. Baseline 3 is appropriate.

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 states a specific verb, 'Format-validate', and a precise resource set: Nigerian NIN, BVN, TIN, CAC RC, and CAC BN numbers. It clearly distinguishes this tool from sibling validation/lookup tools by emphasizing format validation rather than database lookup.

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 makes the use case clear: format validation only, with no database lookup and no personal data returned. It does not explicitly name alternatives such as ng_bank_validate or ng_phone_lookup, but the intended context is still clear.

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?

No annotations exist, so the description carries the burden, and it does disclose the two traits an agent most needs: the cost ($0.003 per call) and the payment path (USDC over x402), plus the data source (prefix allocation). It stops short of stating failure behavior for invalid or unassigned prefixes and whether the lookup is offline or live, which are the remaining gaps.

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 sentences with no waste: price and payment rail front-loaded, then the operation and its outputs. Every clause carries information the agent would otherwise have to guess.

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 one-parameter lookup with no output schema, the description names the return fields and the cost model, which is close to sufficient. It could be stronger by noting what the response looks like when the prefix is unassigned or the number malformed.

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 a single required parameter, so the baseline is 3. The description adds genuine value beyond the schema's lone example by naming the three accepted formats (local, +234, 234), telling the agent it need not pre-normalise.

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 and resource (normalise a Nigerian phone number) and enumerates the returned fields: E.164, line type, and network. The subject matter (phone-number normalisation) is clearly distinct from the chain_* tools and from ng_bank_validate / ng_identity_format without needing to open 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?

Accepted input forms (local, +234, 234) are given, which tells the agent the tool can be called directly on any Nigerian number format. However, there is no explicit guidance on when to prefer this over ng_bank_validate or ng_identity_format, and no mention of what to do with non-Nigerian numbers.

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?

With no annotations, the description carries the full burden and does disclose two useful traits beyond structured data: the call is free (no payment required) and the result set is complete (all 36 states + FCT), implying a static, non-paginated reference list. It also implies the return content (state-to-capital pairs). What it omits is trivial for a zero-parameter list — there is no mutation or auth to disclose.

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 sentences, zero waste, with the scope-defining content ('36 Nigerian states plus the FCT with their capitals') front-loaded before the cost note.

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?

No output schema exists, so the description has to convey the return shape, and it does (states with their capitals). For a zero-param, read-only reference tool that is nearly complete; only an explicit statement of the response structure (e.g. array of {state, capital}) is 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?

The tool takes zero parameters, so no parameter semantics are needed; baseline is 4. The description correctly signals there is nothing to supply by framing it as an unfiltered 'list all'.

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 and resource ('List all 36 Nigerian states plus the Federal Capital Territory with their capitals') with exact scope — the 36 states plus FCT — so an agent knows precisely what comes back. No sibling overlaps: the others are chain_* or ng_* validators/lookups, none of which enumerate states.

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 only implied: it is evidently a static reference lookup to be used when state/capital names are needed, e.g. to normalize input for ng_bank_validate or ng_identity_format. It states no explicit when-to-use or when-not-to-use condition and names no alternative.

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?

With no annotations the description carries the full burden, and it discloses a lot: per-call price ($0.02), the exact set of instructions executed atomically (mint, metadata, mint supply, revoke authority), and the non-custodial key handling. It still omits failure modes, idempotency, and rate/throughput limits.

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?

Front-loads the price and the returned artifact, then the transaction contents, then the non-custodial constraint and the devnet recommendation. Every sentence earns its place, though the single long compound sentence listing the four instructions is dense.

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 10-parameter transaction-builder with no annotations and no output schema, the description covers what is returned (unsigned tx), what it contains, and the security model. Gaps remain around mainnet consequences and error behaviour, but the caller has enough to invoke it correctly.

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%, so the schema already documents every parameter including payer, network, decimals and revoke_mint_authority. The description only restates the payer requirement ('Requires a payer public key'), adding no syntax or format detail beyond the schema; 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 verb and artifact: returns an unsigned Solana transaction that creates an SPL mint, writes Metaplex metadata, mints supply and revokes mint authority. This is clearly distinguishable from sibling sol_launch_plan (planning) and sol_token_audit (inspection).

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?

Gives useful conditions: requires a payer public key and 'Test on devnet first', and the non-custodial framing tells the caller they must sign. It does not, however, explicitly route the agent between this and sol_launch_plan, nor state when not to call it (e.g. mainnet without a prior plan).

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?

With no annotations, the description carries the behavioral burden and does well: it discloses normalisation, a typed allow/review/deny gate, authority defaults, and that the response includes exact on-chain cost in SOL and USD. It stops short of explicitly stating side effects, rate limits, or how review/deny outcomes are surfaced.

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?

The purpose is front-loaded and the text is compact. There is minor redundancy between 'Free.' and 'it costs nothing', but otherwise every sentence contributes useful context.

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 an eight-parameter planning tool with no output schema, the description gives enough to select and invoke it correctly: purpose, sequencing, validation gate, authority defaults, and cost output. More detail on the exact response shape and gate outcomes would make it fully complete.

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 description coverage is 100%, so the schema already documents all eight parameters thoroughly, including defaults and enums. The description reinforces a few defaults such as mint revocation and freeze authority, but adds little semantic detail beyond what the schema provides.

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 and resource: validate a Solana token launch. It distinguishes itself from the build step with 'before building it', so an agent can separate planning from transaction construction without opening schemas.

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 explicitly says 'Use this first' and explains why: it is free and catches mistakes before signing. It implies the build tool should come later, but does not explicitly name the alternative sibling tool or state when not to use this one.

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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states that the tool is free, lists what it returns, and specifies that fees are in lamports, but it does not explicitly state that the operation is read-only, whether authentication is needed, or what rate limits may apply. For a zero-parameter informational tool this is adequate but not rich.

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?

The description is a single, front-loaded sentence that immediately states the primary resource and expands into the specific data returned. The 'Free — no payment required' clause is short and adds useful context without bloat.

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?

Given the tool's low complexity, zero parameters, absence of annotations, and lack of an output schema, the description provides enough detail about what is returned: supported networks, on-chain programs, and exact rent + fee figures in lamports. Nothing essential for an agent to call this informational tool correctly is 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?

The tool has zero parameters, so there are no parameter semantics to explain. Per the baseline for parameterless tools, a 4 is appropriate; the description does not need additional 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?

The description uses a specific verb, 'List,' and names the exact resource: Solana networks supported by the API, on-chain programs, and the rent + fee table in lamports. It clearly distinguishes itself from generic chain tools by focusing on Solana and launch costs, though it does not explicitly contrast itself with siblings such as chain_networks or sol_launch_plan.

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 purpose: an agent can infer this is the tool for discovering supported Solana networks and launch cost details. The description adds that it is free with no payment required, which is helpful context, but it does not explicitly state when to use this tool versus alternatives like chain_networks or sol_launch_plan.

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?

With no annotations, the description does meaningful work: it makes the read-only nature explicit ('Read', 'Reads the chain directly'), discloses per-call cost ($0.003), and sets expectations about determinism ('no opinion, no blacklist'). It stops short of covering failure behavior (invalid/non-existent mint addresses) or latency, which keeps it from a 5.

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 dense sentences with no filler, and the authoritative scope statement comes right after the price. Leading with the price is arguably a detour ahead of the purpose, but it's a legitimate decision factor for a paid tool and costs only a few words.

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?

There is no output schema, so the description must explain the return value, and it does: authority holders, metadata immutability, token identity fields, and a machine-readable verdict with flags. For a 2-parameter read tool this covers what an agent needs, with only error/edge-case behavior left implicit.

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 description coverage is 100%, with the mint address and the mainnet-beta/devnet enum both documented in the schema, so the baseline is 3. The description adds no parameter-level detail beyond the schema (e.g., no guidance on address validation or devnet caveats), so it doesn't exceed that baseline.

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?

It gives a specific verb and resource ('Read a Solana SPL mint's real authority state') and enumerates the exact facts returned: mint authority, freeze authority, metadata immutability, name/symbol/logo, and a flagged verdict. This is clearly distinguishable from siblings like chain_token and sol_launch_plan 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?

'Reads the chain directly — no opinion, no blacklist' signals what kind of audit this is versus opinionated rug-check services, and the price hints it's a pay-per-call utility. However, it never says when to prefer this over sibling chain_token, nor any prerequisites or exclusions, so usage is implied rather than stated.

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