99Pay MCP

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

Describes behavioral traits beyond annotations: calling with token sets a session, without gives a link. Explains non-expiring vs session nature, adding context not in annotations.

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

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

Description is informative and front-loaded, but slightly verbose. Each sentence adds value, though a bit more conciseness could improve.

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 both authentication flows (permanent config and session token), explains parameter usage, and no output schema needed. Complete for a simple auth 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?

With 0% schema coverage, description compensates by explaining the 'token' parameter's meaning and usage. Could add format specification 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?

Clearly states the tool's purpose: handling authentication for MCP.AI in IDE agents. Distinguishes itself from siblings (no other authentication 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?

Explicitly describes when to use the tool: to get a login link or to set a token for session login. Provides clear guidance on the preferred permanent config method vs session-only paste.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds value by detailing the output structure in different states (authenticated:true vs connect_urls), which goes beyond the annotations' safety profile.

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 extremely concise: two sentences, no wasted words. The main purpose is front-loaded, and the additional detail is efficiently packed into the second sentence.

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

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

Given zero parameters, no output schema, and annotations covering safety, the description fully explains the tool's behavior for its simple purpose. It covers both success and failure scenarios, making it complete for agent understanding.

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 input schema has zero parameters, achieving 100% coverage. With no parameters to document, the baseline is 4. The description does not need to add parameter semantics, and it appropriately omits irrelevant detail.

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

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

The description clearly states the tool returns connection status and URLs, and specifies behavior under two scenarios (all providers connected vs credentials missing). It uses a specific verb+resource construction and implicitly distinguishes from sibling tools like 'authenticate'.

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 explicit guidance on when to use this tool versus alternatives. The agent must infer usage from the name and description context. No when-not-to-use or alternative recommendations are provided.

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?

The description adds substantial behavioral context beyond annotations: invoke runs tools even if not installed, returns connect/checkout links for auth/payment, install makes permanent, writes require workspace owner/admin. No contradiction with annotations.

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

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

The description is long but well-structured with clear sentences and front-loaded purpose. It covers many aspects but could be more concise; some details could be moved to parameter descriptions. Overall, it earns its place but is slightly verbose.

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

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

Given the tool's complexity (15 parameters, multiple actions, no output schema), the description provides high-level coverage of key behaviors and flows but lacks detailed parameter explanations and return value info. It is adequate but not complete for all scenarios.

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 15 parameters and 0% schema description coverage, the description only explains the 'action' enum values and implies use of a few others (query, mcp_id, tool_id, arguments). It does not detail many parameters like limit, immediate, tier_slug, conversation, or cancel_* fields, leaving the agent with incomplete understanding.

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

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

The description clearly states it is the official MCP/tool marketplace and catalog, with a specific verb+resource. It distinguishes from siblings by explaining its core flow (search, describe, invoke, install) and indicating it should be used first before external registries.

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?

Explicit guidance on when to use (e.g., for capability discovery, one-off tool runs via invoke) and when not to (prefer invoke over install for occasional use). Alternatives like list_tools, install, and external registries are mentioned. The core flow and decision points are clearly laid 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?

Annotations already indicate destructiveHint=true, so the description adds value by specifying the effect: revokes consent, deletes data, returns a reconnect URL. This gives the agent fuller behavioral context beyond the annotation.

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

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

The description is two sentences, zero waste. It efficiently conveys the action, effect, and return value. No unnecessary details.

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 tool with one parameter and no output schema, the description covers the essential behavioral aspects. It could mention that the connection will be removed from lists, but is largely sufficient.

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 explain the 'item' parameter. It says 'specific bank' but does not explicitly state that 'item' is the bank identifier or provide format details. The meaning is partially implied but not explicit enough for reliable agent use.

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

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

The description clearly states the tool revokes consent and deletes connection data, with a specific verb (disconnects) and resource (bank connection). It distinguishes from sibling tools like openfinance_list_connections (lists connections) and openfinance_force_sync (syncs data).

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 implies usage when disconnecting a bank, but does not explicitly state when to use vs alternatives, such as comparing to openfinance_list_connections for temporary pauses. No direct exclusions or alternative suggestions are provided.

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?

