Netfluid

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

With no annotations, the description carries the full burden. It usefully discloses that an api_key with administrator privileges is required and that the block is temporary (implying reversibility via access_resume), but says nothing about what operations are blocked, side effects, or rate 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?

The opening sentence is duplicated verbatim before the elaborated version, wasting space, and the javadoc-style @param/@return tags pad the text. The intent is still front-loaded and understandable.

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 two-param mutation tool with no annotations and no output schema, the description covers purpose, privilege requirement, and both parameters, but leaves the behavioral effect underspecified and the return value ('a json object') uninformative.

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 0%, so the description must compensate, and it does document both parameters: api_key as the admin-privileged key and wallet_fk as the wallet to pause. It lacks format details (e.g. API key source) but covers the semantic intent of each param.

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: temporarily blocks access to the wallet, and adds scope ('for all systems'). It is distinguishable from the write-side siblings, though it never names access_resume as its inverse, which would have made the pairing explicit.

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?

No when-to-use guidance, no statement of prerequisites beyond the admin key, and no reference to the obvious counterpart access_resume for undoing the pause. The agent must infer usage context entirely.

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. It implies a mutation (binding a wallet to a platform identity) but never states whether the binding is reversible, what happens if the user_id is already linked, what permissions the api_key needs, or what the returned JSON contains beyond 'a json object'.

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 core sentence appears twice verbatim, and the @param/@return block duplicates what a schema would normally carry. The useful hint about prompting the customer is buried mid-block rather than front-loaded, so the definition is both padded and poorly ordered.

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?

Five required parameters, no annotations, no output schema, and two parameters undocumented by either the schema or the description. The return value is described only as 'a json object', leaving the agent without the information needed to handle the response.

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 0%, so the description must compensate. It does document three of five parameters — api_key as the application key, token and wallet_fk as values from /access/login — and the enumeration of platforms is embedded in the first sentence. But user_id and platform are never described as parameters, and no formats or constraints are given.

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 opens with a specific verb and resource: 'Assigns this wallet_fk to a channel (discord, telegram, whatsapp) user id.' That is enough for an agent to distinguish it from access_platform_login or account_pair. It stops short of naming a sibling it must not be confused with, but the resource is precise.

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 line 'Where possible prompt the customer to do this, as it makes getting a token much easier in the future' gives a real usage cue about when to invoke it. However, there is no guidance on prerequisites, sequencing relative to access_platform_login, or 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?

With no annotations, the description carries the full burden, and it does disclose a genuinely important behavior: a single failed PIN attempt forces the user back to the website for a session key. That is real added value. It still omits token lifetime, what is actually returned, and any auth/prerequisite context.

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 core fact ('retrieves a token from wallet_fk + PIN') is stated three separate times, and the '@return a json object' line is near-contentless. The single-attempt warning is the only sentence that earns its place, so the description is padded rather than 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?

For a login/credential-exchange tool with no annotations and no output schema, the description omits what the token is, how it should be used downstream, and whether it expires. The one-attempt warning is valuable, but an agent still lacks enough to handle the failure path or the returned value confidently.

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 0%, so the description must compensate, and it does define both parameters: wallet_fk as the wallet identifier and pin as the 5-digit numeric PIN. It never explains what wallet_fk refers to (a foreign key to a wallet record) or whether the PIN is client- or server-validated, leaving the compensation partial.

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: retrieves a token given a wallet_fk and a 5-digit PIN. The purpose is unmistakable, but it never names or distinguishes itself from potentially overlapping siblings like netfluid__session or netfluid__session_2_token, so it is clear without being sibling-differentiated.

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?