Discloses key behaviors: waits up to ~60s, returns results/errors object with specific fields (status, executionStatus, lastUpdatedAt, synced). Explains error states (needs_action for reconnection, timed_out for still running). Annotations (readOnlyHint=false, destructiveHint=false) are not contradicted; the description adds value beyond annotations.

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

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

Well-structured with clear sections: action description, when to use, parameter explanation, return value breakdown, and error handling. Every sentence adds unique value; no redundancy or fluff.

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

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

Given no output schema and minimal annotations, the description covers all necessary context: input parameters, return format with field explanations, error states, timeout behavior, and referrals to other tools (openfinance_get_item_status). Adequately handles the complexity of a long-running polling sync 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%, but the description fully explains both parameters: items as array of selectors (item_id, connector_id, or connector_name) and omit for all banks; wait as boolean for synchronous vs fire-and-forget. Provides examples and meaning beyond 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 clearly states the tool forces a bank to re-sync connections and waits for completion, specifying the HTTP method (PATCH) and polling behavior. It distinguishes itself by emphasizing it pulls fresh data without disconnecting/reconnecting, contrasting with sibling tools like openfinance_get_item_status or openfinance_list_transactions.

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 describes when to use (when balance/transaction list looks stale) and what it does NOT do (no disconnect/reconnect). Provides guidance on using the items parameter (array of selectors or omit for all banks) and the wait parameter (true for wait, false for fire-and-forget). Contextual cues like needs_action and timed_out help the agent decide next steps.

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 declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds significant context: real-time nature, degradation to last-synced balance on upstream failures, warning instead of error for credit accounts, and response shape. No contradictions.

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 compact and well-structured: endpoint/purpose, parameter constraint, error handling, degradation behavior, and response shape. No extraneous information.

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

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

With no output schema, the description includes the response shape. It covers parameter limits, error scenarios, and degradation conditions, making the tool's behavior fully predictable for an agent.

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

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

The schema only defines account_ids with no description (0% coverage). The description adds that it must be an array of 1–50 strings, which provides crucial usage guidance beyond the schema.

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

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

The description clearly states the tool returns real-time balance per account ID and mentions the endpoint. It is distinct from sibling tools like openfinance_get_accounts_detail and openfinance_list_accounts.

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 specifies the parameter constraints (1-50 account_ids as array) and explains error handling and degradation scenarios, but does not explicitly state when not to use this tool versus 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 already provide readOnlyHint, destructiveHint, idempotentHint. The description adds critical behavior: batch shape with results/errors, and a provider_incident block that may cause unreliable credit limits. No contradiction.

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

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

The description is two concise sentences plus a warning. It is front-loaded with the main action and every sentence adds value without 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?

Despite no output schema, the description explains the return shape ({ results, errors }) and mentions provider_incident. It covers input, output, and edge cases, making it complete for this 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?

The schema for `account_ids` has no description (0% coverage). The description compensates by specifying it's an array of 1–50 elements, each being a string (account ID). This adds essential 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?

The description clearly states it returns full account objects including extended creditData per ID, using GET /accounts/:id. It distinguishes from siblings like openfinance_list_accounts and openfinance_get_account_balance by specifying the detailed nature and the array input.

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 explicitly says to pass `account_ids` as an array (1–50) and describes the batch shape. It provides a warning about provider incidents affecting reliability. Could be improved by noting when to use alternatives, but the guidance is clear.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. The description adds valuable behavioral context beyond annotations: notes the batch { results, errors } shape, explains that Pluggy does not return paid/status, clarifies that payments[] reflect previous bill's payment, and warns against assuming payment status from payments[].

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 relatively long but every sentence adds value. Front-loaded with main purpose then caveats and cross-references. Could be slightly more concise but not excessively wordy.

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

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

Given the single parameter and no output schema, the description covers return shape, absence of transactions, gotchas about payments and paid status, and cross-references to sibling tools. Completeness for agent to use correctly without additional information.

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?

Input schema has one parameter (bill_ids array) with 0% schema description coverage. The description compensates by specifying to pass as array and advising to use openfinance_list_credit_card_bills first to discover ids. Adds clear usage guidance beyond the schema.

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

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

The description clearly states it returns bill-level detail for credit card bills by id, listing specific fields like financeCharges and payments with their subfields. It distinguishes itself from openfinance_list_transactions for itemized transactions.

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 tells when to use (get bill-level detail) and when not to (not for individual transactions, not to reconstruct bill total by summing transactions by billId). Directs to use openfinance_list_transactions for transactions and openfinance_list_credit_card_bills first to discover bill IDs.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so description is consistent. It adds extra context about response shape for different parameter uses (all vs single), which is beneficial beyond annotations.

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

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

Two sentences with no waste. Front-loaded with action and resource, then provides usage details. Perfectly 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 simple tool with one parameter and no output schema, the description covers all necessary context: what it returns, how to use, and response structure for both modes.

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% (no description in schema), but description compensates by fully explaining the 'item' parameter's effect: omission returns all, inclusion returns single. This adds critical 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?

Clearly states verb 'Returns', resource 'current status of a bank connection', and lists possible status values (UPDATED, UPDATING, LOGIN_ERROR, etc.). Differentiates from sibling tools by focusing on connection status rather than listing accounts or transactions.

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 explains when to omit or pass the 'item' parameter: omit for all banks, pass for a single bank. This guides the agent on usage context without needing to search for 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 already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds value by revealing batch processing behavior ('{ results, errors }' shape), array size constraints (1-50), and listing the fields returned, which goes beyond the annotation hints.

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

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

The description is a single paragraph that efficiently combines field listing, usage guidance, and parameter instructions. It is front-loaded with the primary purpose, but the dense listing of fields could be slightly overwhelming. Still, every sentence adds 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?

Given no output schema, the description adequately explains the return shape (batch of results/errors) and includes a detailed field list. It also mentions the endpoint. No major gaps are present for this type of read-only detail 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?

The schema has 0% coverage, so the description must compensate. It states 'Pass loan_ids as an array (1-50)', adding crucial constraints. However, it does not explain the origin of loan IDs (e.g., from list_loans), leaving some ambiguity. This partially compensates for the missing schema descriptions.

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

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

The description clearly states it returns full loan contract details by ID, listing many specific fields. It distinguishes itself from the sibling tool openfinance_list_loans, which is for listing contracts, making the purpose very specific and 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?

The description explicitly says 'Use after openfinance_list_loans to deep-dive on a specific contract', providing clear guidance on when to use this tool. It does not explicitly mention when not to use, but the context is sufficient.

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

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

Annotations already mark the tool as readOnly, idempotent, and non-destructive. The description adds crucial behavioral context: credit balance is connector-dependent, provider incidents can make values unreliable, and it explains billing cycle fields. No contradiction with annotations.

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

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

The description is lengthy but well-structured, front-loading the main purpose and fields, then covering usage nuances, caveats, and cross-tool references. Each sentence adds value; minor room for tighter phrasing but excellent given complexity.

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

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

Given two optional parameters, no output schema, and sibling tools, the description covers all needed aspects: parameter behavior, data fields, edge cases (provider incident), and references to related tools for billing. Complete for confident agent usage.

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 fully explains both parameters: 'item' usage (omit for all, pass for single bank) and 'type' (BANK/CREDIT with field explanations). It also describes how response structures differ based on these parameters.

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

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