Offers one contextual hint ('if you have a wallet_fk but no token, it's a shortcut to the token') and a critical constraint (only 1 attempt). However, it never routes the agent to alternatives such as session_2_token or access_recover, so the when-to-use-this-vs-those guidance is only implied.

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. It discloses the assignment precondition and states the return is a json object, but says nothing about auth requirements, pagination, or error behavior. The precondition is genuine added value, but coverage remains partial.

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 opening sentence is repeated almost verbatim in the second line, wasting space on redundancy. The content is front-loaded and otherwise compact, but the duplication is a clear structural flaw.

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 list tool with no output schema and no annotations, the description covers purpose, precondition, parameter meanings, and the return shape. It is adequately complete, missing only deeper error/pagination detail.

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 0%, so the description must compensate, and it does: user_id is explained as the channel-specific customer id, and platform is given concrete values (discord, telegram, whatsapp) that the schema does not encode as an enum. This adds real meaning 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 verb (Retrieves) and resource (list of wallets) with scope (associated with channel and user id), so an agent can identify the operation. There is no sibling with a near-identical name to differentiate against, though the verb+resource pairing is clear.

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 precondition — 'only works if the wallet_fk has been previously assigned to this channel and user id' — which is useful context for when the call succeeds. However, it names no alternative tools and does not say when to prefer this over other access/wallet listings.

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. It does disclose the return payload (private key, first_name, last_name, mobile, email), which is meaningful given the missing output schema and signals sensitive PII/secret material. But it says nothing about auth requirements beyond api_key, failure modes, or the security weight of returning a private key.

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 first sentence is duplicated verbatim, and a truncated sentence plus docstring artifacts ('@param', '@return: a json object') leak into the text. The front-loaded sentence is fine, but there is clear waste and a broken fragment.

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 explaining the return object is the right call and partially covers that gap. A 2-param tool is simple, but the definition omits when-to-use guidance and security/permission context, leaving it only minimally 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 coverage is 0%, so the description must compensate, and it does: it documents both parameters, giving 'api_key' purpose ('allocated to your application') and 'words' format ('a set of 24 recovery words, space delimited'). The word-count and delimiter detail is genuinely additive beyond the bare 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?

States a specific verb and resource: 'Recovers the Netfluid wallet's private key from a set of 24 keywords.' Clear about the operation. However, it does not distinguish itself from the closely related sibling netfluid__wallet_mnemonic, leaving ambiguity about when recovery differs from plain mnemonic retrieval.

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 usage-adjacent text is a truncated fragment: 'It's preferable that the person trying to recover' — the condition is cut off mid-sentence, so no real guidance lands. No when-to-use, no prerequisites, and no routing against wallet_mnemonic or account_unlock.

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 empty annotations, the description carries the full behavioral burden. It does disclose one meaningful trait beyond the schema: the operation requires an api_key with administrator privileges. Beyond that it says nothing about side effects, reversibility, or rate limits, so it is only partially transparent.

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 size is reasonable, but the structure is marred by a wrong leading sentence (copied from the pause operation) followed by the correction, and the @return line ('a json object') is near-empty filler. Every sentence should earn its place; the first one actively harms.

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 mutation tool with no annotations and no output schema, the description should explain effects and return shape. It covers both parameters and the auth requirement but gives only '@return: a json object,' leaving the response contents and side effects unexplained.

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 0%, so the description must compensate, and it does document both parameters: api_key (with administrator privileges) and wallet_fk (the wallet to resume). The privilege qualification on api_key adds real semantic value beyond the bare schema types, though wallet_fk's entry is largely a restatement.

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 lead sentence ('Temporarily blocks access to the wallet') describes the opposite operation from the tool name and the following sentence, creating an internal contradiction that could mislead selection. The second sentence does state a specific verb+resource ('Resumes access to a paused wallet'), so the correct purpose is recoverable, but the erroneous first line erodes clarity and fails to cleanly distinguish it from the sibling netfluid__access_pause.

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?

'Resumes access to a paused wallet' implies the condition for use (a paused wallet), and the admin-privilege requirement is stated, which is genuinely useful. However, no alternative sibling (e.g., netfluid__access_pause) is named, and there is no explicit when-not 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?

Annotations are empty, so the description carries the full behavioral burden. It does not say whether the change is reversible, what permissions are required, whether an existing PIN or confirmation is needed, or what the response contains beyond 'a json object'.

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 opening sentence is repeated twice, and the raw @param/@return docstring formatting is carried through verbatim. This is wasted space that makes the definition harder to scan, though the parameter block itself is compact.

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 4-parameter mutation tool with no annotations and no output schema, the parameter coverage is adequate but behavioral context is missing. The description should say more about auth requirements and the effect of the change to be 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 0%, so the description must compensate, and it does document all four parameters and their provenance (token and wallet_fk come from /access/login). The 5-digit numeric constraint on new_pin is a useful addition, though types are still not stated in prose.

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 verb and resource ('Changes the wallet PIN') and adds a format constraint, so an agent knows exactly what the tool does. However, it does not differentiate itself from any sibling tool, and the purpose sentence is duplicated verbatim, which weakens the signal.

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 call this versus alternatives, nor any precondition beyond the parameter list. The agent is left to infer that this is the PIN-reset path rather than, say, a login or recovery flow.

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 are empty, so the description carries the full burden. 'Returns public information' implies a safe read, but there is no mention of authentication, permissions, rate limits, or what happens on an invalid account_fk. The '@return: a json object' clause conveys essentially no behavioral information.

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?

Short and front-loaded, which is good, but the trailing '@return: a json object' is boilerplate that adds no value. The whole description is terse to the point of under-specification rather than genuinely concise.

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 read tool with no annotations and no output schema, the description should at least clarify the parameter and differentiate it from the numerous sibling lookups. It leaves both the input semantics and the sibling routing unresolved.

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 0% and the description only repeats the parameter name 'account_fk' without explaining what it identifies or where it comes from. With a single required parameter undocumented in both schema and prose, the description fails to compensate.

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 ('Returns public information associated with an account_fk') and enumerates the fields returned (address, commodity, currency, type). It is clear on its own, but it does nothing to distinguish itself from near-identical siblings such as netfluid__account_info, netfluid__account_address, or netfluid__account_types.

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 guidance on when to call this versus the many sibling account/wallet tools. No preconditions, no alternatives, no exclusions are mentioned.

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. It does convey that this is a non-mutating check (validate/verify existence) rather than a write, but the return body is only described as 'a json object', with no indication of what fields or validity signal come back or what failure looks like.

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 core purpose is front-loaded in one sentence, which is good, but the trailing '@return: a json object' is pure filler that conveys nothing actionable and slightly dilutes an otherwise tight definition.

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, non-mutating lookup this is near-minimum viable: no annotations, no output schema, and the description doesn't say whether the response is a boolean validity flag or an object, nor how invalid addresses are surfaced. It is adequate but has identifiable gaps.

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 0% and the single parameter is undocumented, so the description must compensate. It does add real meaning by clarifying that account_address is a Netfluid account address rather than a blockchain address, which resolves the most likely agent confusion, but gives no format, length, or example.

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 pair (validates, verifies existence) against a specific resource (Netfluid account address), and the parenthetical '(not blockchain address)' usefully separates it from the many crypto_* siblings. It falls short of 5 only because it doesn't name or contrast with the nearest sibling (netfluid__account, netfluid__wallet_verify).

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 parenthetical hints at a negative case (not a blockchain address), but there is no explicit when-to-use, when-not-to-use, or named alternative among the ~110 siblings. An agent must infer the context from the name alone.

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 full burden. It does disclose that confirmation is required before execution and that account_fk is an internal database ID rather than an address and may not be 0 — real behavioral value. It says nothing about whether overwriting an existing alias is destructive, whether the operation is idempotent, or what errors/permissions to expect.

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?

Purpose is front-loaded, which is good, but the opening sentence is immediately restated as 'Sets a friendly name/alias on an account_fk' — redundant. The @param/@return block is standard and readable, but the duplication costs efficiency.

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 4-param mutation with no annotations and no output schema, the description covers every parameter plus the confirmation requirement, which an agent needs before calling. Missing details on overwrite semantics or failure modes keep it from being 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 0%, so the description must compensate, and it largely does: it defines all four parameters including the source of token (/access/login) and two important constraints on account_fk (it is an int database ID, not a string address, and may not be 0). Coverage is good though api_key is described only generically.

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: 'Sets a friendly name/alias on an account.' That is unambiguous against siblings like account_info or account_pause. It stops short of naming any alternative tool or scoping condition, but the operation itself is clearly identified.

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?

'Confirm (yes/no) before executing' gives the agent one concrete usage instruction for a mutation. Beyond that there is no when-to-use/when-not guidance and no alternative tool is referenced. Adequate but thin.

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. It discloses the confirmation-before-execution step, but says nothing about auth requirements (api_key/token are only implied), whether the purchase is reversible, or failure behavior for a financial mutation.

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 core action, but the opening sentence is repeated word-for-word and the @return tag ('a json object') is filler. The @param block is structured but the duplication wastes space.

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 parameters well, but for a financial mutation with no annotations and no output schema it omits return structure (just 'a json object'), auth expectations, and failure/irreversibility details an agent would want.

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 0%, so the description must compensate, and it does: it documents all four params via @param tags. Notably it clarifies account_fk is a database int ID (not an address) that may not be 0, and that token comes from /access/login — meaningful value beyond the bare 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?

States a specific verb (Purchases), resource (digital asset), and source of funds (account's FIAT balance). This distinguishes it from siblings like account_sell or crypto_swap, though the sentence is duplicated verbatim, adding no extra value.

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 'Confirm (yes/no) before executing' instruction gives a usable workflow cue, and the fiat-to-asset framing implies when it applies. However, it never states when to prefer this over account_sell, crypto_swap, or crypto_spend, so alternatives are left to inference.

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 full burden. It does disclose that this is a purchase that deducts from a specified account and that confirmation is required first, which is meaningful behavioral context. But it says nothing about irreversibility, failure modes (e.g. insufficient balance), or what the returned JSON contains beyond 'a json object'.

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 opening sentence is duplicated verbatim, wasting space at the front, and it is followed by JSDoc tags pasted in wholesale. The parameter details earn their place, but the repetition and mixed prose/JSDoc structure hurt front-loading.

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 mutating, money-moving tool with no annotations and no output schema, the definition covers inputs well and flags the confirmation step, but leaves the return value completely unspecified and omits any failure or balance-check behavior. Adequate but with clear gaps.

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 0%, so the description must compensate, and it largely does: it documents all five parameters, clarifies that account_fk is an integer database ID rather than an address (and cannot be 0), specifies amount is currency with 2 decimals, and gives currency code examples. Only the token/api_key origins are touched lightly.

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 (purchase airtime) plus the distinguishing mechanism (converting currency to minutes and seconds), which separates it from generic siblings like account_buy or account_pay. However, it never names those siblings explicitly, so the agent must infer the boundary from the name alone.

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 usage guidance is 'Confirm (yes/no) before executing', which is about a workflow step, not about when to choose this tool over account_buy, account_pay, or fund_ott. No prerequisites (e.g. needing a valid account_fk and token) or exclusions are stated.

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 are empty, so the description carries the full burden. It does disclose real behavior: a confirmation gate before execution and a hard PIN requirement for completion, plus api_key/token auth. It omits irreversibility, failure behavior, and rate limits, which matters for a money-moving mutation.

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 core sentence 'Charges the account based on a presented QR-code or NFC card' is repeated verbatim in the opening and again in the body, wasting space. The rest is a functional JSDoc block, and key constraints (confirmation, PIN) are front-loaded, but the duplication costs it.

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 7-parameter payment mutation with no annotations and no output schema, the definition covers inputs well but returns only 'a json object' and says nothing about error cases, idempotency, or what a successful charge response contains. Adequate but leaves meaningful gaps for a high-stakes 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 0%, so the description must compensate, and it largely does: it disambiguates account_fk (an int database ID, not an address, may not be 0, and is the merchant receiving payment) from account_address (the account charged), and clarifies token provenance (/access/login) and that pin belongs to account_address. Only amount and note get no added meaning.

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 ('Charges the account') plus the triggering mechanism ('presented QR-code or NFC card'), which distinguishes it from generic siblings like account_pay or account_send. However it never names or excludes those siblings explicitly, so the differentiation 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?

It gives an operational instruction ('Confirm (yes/no) before executing') and a prerequisite ('The payer must present a valid PIN'), which implies the usage context. But with many overlapping payment siblings (account_pay, account_send, account_wire, account_merchant_voucher_redeem), there is no explicit when-to-use-this-vs-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?

Annotations are empty, so the description carries the full disclosure burden. It states only that a json object is returned, with no mention of auth scope beyond the params, error or failure behavior, or what 'detailed' actually covers.

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 core claim is front-loaded, but the sentence 'Returns detailed account information' is duplicated almost verbatim before the balances clause, wasting space. The docblock @param/@return style is otherwise readable.

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 and no annotations, the agent relies entirely on the description, which reduces the return value to 'a json object' without hinting at fields or structure. The parameter coverage is complete, so it is adequate but leaves the response shape opaque.

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?

With 0% schema description coverage, the description must compensate, and it does: all three params are documented, and account_fk gets valuable disambiguation (a database int, not an address, not 0, sourced from /wallet/accounts_list). The api_key and token notes are brief but sufficient.

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 operation ('returns detailed account information and balances'), which is more than a tautology. However, it offers no differentiation from close siblings such as netfluid__account, netfluid__account_statement, or netfluid__wallet_accounts_list, so an agent cannot tell which one gets account details versus statements versus lists.

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. The only implied workflow cue is the note that account_fk comes 'as provided by /wallet/accounts_list', which hints at a prerequisite call but never states the routing logic against alternatives.

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 are empty {} so the description carries the full behavioral burden. It does disclose two valuable traits: this mutates funds by performing a FIAT withdraw, and it is restricted to FIAT balances. It says nothing about permissions/authentication beyond the api_key/token params, irreversibility, idempotency, fees, or failure behavior — significant omissions for a money-moving operation 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?

Front-loaded with the purpose and constraints, then uses compact @param/@return tags. Every element carries information and there is no filler, though 'Issues a Netfluid voucher' and 'Performs a FIAT withdraw' partially overlap in what they convey.

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 no annotations, so the description should compensate more than it does: '@return: a json object' tells the agent nothing about the response shape, voucher identifier, or new balance. Parameters and the FIAT-only constraint are covered, but the return contract and the quote/redeem workflow context are missing for a financial mutation.

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 0%, so the description must compensate, and it largely does: it documents all four parameters, and the account_fk note (a database int ID, not a wallet address string, and must not be 0) adds real disambiguation not present anywhere else. Only 'amount' is described thinly ('The amount to issue for'), with no units, precision, or min/max meaning.

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 ('Issues a Netfluid voucher') plus the mechanism ('Performs a FIAT withdraw'), which is more than a restatement of the name. The verb 'issue' does separate it from the sibling verbs 'quote' and 'redeem', but the description never names those siblings, so differentiation is left to the reader.

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 one conditional constraint ('Only applicable on FIAT balances'), which rules out non-FIAT balances. However there is no guidance on the obvious workflow alternatives: the sibling netfluid__account_merchant_voucher_quote (presumably needed first to price the voucher) and netfluid__account_merchant_voucher_redeem (the counterpart operation) are never mentioned, so the when-to-use-vs-alternatives question is only implied.

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 full burden. It partially compensates by disclosing what the call returns (merchant commission and customer-charged amount), which tells the agent this is a non-mutating preview. But '@return: a json object' is uninformative, and prerequisites, quote validity/expiry, and error behavior are unstated.

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 first sentence and the 'STEP 1:' sentence are largely redundant restatements, and the opening line contains a grammatical error ('quote to before issuing'). The parameter block is well organized, but the prose is repetitive rather than 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?

For a 4-required-param tool with no annotations and no output schema, the description covers parameters and the substantive return contents (commission, charged amount), but omits authentication flow context beyond parameter notes, quote lifetime, and failure modes. Adequate but with visible gaps.

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 0%, so the description must compensate, and it does: it documents all four parameters, including the critical clarification that account_fk is a database integer (not a wallet address) and may not be 0, and that amount is expressed with up to 2 decimals. Format details for token origin (/access/login) are also given.

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 ('Performs a quote to issue a voucher as a merchant') and clarifies it's a pre-step ('STEP 1', 'to before issuing'). It does not name the sibling voucher_issue explicitly, but the sequencing language distinguishes it functionally from the other merchant voucher 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?

The 'STEP 1' framing implies this quote precedes netfluid__account_merchant_voucher_issue, which is useful implied usage. However, there is no explicit when-to-use/when-not statement, no named alternative, and no guidance on what to do with the returned quote.

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 full burden. It usefully reveals the auth dependency (token comes from /access/login) and a real constraint (account_fk is a DB integer, not an address, and may not be 0). But it omits whether redemption is irreversible, whether the voucher is single-use, what happens on an invalid/used code, and what permissions are required.

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 sentence is front-loaded and the docblock form makes parameters scannable. The @param/@return scaffolding is slightly verbose for a tool description, but every line carries information and nothing is wasted.

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 4-required-param mutation with no annotations and no output schema, parameter coverage is good but outcome behavior is thin: '@return: a json object' says nothing about the success payload, and failure/idempotency semantics are absent. Adequate but with clear gaps.

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 0%, so the description must compensate, and it largely does: each of the 4 parameters is documented, including token provenance (/access/login), the account_fk type/caveat, and the voucher_code format (1234-0000-4321-5678). Only minor gaps remain, such as whether account_fk must belong to the caller.

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: 'Redeems a Netfluid voucher.' An agent knows exactly what operation this performs. However, it does not distinguish itself from close siblings such as account_merchant_voucher_issue, account_merchant_voucher_quote, or netfluid_voucher_check, which all concern vouchers.

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 guidance, no prerequisites, and no mention of alternatives (e.g., check the voucher first via netfluid_voucher_check, or quote it before redeeming). Usage must be entirely inferred from the tool name.

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 disclosure burden, and it does add real behavioral context: there are costs, minting is asynchronous, and the account may take several seconds to appear, plus a human confirmation step. It stops short of saying what the costs are, whether the operation is reversible, or what permissions/state the wallet must be in.

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 opening paragraph is duplicated verbatim ('Mints a new account of an account type into the wallet...'), roughly doubling the size of the description with zero added information. The key purpose statement is front-loaded and the @param list is informative, but the redundant block is pure 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 state-mutating tool with no annotations and no output schema, the description covers the essentials an agent needs (costs, async latency, human confirmation, parameter lookup paths). It is still thin on failure modes, reversibility, and what the returned JSON contains, which matters given there is no 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?

Schema description coverage is 0%, so the description must compensate, and it largely does: every one of the five parameters is annotated, including the non-obvious defaults (account_type_fk default Solana 7, currency_fk default ZAR 7) and lookup endpoints for both fk values. It does not explain the format or scope of api_key/token beyond provenance.

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 first line states a specific verb and resource: 'Mints a new account of an account type into the wallet.' That is enough to separate it from siblings like account_buy, account_pair or wallet_accounts_list. It does not, however, explicitly contrast itself with the other account-creating or funding 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?

The description gives one concrete procedural instruction ('Confirm (yes/no) before executing') and points to /account/types and /currency/list for resolving the two fk parameters. It never says when to prefer this tool over account_buy, account_pair, or other account-onboarding siblings, so the usage guidance is implied rather than explicit.

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. It does disclose one important behavioral trait — that the agent must obtain yes/no confirmation before executing — plus the PIN length (5 digits) and expiry timezone. It does not say what happens on re-pairing, whether the PIN can be overwritten, or what authorization level is needed.

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 opening sentence is duplicated verbatim ('Assigns a PIN to an account...' appears twice), wasting the most valuable front-loaded position. The @param block is compact and useful, but the redundancy shows poor structure.

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 5-parameter mutation tool with no annotations and no output schema, the description covers the parameters and one behavioral rule (confirm first), but leaves out permission requirements, side effects on existing PINs, and any sense of the return object beyond '@return: a json object'.

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 0%, so the description must compensate, and it largely does: it documents all five parameters, including pin as 'The 5 digit numeric PIN e.g 01234', expire_date as optional with the exact format 'YYYY-MM-DD HH:MM:SS, in GMT', and token's provenance ('provided by /access/login'). Only address and api_key are defined minimally.

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: 'Assigns a PIN to an account for use by a QR-Code or NFC card.' This distinguishes it from the nearby sibling netfluid__access_wallet_pin_change and netfluid__account_unlock by naming the PIN/QR/NFC pairing use case, though it never explicitly contrasts with those alternatives.

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 the intended context (PIN used by a QR-Code or NFC card) and a procedural instruction ('Confirm (yes/no) before executing'), but no explicit when-to-use versus a PIN change or account unlock, and no stated prerequisites beyond the auth params.

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 load. It does disclose important behavioral traits: reversal requires an administrator, the lock parameter is customer-irreversible, and confirmation is needed before execution. It omits whether the pause is idempotent, what happens to in-flight transactions, and what the returned JSON contains beyond 'a json object'.

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 opening paragraph is duplicated verbatim, wasting roughly half the text, and the '@param'/'@return' markers are raw doc-comment artifacts rather than prose. The key warning is front-loaded, but the redundancy is a clear structural defect. (Note also the typo 'funds existing the account' for 'exiting'.)

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 destructive, admin-reversible mutation with no annotations and no output schema, the description covers the essentials (irreversibility, lock semantics, confirmation). It still leaves the return payload undefined and does not describe side effects or error conditions, so it is adequate rather than 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 coverage is 0%, so the description must carry the parameter burden, and it largely does: it explains account_fk is a database int ID (not an address) and cannot be 0, and that lock=1 applies a system lock the customer cannot remove. api_key and token are named but only minimally explained, which is the only gap.

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 action and target: it temporarily restricts an account from moving funds out. The verb+resource pair ('pause' an 'account') is clear and distinguishable from siblings like account_resume and account_unlock. It does not, however, explicitly contrast itself with those siblings (access_pause, account_unlock).

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 a caution: 'Can only be undone by an administrator, warn before using! Confirm (yes/no) before executing.' That is an operational warning, not guidance on when to choose this tool versus account_unlock, access_pause, or other restriction mechanisms. No prerequisite or alternative-selection logic 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?

Annotations are empty, so the description carries the full burden. It does disclose two useful traits the schema cannot express: the operation charges the account (a mutation), and it must be confirmed with the user first. It says nothing about reversibility, failure modes, permission requirements, or what the resulting transaction does to the account balance.

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 first line and the sentence after the confirmation prompt are verbatim duplicates, wasting the highest-value position. The body is a raw code-comment dump with @param/@return tags rather than prose front-loaded around the action the agent must take.

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 5-parameter mutation tool with no annotations and no output schema, the description covers the inputs well and adds the confirmation requirement, which is the single most important behavioral note. It stops short of describing the response ('a json object' is empty), error conditions, or how the charge settles, so it is adequate rather than 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 0%, so the @param block is doing all the work and it largely succeeds: it explains that account_fk is a database integer rather than an account address and may not be 0, that token comes from /access/login, and that api_key is the application's key. Only amount and note are left as bare restatements, with no currency or unit given for amount.

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 opening clause states a concrete verb and resource ('Charges the account a transaction fee'), so an agent knows a money-moving charge is being performed. What it lacks is any differentiation from close siblings such as netfluid__account_charge, netfluid__account_buy, or netfluid__account_send, which occupy the same semantic space.

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?

'Confirm (yes/no) before executing' is a real procedural instruction that tells the agent to gate the call on user confirmation. But there is no guidance on when to pick this over account_charge or the other payment siblings, and no prerequisites beyond the parameter docs, so usage is only implied.

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 supplied, so the description carries the full behavioral burden. It does disclose two genuinely useful traits: the action is administrator-gated for reversal and it should be confirmed before executing. It stops short of describing auth/permission requirements, error conditions, or what state changes on success beyond 'full trading capability'.

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 opening sentence is duplicated verbatim (once inline, once at the start of the JSDoc block), which is pure redundancy an agent must read past. The @param lines are information-dense and well front-loaded, but the duplication and the vague '@return: a json object' dilute an otherwise tight description.

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 state-changing, admin-gated account operation with no annotations and no output schema, the description covers parameters and the confirmation requirement adequately. It is still thin on outcome semantics: the return is dismissed as 'a json object' and there is no mention of failure modes (e.g., already-active account) or authentication/scope requirements.

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 0%, so the description must compensate, and it largely does: account_fk is flagged as a database integer (not an account address) that may not be 0 and is obtained from /wallet/accounts_list, and token is sourced from /access/login. api_key is described only generically ('allocated to your application'), so the compensation is good but not complete.

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 ('Resumes full trading capability for an account that has been previously paused'), which is clearly distinct from the pause operation. However, it never differentiates itself from the sibling netfluid__access_resume, which an agent could easily confuse with this account-scoped variant, so sibling differentiation is incomplete.

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 precondition is implied ('an account that has been previously paused') and the description adds a confirmation requirement ('Confirm (yes/no) before executing'), which is useful invocation guidance. It does not name alternatives such as netfluid__account_pause or netfluid__access_resume, and the sentence 'Can only be undone by an administrator' is ambiguous about whether it describes reversibility of the resume or who may pause again.

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 empty annotations, the description carries the full burden. It usefully discloses that this is a confirmation-gated trade that credits proceeds to FIAT, but says nothing about irreversibility, required permissions beyond the auth params, failure modes, or rate 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?

The core sentence is front-loaded and clear, but the opening sentence is duplicated verbatim and the JSDoc @param tags largely restate parameter names, adding bulk without new meaning.

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 financial mutation tool with no annotations and no output schema, the description covers purpose, confirmation, and all params, but leaves the return value ('a json object') unelaborated and omits safety/mutation details an agent would need to invoke it reliably.

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 0%, so the description must compensate, and it does document all five parameters. The note that account_fk is a database integer ID (not an address) and may not be 0 is genuinely valuable beyond the schema, though several params (amount, digital_asset_fk) are only minimally restated.

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 (sells), resource (a digital asset), and outcome (proceeds to the account's FIAT balance), which naturally distinguishes it from siblings like account_buy and account_swap. It stops short of naming those alternatives explicitly, so it is clear but not sibling-differentiating.

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 usage directive is 'Confirm (yes/no) before executing', which tells the agent a confirmation step is required but gives no when-to-use/when-not-to-use guidance or alternatives. Usage context is implied rather than 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 annotations empty, the description carries the full burden. It usefully discloses that FIAT is converted to the destination currency and that transfers can cross wallets, but says nothing about irreversibility, permissions beyond the api_key/token params, failure behavior, or rate limits. The dangling 'Confirm (yes/no)' statement adds ambiguity rather than transparency.

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?

Purpose is front-loaded, and the param list earns its space given 0% schema coverage. However the opening is duplicated almost verbatim across two sentences ('Sends FIAT ... Optionally save as a beneficiary'), and the stray 'Confirm (yes/no) before executing' dangles without a corresponding field.

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 money-movement tool with no annotations and no output schema, this leaves key questions open: how the stated confirmation is supposed to be performed, what the returned 'json object' contains, and whether the transfer is reversible. Parameter documentation is solid, but the safety and interaction model is incomplete.

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 0%, so the description must compensate, and the @param block does substantial work: it disambiguates account_fk (an int database ID, not an address) from destination (a user-readable address string), and clarifies save as 0/1 and name as applicable only when save=1. This resolves the most confusing parts of the schema. It loses a point only because it does not fix the schema's apparent type error on 'name' (typed integer).

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: 'Sends FIAT from this account to another Netfluid account', and adds scope details (converted to destination currency, cross-wallet). It is clearly distinguishable from withdraw_to_bank or beneficiary_add, though it never explicitly contrasts itself with nearby siblings like account_wire, account_pay, or account_swap.

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 usage-ish instruction is 'Confirm (yes/no) before executing', but no such confirmation parameter exists in the schema, so the guidance is unactionable and confusing. There is no when-to-use/when-not guidance and no routing away from account_wire, account_pay, or account_swap.

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 well: it discloses that the account is charged, that charging is per submission and per 160 characters, that delivery is not guaranteed, that only SA/Botswana/Zimbabwe/UK are supported, and that the api_key needs admin privileges. It omits failure/reversal behavior and rate limits, but the side-effect profile is unusually well covered.

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?

Information is front-loaded and the @param blocks are useful, but the first two sentences restate the same fact ('Sends a Mobile SMS and charges this account' / 'Sends a SMS and charges this account'), which is pure duplication. The @return line is also low-value.

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 5-required-param mutation with no annotations and no output schema, the description is largely self-sufficient: parameters, cost model, and channel limitations are all present. The weak spot is the return value, dismissed only as 'a json object', leaving success/failure signaling undocumented.

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 0%, so the description must compensate and it does: all five parameters are documented with real semantics – admin-scoped api_key, token provenance (/access/login), account_fk as a non-zero integer database ID from /wallet/accounts_list (explicitly not an address string), mobile in e164 without '+', and message billed per 160 chars.

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 opening states a specific verb and resource – 'Sends a Mobile SMS and charges this account' – and the SMS channel inherently distinguishes it from siblings like send_email and push_message_send. An agent can tell what the tool does at a glance.

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 'Confirm (yes/no) before executing' instruction is a genuine workflow guideline and the limited-destination list scopes where it can be used. However, it never states when to prefer this over send_email or push_message_send, nor any prerequisites beyond admin privileges.

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 disclose meaningful behavior beyond the schema: default of 1000 rows when max_rows is omitted, default of 60 days of data, GMT timezone for start_date, and the auth chain (api_key plus token from /access/login). It stops short of describing pagination, rate limits, or permissions, so it is strong but not complete.

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 @param block is appropriately dense and front-loads the defaults, but the first two sentences are near-duplicates ('Returns detailed account FIAT statement' / 'Returns detailed account statement from a start date...'), so one sentence does not earn its place.

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 5-parameter, all-required read tool with no annotations and no output schema, the description covers all inputs, their defaults, and the auth prerequisites. The only thin spot is the return value, dismissed as 'a json object' with no hint of the entry fields, which matters given there is no 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?

Schema coverage is 0%, so the description must compensate entirely, and it does: every one of the 5 parameters is documented with meaning, format, and defaults. The account_fk note (database ID int, not an address str, may not be 0, sourced from /wallet/accounts_list) is exactly the kind of disambiguation an agent needs to avoid a wrong call.

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 opening states a specific verb and resource ('Returns detailed account FIAT statement') and the second sentence adds the scoping inputs (start date, max entries). However, it never distinguishes itself from near-siblings like netfluid__account_info or netfluid__wallet_accounts_list_verbose, so an agent cannot easily tell which of these returns the statement versus a balance or account list.

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 explains what the tool returns but gives no when-to-use guidance, no exclusions, and no alternative tools. An agent must infer from the name alone that this is the read path for statement history versus netfluid__account_info.

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. It usefully discloses the required human confirmation step, the auth inputs (api_key and a token from /access/login), and the FIAT sentinel convention, but it says nothing about reversibility, permissions, rate limits, or failure behavior for what is inherently a mutating financial 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?

The opening sentence is duplicated almost verbatim ('Swaps one digital asset for another on an account level') before the JSDoc-style @param block, and the @return note ('a json object') is near-empty filler. The parameter documentation is valuable, but the structure wastes space on repetition.

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 7-parameter mutation tool with no annotations and no output schema, the description covers purpose, every parameter, authentication, and the confirmation/ FIAT conventions. The only real gap is the unspecified response shape, which matters less given swaps are typically fire-and-confirm.

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 0%, so the description must compensate, and it does: it documents all seven parameters, warns that account_fk is an integer database ID (not an address) and may not be 0, and explains the digital_asset_fk=0 / to_digital_asset_fk=0 convention for indicating FIAT. This adds meaning well beyond the bare types in 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?

States a specific verb (swaps) and resource (one digital asset for another) with scope ('account level'), which implicitly separates it from the blockchain-level crypto_swap/crypto_dex_swap siblings. It does not explicitly name the alternative tools, so the differentiation 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?

The description front-loads a useful interaction rule ('Confirm (yes/no) before executing') and scopes the operation to the account level, but it never says when to choose this over netfluid__crypto_swap or netfluid__account_sell, nor what prerequisites must hold before swapping. Usage is implied rather than guided.

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 disclosure burden. It adds one genuinely useful behavioral trait ('typically static information', implying the result is cacheable and slow-changing), but does not state that this is a read-only operation, confirm no side effects, or describe error/auth behavior. A single hint is insufficient for a no-annotation 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?

The description repeats 'Lists all account types' twice and carries over raw docstring artifacts (@param, @return). Roughly half the text is redundant, though the core statement 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?

For a trivial one-parameter list endpoint with no output schema and no annotations, the description covers the input and notes the return is a JSON object. It is minimally complete, but does not describe what an 'account type' contains or how results are shaped, leaving the return value under-specified.

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 0%, so the description must compensate for the single api_key parameter. It does explain the parameter ('The api key allocated to your application'), which the schema omits, covering the only input. It stops there, with no format or scope detail beyond the generic definition.

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 clear verb+resource ('Lists all account types') and adds the useful qualifier that the data is 'typically static'. However, it does not differentiate itself from nearby sibling list tools such as currency_types, commodity_types, or telco_accounts, so an agent gets a clear purpose but no disambiguation.

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 indication of when to call this versus alternatives, nor any prerequisites beyond the required api_key. The 'typically static information' note hints that results are stable, but no when-to-use or when-not-to-use guidance 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 at all, the description carries the full burden and does add real behavior: the exact state change, the requirement that api_key have admin privileges, and a confirmation gate before execution. It does not cover error cases (e.g. account not currently locked) or reversibility, so it falls short of 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?

The critical line is front-loaded well, but the description wastes space repeating the purpose sentence and mixes an MCP description with JSDoc-style @param/@return tags. Every sentence is not earning its place.

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 3-required-param mutation with no annotations and no output schema, the description covers the inputs and the state transition but leaves the return value as a bare 'a json object' and says nothing about failure behavior. Adequate but with clear gaps on the return contract.

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 0%, so the description must compensate and largely does: api_key (admin privileges required), token (wallet_api_token from /access/login), and account_fk (a database int ID, not an address, must not be 0, sourced from /wallet/accounts_list). It adds format and source context the bare schema lacks, though the api_key/token string formats remain unspecified.

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 ('Unlocks a locked account') plus the exact state transition (status_fk=10 to status_fk=1), which is enough to distinguish it from siblings like account_pause and account_resume. The only blemish is the verbatim repetition of 'Unlocks a locked account.' in the second line.

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 state transition — you call it when an account is in status_fk=10 — and it adds a 'Confirm (yes/no) before executing' step. However, it names no alternatives (e.g. account_resume/account_pause) and gives no explicit when-not-to-use condition, leaving the agent to infer the trigger.

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 load. It discloses non-obvious behavior: FIAT auto-conversion, a yes/no confirmation gate, and the same-blockchain constraint. But it is silent on irreversibility, fees, permission/auth requirements, and rate limits — important for a high-stakes wire 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?

Purpose is front-loaded and the @param block is well organized, but the opening sentence is duplicated verbatim, which is pure waste. The '@return: a json object' line is uninformative 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 7-parameter mutation with no annotations and no output schema, the description covers parameters and core mechanics but leaves gaps around auth, fees, failure modes, and the actual response shape. Adequate but short of complete for a funds-transfer 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 description coverage is 0%, so the description must compensate, and it does document every parameter via @param lines. It adds genuine meaning beyond types, e.g. account_fk is a DB ID not an address and may not be 0, and digital_asset_fk=0 means FIAT.

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 ('Sends FIAT or Digital Assets from this account to a blockchain address') and adds the material scope detail that FIAT is converted by the system. This is enough to distinguish it from fund-moving siblings like account_send or withdraw_to_bank, though it never names an alternative 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?

Implicit usage is clear (move funds out of an account) and it states a real prerequisite ('The FIAT account must be associated to the same blockchain as the destination address') plus a confirmation requirement. However, it never says when to choose this over account_send, account_pay, or crypto_spend, so routing between siblings is left to inference.

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 present, so the description carries the full burden, and it discloses almost nothing: only '@return: a json object'. It does not say that this is an external LLM call (latency, cost, non-determinism), whether the prompt or response is logged, whether the call requires an authenticated session, or how errors 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 JSDoc-style block is short, front-loads the single purpose sentence, and every line is scannable. The only waste is the redundant '@param prompt: The string prompt' restatement.

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 four-required-parameter call with no annotations, no output schema, and 0% schema coverage, the description documents the inputs but leaves the behavior opaque: nothing about the auth flow ordering, the shape or content of the JSON response, or the cost/latency of an LLM invocation. An agent has enough to construct the call but not to predict its effect.

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 0%, so the description must compensate, and it does meaningfully: it documents all four parameters and supplies provenance that the schema lacks (token is 'the wallet_api_token provided by /access/login'; wallet_fk likewise comes from that login flow). It loses points only for circular entries like 'prompt: The string prompt', which add nothing.

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 concrete action on a concrete resource: it sends a prompt to Gemini AI and returns a result. That is enough to distinguish it from every sibling (all of which are wallet/payment operations), though it never frames itself relative to those siblings or explains why an agent would use an AI call inside this API.

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 guidance, no prerequisite ordering, and no mention of alternatives. An agent cannot tell from the text when invoking Gemini is appropriate versus using the domain-specific tools around it, nor what must happen before this call (e.g. that a login token is required first).

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 substantial work: it discloses the 30-second latency, that the sponsor must be KYCed, that a Solana wallet is auto-minted, that the human assumes legal responsibility, and strongly warns the caller to persist wallet_fk and PIN. It omits error/failure behavior and whether the call is idempotent or costs money.

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?

Purpose is front-loaded, but the body is bloated with marketing filler ('own wallet, own bank accounts and blockchain wallets without limitations') and typos ('agents payments'), and it mixes behavior, legal terms, and parameter docs without clear structure.

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 high-complexity, 7-parameter, no-annotation, no-output-schema tool, the description covers the creation flow, KYC dependency, latency, persistence requirement, and every parameter. Coverage of the return value is thin ('a json object', with wallet_fk/PIN only implied), which is the main 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 0%, so the prose docs are the only source, and they cover all 7 params with real semantics: secret uniqueness/min-length with a generation suggestion, 5-digit PIN, e164 mobile format with blank-string fallback, and the sponsor KYC constraint. The currency_fk guidance is garbled ('use 7 (ZAR) for everyone else use 3 (USD)'), which blunts an otherwise strong parameter section.

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 first sentence states a specific verb+resource (automated signup for an agent wallet) and the description goes on to detail the distinctive flow: a human-KYCed sponsor wallet mints an agent wallet with a Solana blockchain wallet and bank accounts. It does not, however, distinguish itself from the near-identically named sibling netfluid__automated_signup, so an agent cannot tell them apart from text alone.

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 context is implied ('for an Agentic AI to perform autonomous agents payments') and it states a prerequisite (sponsor wallet must be KYCed or the new wallet won't be). There is no explicit when-to-use-vs-alternative guidance against payment_wallet_signup or automated_signup, and no when-not-to-use condition.

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 add meaningful behavior: the call can take up to 30 seconds, it produces a KYC url the human must be sent to, and the retry path goes through wallet_kyc_session_create. It still omits auth/permission requirements and what happens on failure or duplicate signup, so it is not fully complete.

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 opening line 'Automated signup for new customers.' is duplicated verbatim immediately after the preferred-method sentence, which is pure redundancy. The rest is front-loaded and informative, but the repetition wastes space in an otherwise long block.

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?

Handles 8 parameters well and gives the downstream KYC workflow, but there is no output schema and the return value is described only as 'a json object' — it never states that the returned object contains the KYC url the caller is told to hand to the customer. Naming that field 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 description coverage is 0%, and the description compensates fully: min-8-character unique 'secret' generation advice, 5-digit 'pin', e164 'mobile' with a concrete example, currency_fk mapping (7=ZAR, 3=USD), default app_id/org_id values, and the conditional constraint that customer_referral_code cannot be blank when app_id != 1.

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 ('Automated signup for new customers') and distinguishes the human path from the agent path by scoping it to 'human customers' (vs. sibling netfluid__automated_agent_signup). It does not name that sibling explicitly, so the differentiation 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?

Explicitly marks itself as 'the preferred method to signup human customers' and gives a follow-up routing rule: after completion, direct the customer to the KYC url, and if more verification tries are needed, call wallet_kyc_session_create. Clear context and one named alternative, but no explicit when-NOT-to-use 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 are provided, so the description carries the full burden. It usefully discloses two behavioral traits: wallet_fk 'may not be 0' and account_fk=0 returns all beneficiaries for the wallet. However, it says nothing about auth requirements beyond the token/api_key parameters, read-only nature, or pagination 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?

The leading sentence is duplicated verbatim, and the JSDoc-style @param/@return boilerplate is retained, which is wasteful and not front-loaded cleanly. The content is not excessive in length, but the duplication undermines structure.

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 four-required-parameter list tool with no output schema and no annotations, the description covers inputs adequately but reduces the return to 'a json object' with no indication of the beneficiary fields or pagination. It is minimally sufficient but leaves return-shape questions unanswered.

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 0%, so the description must compensate, and it does: it documents all four parameters, clarifies that account_fk is a database int not an address and may be 0, and notes wallet_fk must be non-zero. It adds genuine meaning beyond the bare type declarations in 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 clear verb and resource: 'Lists all beneficiaries' on a wallet or account. It is distinguishable from the sibling write operations beneficiary_add and beneficiary_remove, but it offers no explicit differentiation from other list tools such as wallet_accounts_list. Clear but not sibling-differentiated.

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 guidance or mention of alternatives, prerequisites, or scoping decisions (e.g., when to scope by account_fk vs. wallet_fk). The agent must infer usage from the parameter names alone.

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. It does disclose some genuine behavioral detail beyond the schema: name should be 'short and unique per wallet', account_fk=0 makes the beneficiary wallet-scoped, and note is 'visible to the receiver'. However it omits auth/permission requirements beyond naming the api_key/token params, error behavior, and any side effects of creating a beneficiary.

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, but the opening sentence is duplicated verbatim and the @param block is verbose with an internally contradictory line for account_fk. Most content earns its place, but the redundancy and contradiction are structural flaws.

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 8-param mutation tool with empty annotations and no output schema, the parameter documentation closes the largest gap. But the @return line ('a json object') conveys nothing about the created beneficiary's shape, and there is no error or failure-mode context an agent would need to invoke this reliably.

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?

With 0% schema description coverage across 8 required params, the description must compensate and largely does: every parameter gets a meaning, including type guidance ('this is a database ID (int) not an account address (str)') and the rba_fk/name/address dependency. The account_fk text is self-contradictory ('may not be 0' then 'may be set to 0'), which blunts an otherwise thorough set of parameter docs.

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 opening states a specific verb and resource: 'Creates a beneficiary on this wallet or on this account.' This distinguishes it from siblings like beneficiary_remove and beneficiaries_list, though it never names those siblings explicitly. The repeated opening sentence adds noise but the core purpose is unambiguous.

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 tool versus beneficiaries_list or beneficiary_remove, nor any preconditions or workflow context. The account_fk/wallet_fk relationship hints at scope, but an agent gets no routing guidance from the description.

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 fails: no permissions/auth requirements, no reversibility or side effects, and only a vacuous "@return: a json object". Worse, it claims both deletion and creation, so behavioral intent is genuinely ambiguous.

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 raw docstring blob mixing a contradictory summary, a misapplied @param block, and a useless return note. The duplicated account_fk sentence is redundant and self-conflicting, so structure and signal-to-noise are poor even though it is short.

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 mutation tool with no annotations, no output schema, and 0% schema coverage, the description should at minimum unambiguously state what it destroys and under what auth. Instead it contradicts its own purpose and gives no output or effect information, leaving critical gaps.

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 0%, so the description must compensate, and it does document all four parameters (api_key origin, token from /access/login, beneficiary_id as uuid from /beneficiary/list, account_fk as an int DB ID rather than an address). It is undercut by an internal contradiction about account_fk ("may not be 0" immediately followed by "may be 0"), but it is more informative than the bare 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 first line states a specific verb+resource ("Deletes a beneficiary") that would distinguish it from the sibling netfluid__beneficiary_add. However, the very next line says "Creates a beneficiary on this wallet or on this account", a direct self-contradiction that reads as copy-paste from the add tool and leaves the agent unsure whether this tool deletes or creates.

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 tool vs alternatives, no prerequisites, and no mention of the sibling beneficiary_add or beneficiaries_list. The contradictory "Creates" line actively misleads rather than guiding tool selection.

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 disclose meaningful behavior: a required confirmation step, an asset restriction, and a loss warning ('these may be lost'). However it is internally inconsistent — the currency param lists usdc, usdt and eurc while the preamble says USDC only — leaving the true supported-asset set ambiguous, and it says nothing about irreversibility, timing or fees.

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 opening sentence is duplicated verbatim ('Creates a blockchain to blockchain bridge'), which is wasted space, and the @param block is dense. The safety restriction is front-loaded, which is good, but the repetition costs structure points.

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 8-parameter mutation with no annotations and no output schema, the description covers the critical inputs and the asset-safety warning, but return values are dismissed with '@return: a json object' despite there being no output schema to fall back on, and no downstream identifiers or status behavior are described.

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 0% across 8 parameters, so the description does the heavy lifting and largely succeeds: it explains account_fk is a DB integer ID (not an address, not 0), enumerates blockchain values, and notes alias defaults asynchronously. The currency enumeration directly contradicts the USDC-only preamble, which blunts an otherwise strong effort.

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 ('Creates a blockchain to blockchain bridge'), which cleanly separates it from the sibling bridge_list, bridge_delete and bridge_rename tools. It does not, however, explicitly name the alternative ramp tools (bridge_on_ramp, bridge_off_ramp_sepa/ach_wire) so routing is left to inference from the name.

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?

Provides a workflow instruction ('Confirm (yes/no) before executing') and an asset-scope rule ('Only supports USDC transfers'), which is real usage guidance. It stops short of saying when to choose this tool over the sibling on-ramp/off-ramp bridges or what prerequisites must be met.

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 two meaningful facts: the operation is a deactivation (soft, presumably) rather than a destructive delete, and it requires an explicit yes/no confirmation. It stops short of saying whether deactivation is reversible, what happens to in-flight transfers or balances, or how the caller's permissions affect success.

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 opening sentence 'Deactivates the Bridge' is repeated verbatim in the second block, so the description wastes its most prominent position on duplication. The JSDoc parameter block is compact and useful, but the copy-paste artifact suggests the text was assembled carelessly.

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 four-parameter, all-required mutation with no annotations and no output schema, the description covers auth provenance, the confirmation gate, and the deactivation semantics, which is enough to invoke it. It still omits reversibility, side effects on the bridge's assets, and any hint of the return payload beyond '@return: a json object'.

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 0%, so the description must compensate, and it does: all four parameters are documented with provenance — api_key is the application key, token and wallet_fk come from /access/login, and external_account_id is found on /bridge/list. That is genuinely actionable, though no format or validation details are given.

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 gives a specific verb+resource ('Deactivates the Bridge') and importantly corrects the misleading tool name 'delete' by clarifying the operation is a deactivation rather than a hard delete. It does not, however, distinguish itself from siblings such as netfluid__bridge_rename or netfluid__bridge_list, which an agent must infer from names alone.

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 usage instruction is 'Confirm (yes/no) before executing', which is a procedural step rather than guidance on when to choose this tool over bridge_rename or other bridge operations. No preconditions, no alternatives, no statement of what state the bridge must be in.

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. It does add real behavioral context: bridges only exist on blockchain accounts, and account_fk 'may not be 0'. However it says nothing about pagination, rate limits, filtering defaults, or what the returned JSON contains beyond 'a json object'.

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 opening sentence is duplicated almost verbatim, account_fk's explanation is pasted twice inside itself, and the @return is the useless 'a json object'. The content is buried in redundant prose rather than front-loaded cleanly.

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 5-required-param tool with no annotations and no output schema, the description covers parameters and preconditions adequately, but its treatment of the return payload is non-existent ('a json object'), and with no output schema that gap is on the description.

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 0%, so the description must compensate — and it largely does, documenting all five parameters via @param tags, including the transfer_type value set (off-ramp/blockchain/on-ramp) that the schema does not enumerate. It loses points for tautological phrasing (account_fk's description is repeated verbatim) and thin docs on api_key/token.

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 gives a specific verb+resource ('Returns bridges') and even defines the domain vocabulary (on-ramp/virtual account, off-ramp, blockchain). It does not, however, distinguish this listing tool from siblings like bridge_blockchain, bridge_on_ramp, bridge_off_ramp_sepa, or bridge_rename, so the agent gets no help telling 'list' from 'create/rename'.

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 guidance and no alternative named. The only contextual hint is the constraint 'Bridges are only available on blockchain accounts', which is a precondition rather than usage routing.

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 disclosure burden; it does add meaningful traits such as the required yes/no confirmation and the fact that this moves real money via ACH/WIRE. It still omits reversibility, failure behavior, auth/permission prerequisites, and rate limits, which matter for a financial off-ramp.

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 sentence is front-loaded and the param block is genuinely useful, but the opening sentence is duplicated verbatim in a slightly garbled second copy, which wastes space without adding 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?

For a 16-parameter, 12-required financial mutation with no annotations and no output schema, the parameter documentation is strong, but return behavior is dismissed as 'a json object' and the description says nothing about what happens to funds, timing, or error cases after invocation.

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 0% and there are no declared enums, yet the description documents every parameter, including allowed values for destination_rail (ach_same_day/wire), currency (usdc/usdt) and account_type (checking/savings), plus the constraint that account_fk is an integer ID that may not be 0. A few entries (token, api_key) only give provenance pointers, keeping this just short of exhaustive.

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 (creates) plus resource (blockchain-to-FIAT off-ramp) and scope (USA, ACH/WIRE), which cleanly separates it from siblings like bridge_off_ramp_sepa and bridge_on_ramp. An agent can identify the operation 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?

'Confirm (yes/no) before executing' gives a workflow instruction, and the USA/ACH-WIRE scope implies applicability. However, it never names when to prefer this over bridge_off_ramp_sepa, withdraw_to_bank, or account_wire, leaving alternative selection to inference.

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 supplied, so the description carries the full behavioral burden. It discloses that a yes/no confirmation precedes execution and that the result is 'a json object', but says nothing about permissions, idempotency, whether the transfer is irreversible, timing/settlement, or failure modes for a money-movement 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?

Purpose is front-loaded, and a long @param block is justified by 19 undocumented parameters. However, the purpose sentence is duplicated verbatim at the top and again before the parameter list, and '@return: a json object' is filler. Functional but with avoidable 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 19 parameters, 14 required, no annotations and no output schema, the description covers inputs reasonably well but leaves the outcome thin: no settlement timing, no error/limit behavior, and the return is described only as 'a json object'. An agent could call it, but not confidently predict what happens next.

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 0%, so the description must compensate, and it largely does: every parameter is documented with real semantics beyond the schema — account_fk is a database int, not an address, and may not be 0; iso3_country shown as 'BEL'; entity_type values 'individual'/'business'; address_line must include a number; alias has an async default. Only the credential params (api_key, token) are near-restatements.

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 opening sentence gives a specific verb, resource, corridor and scope: creating a USDC-to-FIAT off-ramp for SEPA/Europe bank accounts. The Europe/SEPA qualifier implicitly separates it from bridge_off_ramp_ach_wire, though the sibling is never named. Clear enough to select correctly, but not maximal.

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?

Nothing states when to use this versus bridge_off_ramp_ach_wire, bridge_on_ramp, or the other bridge tools, and no prerequisites (KYC, funded wallet) are given. The only procedural note is 'Confirm (yes/no) before executing', which is a confirmation ritual rather than usage 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, the description carries the full behavioral burden. It usefully discloses the confirmation gate and the one-account-per-rail limit, but omits auth/permission requirements, idempotency, failure modes, and what exactly happens to the virtual account after creation.

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 opening sentence is duplicated verbatim ('Creates a virtual account (SEPA/ACH/WIRE) to blockchain bridge' appears twice), wasting space, and the @param block is verbose. Content is front-loaded but not tight.

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 9-parameter, non-read-only bridge tool with no annotations and no output schema, the parameter coverage is good and the confirmation protocol is noted. What remains missing is the surrounding behavioral context: how confirmation is actually supplied, auth/credential expectations, and error handling.

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 0%, yet the description documents all nine parameters inline, including enum-like value sets for blockchain ('ethereum','solana','avalanche_c_chain'), currency, and source_rail, plus the critical warning that account_fk is a database int and may not be 0. This substantially compensates for the empty 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 verb and resource ('Creates a virtual account (SEPA/ACH/WIRE) to blockchain bridge') and adds a distinguishing constraint ('Limited to one virtual account per payment rail'). It is clear enough to separate on-ramp from off-ramp siblings, though it never names an alternative 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?

It gives one real usage instruction ('Confirm (yes/no) before executing') and a constraint on how many accounts may exist per rail. It does not, however, say when to choose this tool over bridge_off_ramp_sepa/ach_wire or bridge_blockchain, nor state prerequisites for calling 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?

With no annotations, the description carries the full burden. It does disclose a meaningful behavioral trait – the confirmation requirement – which is not derivable from the schema. But it omits reversibility, permission/auth requirements, and side effects beyond the name change, leaving significant gaps for a mutation 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?

The purpose sentence is front-loaded, but it is repeated verbatim at the top, and the body is raw JSDoc-style @param/@return text that leaks into the description. Functionally readable but structurally noisy.

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 5-required-param mutation tool with no annotations and no output schema, the description covers parameters adequately but under-specifies safety: no auth failure behavior, no note on whether the rename is reversible, and only a minimal '@return: a json object'.

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 0%, so the description must compensate, and it does: all five params are documented, including where external_account_id is found (/bridge/list) and what alias means. Minor value loss because some entries (api_key, alias) are self-evident, but coverage is complete.

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: 'Changes the Bridge's descriptive name.' This distinguishes it well from siblings like bridge_delete or bridge_list. However, it makes no explicit sibling differentiation or scope statement beyond the verb itself.

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 usage instruction is 'Confirm (yes/no) before executing', which is an invocation guard but not when-to-use guidance. There is no indication of when to prefer rename over related bridge tools, nor any prerequisite context.

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 annotations empty, the description carries the full behavioral burden. It implies a read-only list via 'Returns', but never states authentication requirements, rate limits, pagination, or result shape beyond a vague 'a json object'.

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 opening sentence is duplicated verbatim, and raw docstring artifacts ('@param', '@return') with odd indentation leak into the agent-facing text. The useful content is buried and the presentation is bloated rather than 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?

For a single-parameter listing tool with no annotations and no output schema, the description should at least sketch the returned collection or its fields; 'a json object' leaves the agent unable to anticipate the response.

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 0%, so the description must compensate, and it partially does by documenting '@param api_key: The api key allocated to your application'. That is the only parameter, so the meaning is now clear even though format/obtaining instructions are absent.

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 verb and resource ('Returns all authorised commodities'), but 'commodities' is ambiguous in a sibling set that already contains crypto_digitalassets, currency_types, account_types and telco_bundles. Nothing distinguishes it from those listing tools, so the agent cannot confidently pick it.

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 statement, no exclusions, and no mention of the related sibling listing tools. The agent must guess the context in which commodity types are needed.

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. It hints that this is a passive reference call returning a link and a JSON object in a 'referenced_tools' schema, which signals a non-mutating read. It does not clarify whether there are auth/prerequisite requirements or how the referenced tools should be followed up on.

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 definition is short and front-loads the purpose, but the return information is stated twice ('referenced_tools' schema and '@return: a json object') and the '@return' annotation is redundant. The awkward phrasing ('This tools provides') adds noise without value.

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 zero-parameter reference tool with no output schema, the description gives a minimal but workable picture. It references a 'referenced_tools' schema that is never defined or exposed, leaving ambiguity about what actually comes back, but the core purpose is covered.

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 document. Baseline 4 applies; the empty input schema is self-explanatory.

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: it provides a link to Netfluid's compliance procedures and documentation. An agent can tell this is a reference/lookup tool. However, it does not explicitly distinguish itself from similarly documentation-oriented siblings such as netfluid__terms and netfluid__privacy.

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 guidance on when to invoke this tool or how it relates to the terms/privacy siblings. The intended trigger (an agent or user asking about compliance obligations) is only implied by the description text.

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. It discloses that account_fk is a database integer ID, may not be 0, and comes from /wallet/accounts_list, and that the return is a json object. However, it does not describe authentication requirements beyond the parameter names, error behavior, or return structure in any detail.

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 first sentence is duplicated verbatim, wasting space. The @param and @return blocks are front-loaded and information-dense, but the duplication and vague '@return: a json object' reduce efficiency.

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 3-parameter tool with no output schema and no annotations, the description covers parameter meaning and sources reasonably well. However, it does not explain the shape of the returned balance, which would be important given the absence of 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?

Schema description coverage is 0%, so the description must compensate. It documents all three required parameters: api_key's purpose, token's source via /access/login, and account_fk's type, allowed range, and origin. This adds substantial meaning beyond the bare schema types.

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: 'Returns a crypto wallet address balance associated with an account_fk.' It distinguishes the resource as a wallet address balance, which separates it from some siblings, but it does not explicitly contrast with the very similar sibling netfluid__crypto_token_balance.

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 provides no explicit when-to-use guidance or alternatives. It only notes that account_fk is provided by /wallet/accounts_list, which is a prerequisite rather than usage direction.

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 are empty, so the description carries the full behavioral burden. It implies a safe read ('List all...') but discloses nothing about auth requirements beyond a bare api_key mention, pagination, result size, or whether the list is filtered per account.

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 same idea is stated twice ('List all the system supported blockchains' / 'List all the supported blockchains'), and the text is padded with raw JSDoc tags and a near-useless '@return: a json object'. The redundancy and formatting waste space without adding 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?

For a trivial one-parameter list tool this is roughly adequate: it names the resource and says entries yield blockchain_fk values. But with no output schema, the vague 'a json object' return note leaves the actual response shape underspecified.

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 0%, so the description must compensate. It partially does with '@param api_key: The api key allocated to your application,' which adds meaning the bare schema lacks, but the single required parameter is documented only at the level of an API-key label.

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 the system supported blockchains') and clarifies the unit of the response ('a list of blockchain_fk values'). This is clear enough to distinguish it from most siblings, though it does not explicitly name competing tools like crypto_digitalassets or currency_crypto.

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 guidance and no named alternatives. The phrase 'for later use' hints at a workflow (fetch blockchain_fk before calling other tools) but never states the condition that selects this tool over siblings, leaving the agent to infer 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 are empty, so the description carries the full burden and it delivers meaningful behavior: a confirmation step is required before execution, the DEX charges fees, and unsupported tokens will not appear in balances (needing a block explorer). It does not cover auth requirements, reversibility of the swap, or failure behavior.

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 core swap sentence is stated twice in near-identical form ('Swaps a token for another token using a Distributed Exchange (DEX) on the blockchain'), which is redundant. The confirm instruction is front-loaded well, but the duplication wastes space.

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 6-parameter mutation with no annotations and no output schema, the description covers inputs, the confirmation gate, fees, and one important caveat. It is still missing auth/permission requirements, whether the swap is irreversible, and any sense of the returned JSON beyond 'a json object'.

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 0%, so the description must compensate, and it does — every one of the six parameters is documented, including the high-value caveat that account_fk is a database ID (int, not an address) and may not be 0. The api_key and token descriptions are terse but sufficient to distinguish 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 (swaps one token for another via a DEX on-chain), which is clear enough to act on. It fails to differentiate from the sibling tools netfluid__crypto_swap and netfluid__account_swap, so an agent cannot tell which swap variant to pick 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?

There is no when-to-use guidance and no mention of when this should be preferred over crypto_swap or account_swap. The only procedural instruction is the confirm (yes/no) step, which is execution mechanics, not selection 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?

No annotations are provided, so the description carries the full burden. It never states that this is a non-mutating read, whether api_key is required for authentication (how it is obtained), whether results are paginated or rate-limited, and only offers the uninformative '@return: a json object'.

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 primary sentence is duplicated verbatim, and the body is JSDoc boilerplate (@param/@return) rather than prose aimed at a tool-selecting agent. The '@return: a json object' line conveys nothing and wastes space.

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 3-required-parameter lookup tool with no annotations and no output schema, the description should explain authentication, FK provenance, and result shape; it explains only the bare relationships and nothing about output or limits.

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 0%, so the description is the only source of parameter meaning. It does add real value by explaining that blockchain_fk is the chain on which digital_asset_fk resides and that api_key is the application's allocated key, but it gives no format, valid-value, or lookup guidance for the two foreign keys.

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 it retrieves a digital asset's information scoped by blockchain_fk and digital_asset_fk, which is understandable, but the doubled placeholder line and the vague verb 'List ... information' leave it unclear whether this returns one asset or many. It also makes no attempt to distinguish itself from close siblings such as netfluid__crypto_digitalassets or netfluid__crypto_info.

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 tool versus crypto_digitalassets, crypto_info, or crypto_token_balance, and no prerequisites or exclusions. The agent must infer the use case entirely from the name and parameters.

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 are empty, so the description carries the full behavioral burden but discloses very little: it claims a json object return and mentions the digital_asset_fk field. It says nothing about auth requirements beyond the api_key param, whether results are paginated, caching or rate limits, or whether any state is affected. The repeated text also makes the behavioral claims ambiguous.

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 visibly duplicated – the same list statement appears twice with minor rewording – and it embeds @param/@return doc tags into prose. Not front-loaded or deduplicated, so it wastes the reader's attention before conveying the one useful fact (the digital_asset_fk handle).

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-param list tool with no output schema, no annotations, and no schema descriptions, the description should at minimum nail down the return shape and the chaining contract. It only vaguely says 'a json object' and hints at digital_asset_fk reuse; combined with the duplicated text, an agent cannot fully predict the response.

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 0%, so the description must compensate, and it does document the single parameter as 'The api key allocated to your application'. That is adequate for one param but adds no format or acquisition detail beyond a restatement of the obvious.

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 does state a clear verb+resource ('List all the supported digital assets'), but it says it twice in slightly different words and never distinguishes this from close siblings such as crypto_digitalasset_info, crypto_blockchains, currency_crypto, or wallet_assets_list. An agent can tell what it does, but not reliably why it should pick this over the alternatives.

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 guidance, no prerequisites, and no named alternative. The only usage hint is implicit: the returned digital_asset_fk is 'for later use' and is 'also applicable to to_digital_asset_fk', which hints at a downstream chaining pattern but never states the condition under which this tool should be chosen.

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 behavioral burden. It usefully discloses that the operation is read-only ('display only, no action is taken') and states the mnemonic/private-key precedence rule. It omits other relevant behavior: whether secrets are transmitted or persisted server-side, error behavior when neither key is supplied, and any rate or security constraints.

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 opening sentence is duplicated verbatim and the body is truncated mid-word ('The suppo'), so content is both repeated and lost. The @param block merely restates schema property names. Structure is disorganized and not front-loaded beyond the one repeated line.

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 owns the return contract, yet it offers only '@return: a json object' with no indication of what fields come back (address, balances, derivation path). Combined with the truncated sentence and undocumented blockchain_fk domain, this leaves meaningful gaps for a 4-parameter crypto 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 description coverage is 0%, so the description must compensate, and it does document all four parameters with real detail: api_key is 'allocated to your application,' blockchain_fk selects the chain, private_key must be urlencoded, and mnemonic keywords are space-separated. Encoding and delimiter formats are non-obvious facts that the bare schema does not carry. It does not explain valid blockchain_fk values.

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: recovers/derives a blockchain wallet from a private key or mnemonic, plus the important qualifier that it is 'display only, no action is taken.' It does not distinguish itself from the near-identical sibling netfluid__access_recover or netfluid__wallet_mnemonic, which keeps it below a 5.

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 conditional guidance on inputs — mnemonic takes precedence over private key, and one or the other must be provided — which is useful operating context. However, it never says when to choose this tool over sibling recovery tools such as access_recover or wallet_mnemonic, so tool-selection guidance is implied at best.

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 disclosure burden. It does add useful behavior-adjacent context: authentication requires api_key and a token obtained from /access/login, and account_fk is a numeric database ID that must not be 0. But it reveals nothing about read-only semantics, failure modes, rate limits, or return shape beyond 'a json object'.

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 core sentence is repeated verbatim at the top, which is pure waste, and the JSDoc block is functional but verbose. The useful content is front-loaded, so structure is acceptable but not tight.

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 3-required-param tool with no annotations and no output schema, the description covers auth chain and parameter meaning reasonably but leaves the return value as an unhelpful 'a json object'. An agent cannot know what fields (address, per-asset balances) to expect.

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 0%, so the description must compensate, and it largely does: all three parameters are explained (api_key = app key, token = from /access/login, account_fk = int DB ID, not an address, may not be 0, sourced from /wallet/accounts_list). This adds real meaning beyond bare types, though format details for token/api_key are thin.

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 ('Returns a crypto wallet address and balances') scoped by an account_fk, which is concrete enough to act on. However it does not distinguish itself from close siblings like crypto_balance, crypto_token_balance, or account_info, so the differentiation dimension is unmet.