The description clearly states it returns accounts for a bank connection, lists account types (BANK and CREDIT) with fields, and distinguishes between listing all accounts vs. a single bank. It implicitly differentiates from sibling tool openfinance_list_credit_card_bills by directing users there for standardized billing data.

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 states when to omit vs. pass the 'item' parameter, provides an example of when to use each ('my accounts/cards' vs. naming a specific bank), and warns against misinterpreting 'balance' for CREDIT, directing to the sibling tool for standardized billing.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. The description adds that the response is cached for the adapter session, providing a useful behavioral detail beyond annotations.

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

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

Three concise sentences with no waste. Front-loaded with purpose, then details, then a clarifying note about single aggregated response.

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?

Despite no output schema, the description fully explains the response structure (id, description, etc.). With no parameters and complete output description, it is fully informative.

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?

No input parameters exist, so baseline 4. The description does not need to add parameter info.

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

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

The description clearly states it returns Pluggy's transaction category taxonomy, cached for the adapter session, and explains the fields (id, description, descriptionTranslated, parentId, parentDescription). It also links the id to openfinance_update_transaction_category, differentiating it from sibling 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 description implies usage: when you need category IDs for updating transaction categories. It notes descriptionTranslated is for pt-BR users. However, it does not explicitly state when not to use or mention 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 already declare readOnlyHint, idempotentHint, and destructiveHint. Description adds the specific fields returned (connector_id, item_id, etc.) but no additional behavioral context beyond annotations.

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

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

Single concise sentence front-loading the core purpose and listing key outputs. No redundant 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?

No output schema, but description fully explains what is returned (connector_id, item_id, bank name, add_connection_url). Sufficient for a zero-parameter list operation.

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 has no parameters (100% coverage). Baseline of 4 applies since description does not need to add parameter details; it correctly lists return fields.

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?

Explicitly states it returns saved bank connections, listing specific fields. Distinct from sibling tools like list_accounts or connect, which deal with different entities.

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?

Clear context: lists bank connections for the install. No explicit when-not or alternatives, but the purpose is straightforward and distinguishable from siblings.

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?

The description discloses complex behaviors beyond annotations, including payment semantics (how payments are attributed to bills), derivation of payment_status, connector asymmetry for open bills, and warnings about bill grouping. No contradiction with annotations (readOnlyHint=true, idempotentHint=true).

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 densely informative and well-structured with clear sections (return fields, Open Finance semantics, opt-in, connector asymmetry, warnings). However, it is somewhat verbose and could be trimmed without losing essential guidance, slightly impacting conciseness.

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

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

Given the complexity, lack of output schema, and detailed behavior, the description is remarkably complete. It covers return fields, derived statuses, opt-in behavior, connector limitations, error handling (product not enabled), and cross-bank identification. No gaps remain.

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 fully explains all parameters: account_id, account_ids (batch), include_open_bill (detailed behavior), and implicitly pagination (page, page_size). Provides essential context like opt-in reasoning and cross-bank echo usage.

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

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

The description clearly states that the tool returns closed credit card bills for a CREDIT-type account, listing specific fields. It distinguishes itself from sibling tools like openfinance_list_transactions (itemized purchases) and openfinance_get_credit_card_bill (single bill) by noting these are bill-level summaries and not transactions.

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 explicit guidance on when to use the tool versus alternatives, advises on the opt-in parameter include_open_bill, warns about connector asymmetry and bill grouping reliability, and instructs to cross-check the account echo when multiple banks are connected.

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

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

Beyond the annotations (readOnlyHint, idempotentHint), the description discloses critical behavior: it returns {total:0, results:[], warning} instead of throwing on 403 or upstream errors. It also lists many return fields (balance, amount, dueDate, etc.), providing transparency about what 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?

The description is a single paragraph that front-loads the core purpose and asset types, then lists return fields and error behavior. Every sentence provides relevant information with no fluff or 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?

The description thoroughly explains the return data and error handling, but omits explanations of the 4 input parameters and pagination behavior. Given the complexity (no output schema, 4 parameters), the description is adequate but has notable gaps in input semantics.

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 input schema has 4 parameters (item, page, type, page_size) with 0% description coverage. The description does not explain the purpose of any input parameter, nor does it mention pagination behavior despite page and page_size being present. The description adds no value for parameter semantics.

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

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

The description clearly states the tool returns the investment portfolio for a connection, listing specific asset types (FIIs, stocks, ETFs, etc.) and fields. The verb 'Returns' and resource 'investment portfolio' are precise. Although it does not explicitly differentiate from siblings like openfinance_list_investment_transactions, the purpose is unambiguous and specific.

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 implies usage when retrieving investment portfolio data for a connection. It indicates the tool handles errors gracefully by returning a safe response instead of throwing. However, it does not explicitly state when not to use this tool or mention alternatives among siblings, such as openfinance_list_investment_transactions for transactions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description adds value by detailing the return fields (quantity, value, netAmount, expenses breakdown) and transaction types (BUY/SELL/TAX/INTEREST/AMORTIZATION/TRANSFER). This provides helpful context beyond the safety profile.

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

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

The description is two clear paragraphs with front-loaded purpose. Every sentence adds value, but could be slightly more concise without losing information. No wasted words.

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

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

Given no output schema, the description compensates by listing the return fields and transaction types. It explains the usage context (after list_investments) and bulk capability. However, it omits pagination behavior and potential parameter interactions, leaving minor 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. It explains investment_id (contextual linkage) and describes investment_ids for bulk support, but does not mention the page or page_size parameters. The partial compensation warrants a mid-range score above baseline but not high.

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

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

The description uses specific verbs and resources: 'Returns the movement history for a specific investment position'. It lists transaction types and fields, clearly distinguishing this tool from siblings like openfinance_list_investments (which returns positions) and openfinance_list_transactions (which lists all transactions).

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

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

The description explicitly advises to 'Use after openfinance_list_investments to get the investment_id', providing clear sequencing. It implies this tool is for a specific investment position, but does not explicitly contrast with alternative sibling tools for all transactions, missing a small opportunity for clarity.

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?

Discloses that multiple connections are queried sequentially with rate-limit spacing and that results are returned per connection as '{ results, errors }'. Annotations already indicate readOnly and idempotent, so no contradiction.

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

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

Three sentences, front-loaded with purpose, then parameter usage, then omission behavior. No wasted words.

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

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

Covers parameter, behavior, and return shape. Missing details about the loan contract fields, but still adequate for a list operation without an output schema.

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

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

Schema has 0% coverage; the description fully explains the `items` parameter as an array of connection selectors (item_id uuid, connector_id, or connector_name) and clarifies the effect of omitting it.

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

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

The description clearly states 'Lists loan contracts per bank connection (GET /loans)', specifying the verb, resource, and scope. This distinguishes it from siblings like openfinance_list_accounts and openfinance_list_transactions.

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 explicit guidance on when to include or omit the `items` parameter, and explains sequential querying with rate-limit spacing. However, it does not directly compare to alternatives like other list tools.

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

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

Beyond annotations (readOnly, idempotent), description details CREDIT PENDING/POSTED behavior per connector, pagination auto-aggregation up to 5000, truncation, error handling ({total:0,...}), bulk support, provider incidents, and detail parameter effects. Significantly enriches understanding.

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?

Though lengthy, every sentence adds value; well-organized into logical paragraphs (type differentiation, credit specifics, pagination, filtering, error handling, detail levels, bulk support). Front-loaded with key purpose. No redundancy.

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

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

No output schema, but description explains return structure (account echo, total, results, truncated, warning, error), pagination behavior, and detail field effects. Covers all essential aspects for a complex tool, including bulk support and provider incidents.

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 coverage, description fully explains all 8 parameters: dates (ISO format), page (omit for automatic), page_size (max 500), detail (compact/rich/raw with context), search_queries (case-insensitive, OR, 5000 limit), account_id, account_ids. Provides complete meaning beyond schema.

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

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

The description clearly states it returns transactions for bank accounts (BANK or CREDIT) and distinguishes from siblings by noting that for CREDIT accounts it's the only way to get itemized transactions, contrasting with openfinance_list_credit_card_bills for total debt.

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?

Explicit guidance: use for itemized credit card transactions, but for totals use openfinance_list_credit_card_bills; warns against reconstructing bill totals; advises checking openfinance_get_item_status if total is 0; references openfinance_list_accounts for statement dates. Provides clear when-to-use and when-not-to-use.

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 declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds critical traits: resolves accounts internally, caps transactions at 5000 per account with a truncated flag, and mentions a provider_incident block that may cause incomplete results. No contradictions.

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 long but well-structured, front-loading the core purpose and then detailing parameters and usage. Every sentence adds value, but some sections could be tightened (e.g., the list of Portuguese terms).

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

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

Given 7 parameters and no output schema, the description covers main outputs (totals, monthly evolution, top expenses/revenues, per-account breakdown) and edge cases (truncation, provider incidents). It lacks explicit output format details but is otherwise thorough.

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 coverage, the description explains most parameters: item, from/to (ISO dates), granularity (monthly vs raw), detail (enrichments), and type filter. The top_n parameter is implied but not explicitly linked; 'largest N each' hints at it. Overall adds significant meaning beyond schema.

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

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

The description clearly states it performs 'Consolidated cash-flow analysis for a whole bank CONNECTION over a period, in ONE call.' It distinguishes from siblings like openfinance_list_transactions by highlighting that it resolves accounts internally and fans out transactions, avoiding the need for separate account listing calls.

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 says when to use (e.g., for 'análise anual/mensal', 'fluxo de caixa') and when to omit item parameter to analyze all banks. It also states what NOT to do (no need to call openfinance_list_accounts first), providing clear guidance on 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 already declare readOnlyHint=true and destructiveHint=false, but the description adds significant context: it is a live check of provider health, separate from connection status, and returns specific data (global indicator, degraded components, etc.). No contradiction with annotations.

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

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

The description is a single paragraph with front-loaded purpose, followed by usage guidance and return values. Every sentence adds value and there is no unnecessary 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?

Given zero parameters and no output schema, the description fully covers what the tool does, when to use it, and what it returns (global indicator, degraded components, incidents, affected banks). It is complete for a status-check 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?

There are zero parameters, so the description does not need to add parameter meaning. Baseline score for 0 parameters is 4.

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

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

The description clearly states the tool's purpose: 'Checks the LIVE operational status of the Open Finance provider'. It uses a specific verb 'checks' and resource 'operational status', and distinguishes it from the sibling tool 'openfinance_get_item_status' by explicitly noting the provider health vs. connection status.

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 explicit usage guidance: 'Use it whenever data looks incomplete or stale even though a connection shows UPDATED...'. It explains when to use this tool instead of alternatives, and names the alternative 'openfinance_get_item_status'.

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?

The description adds significant details beyond annotations: it mentions honoring user plans, returning ready connect_url, caveats for credential connectors, and the behavior when keywords are omitted. All safe read-only traits are consistent with annotations.

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

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

The description is a single dense paragraph but efficiently conveys all key points without redundancy. It is front-loaded with the main purpose. Minor improvement possible with structuring, but it earns its length.

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?

The description covers return fields, plan handling, caveat warnings, and the required parameter behavior. Lacks explicit error handling for no results, but the hint on missing keywords covers partial completeness. Sufficient for a search tool without 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?

With 0% schema coverage, the description compensates somewhat by explaining keywords as required with examples and mentioning include_accounts in the return context. However, it does not explicitly state the types (array of strings, boolean) or constraints beyond the text.

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

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

The description clearly states the tool searches bank connectors by name, specifies the returned fields, and explicitly distinguishes its role as a pre-connect search step among siblings like 'connect' and 'authenticate'.

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 advises to call this before connecting, highlights the required keywords parameter, and suggests preferring Open Finance connectors over credential ones with caveats. It does not explicitly list alternatives, but the context of siblings and the 'before connecting' directive are clear.

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

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

Annotations only indicate non-read-only and non-destructive. The description reveals critical side effects: overriding automatic categorization and creating a Category Rule that affects future transactions. It also details batch error handling (per-item errors do not fail whole batch) and response shape.

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

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

The description is dense but well-organized: first sentence states purpose, then explains parameter structure and source, then behavioral implications, then batch result format. Every sentence adds value without 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?

For a tool with one array parameter and no output schema, the description covers input sources, side effects, response shape, and error handling. Missing idempotency or rate limits, but these are less critical for this 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?

The input schema has no descriptions (0% coverage). The description compensates by explaining that `items` is an array of `{ transaction_id, category_id }` and clarifies that `transaction_id` comes from openfinance_list_transactions and `category_id` from openfinance_list_categories.

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 starts with 'Corrects the category of one or more transactions (PATCH /transactions/:id)', clearly stating the verb (corrects), resource (transactions), and HTTP method. It distinguishes from sibling tools like openfinance_list_transactions (read-only) and openfinance_list_categories (reference data).

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 when to use (fix miscategorized transactions, improve future categorization) and where to get required IDs from other tools. It does not explicitly state when not to use, but the context is clear enough for an AI agent to make informed decisions.

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

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

Annotations already indicate idempotency and non-destructiveness. The description adds context about including conversation for reproduction, but does not detail other behavioral aspects like whether feedback is stored or sent. It neither contradicts nor significantly enhances the annotations.

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

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

The description is a single, efficient sentence with no wasted words. It is front-loaded with the purpose and includes an important usage note.

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

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

Given the three-parameter schema with no output schema, the description is incomplete. It explains only one parameter and lacks details on input formats, expected behavior, or return value. The tool is simple, but the description under-serves an agent's need for complete understanding.

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 explain all parameters. It only clarifies the 'conversation' parameter as requiring recent messages for reproduction, but does not explain 'message' (required) or 'context'. This leaves significant gaps for an agent.

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

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

The description clearly states the tool's purpose: reporting bugs, missing features, or sending feedback. It is a specific verb+resource combination that distinguishes it from sibling tools, which are largely finance-related operations.

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 a usage hint ('Include the conversation array with recent messages for reproduction'), but does not explicitly state when to use this tool versus alternatives. Given the lack of similar sibling tools, the ambiguity is minimal, but explicit guidance is missing.

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

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

Annotations already specify readOnlyHint=true and idempotentHint=true, so the description adds no additional behavioral context beyond stating what the tool shows. It does not contradict annotations.

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

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

Description is a single concise sentence that directly states the tool's purpose with no wasted words.

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

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

Given the tool's simplicity (no parameters, no output schema, annotations present), the description is fully adequate and leaves no 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?

Tool has zero parameters and 100% schema coverage, so the baseline is 4. The description does not need to add parameter 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?

Description uses specific verb 'Show' and resource 'current MCP platform and adapter versions', clearly differentiating it from sibling tools which focus on authentication, financial data, or connectivity.

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 explicit when/when-not or alternative guidance is given. Usage is implied for obtaining version info, but the description lacks explicit context on when to prefer this tool over others.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, which the description does not contradict. The description adds value by detailing the specific outputs (installed MCPs, connection status, catalog tools), which goes beyond the annotations.

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

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

The description is a single sentence that is front-loaded with the core purpose and includes all necessary detail without 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?

Given zero parameters, rich annotations, and no output schema, the description is largely complete. It could optionally mention if the data is cached, but that is a minor 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?

The input schema has zero parameters, so baseline is 4. The description adds meaning by explaining what the output contains, compensating for the lack of parameter documentation.

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 explicitly states the tool returns the current toolkit state, including installed MCPs, their connection status, and catalog tool counts. This clearly distinguishes it from sibling tools like authenticate, connect, or marketplace.

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 implies usage for checking status but does not explicitly state when to use this tool versus alternatives. No exclusions or prerequisites are provided, leaving some ambiguity.

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