Pague Veloz Serasa MCP

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

Annotations indicate idempotentHint=true, destructiveHint=false. Description matches by describing token-based login without destructive effects. No contradiction, but could elaborate on repeated call 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?

Description is informative but slightly verbose. Could be structured into clearer sections (setup vs runtime), but each 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?

Covers both authentication flows, setup advice, and parameter usage. No output schema needed for action tool. Complete for the tool's complexity.

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?

0% schema coverage, but description fully explains the 'token' parameter: optional, JWT from browser login, and no-args returns link. Adds significant meaning beyond bare schema type.

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 clearly states the tool is for authentication via browser token or token input. Distinguished from sibling tools like 'connect' and 'openfinance_*' which are unrelated.

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 two usage methods: permanent via config or session via token argument. Implies when not to use (e.g., already authenticated), but could be more explicit about prerequisites.

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, destructiveHint=false, idempotentHint=true. The description adds useful context about return values (authenticated, pending, connect_urls) and behavior when credentials are missing, surpassing what annotations provide.

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 concise sentences with no fluff. First sentence states the main function, second details key scenarios. Every word earns 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?

The description covers two main states but lacks detail on potential partial connection states or other fields like a general 'status' field. As there is no output schema, more completeness would be beneficial.

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 parameters exist, so schema coverage is 100%. The description adds value by explaining the return behavior, which is beyond parameter documentation. Baseline 4 applies for zero-parameter tools.

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 connection status and URLs, with specific scenarios. It differentiates from sibling tools like 'authenticate' by focusing on status rather than performing authentication, but does not explicitly name 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?

The description implies usage for checking connection status by describing two states, but does not explicitly state when to use this tool versus alternatives like 'openfinance_provider_status' or 'authenticate'.

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 behavioral context beyond annotations: invoke works without installing, writes require owner/admin, invoke may return connect or checkout links, and effects like permanent toolkit addition via install. No contradiction with annotations, which only provide basic 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 long and dense, covering many aspects but lacking a clear, scannable structure. While every sentence adds value, the lack of front-loaded summary and paragraph-style presentation reduces readability for an agent needing quick reference.

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 params, multiple actions, error cases, permissions), the description covers most essential context: core workflow, when to use alternatives, error recovery, and installation strategy. However, missing parameter descriptions and absence of output schema coverage leave some 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 description must explain parameters. It covers action, query, mcp_id, tool_id, and arguments implicitly through the workflow, but does not explain limit, message, immediate, tier_slug, conversation, request_name, cancel_reason, cancel_comment, report_context, request_details. Many parameters remain undocumented, forcing agents to infer from action context.

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 defines the tool as the official marketplace and catalog of MCPs/tools, and explains it is the way to run them. It distinguishes from siblings by being the primary entry point for discovering and invoking capabilities, not just listing or managing specific financial connectors.

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 states when to use this tool first ('before any external/generic registry'), provides a core flow (search→describe→invoke), distinguishes invoke vs install ('prefer invoke for a single/occasional use'), and explains error handling (connect link, checkout/top-up) and permission requirements for writes.

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 destructiveHint annotation, the description adds that data is permanently removed and provides the return value (add_connection_url), enhancing transparency about the tool's irreversible effect.

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: action, consequence, return value. No filler. Each sentence adds essential 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?

The description covers purpose, effect, and outcome, but lacks clarity on the required input parameter. Given no output schema, it partially compensates by mentioning the return URL, but the missing parameter definition reduces completeness.

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 the 'item' parameter. It only says 'specific bank' but does not clarify whether 'item' is a bank ID, name, or other identifier, leaving ambiguity.

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 action ('Revokes consent and deletes connection data') and the target resource (specific bank). It distinguishes from siblings like 'connect' and other openfinance tools that deal with accounts, transactions, etc.

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 explains the consequence ('data will no longer be available') and mentions the return URL for re-connection, giving clear context on when to use. However, it does not explicitly state when not to use or list alternative 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?

Discloses polling up to 60s, return fields, error states (needs_action with reconnect_url), and non-destructive nature. Annotations are minimal, so description carries burden. Lacks rate limit or side-effect details.

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 paragraph, dense but readable. Front-loads action and mechanism. Could be slightly more scannable with structuring, but no wasted sentences.

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, yet description fully explains return object (status, executionStatus, lastUpdatedAt, synced, needs_action, reconnect_url, timed_out) and how to handle each case. References sibling tool for re-check.

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?

Provides meaning beyond schema: items as array of selectors (optional), wait as toggle for synchronous vs fire-and-forget. Schema has 0% description coverage, so description compensates well.

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 action ('forces re-sync'), the resource ('bank connections'), and the mechanism (PATCH + poll). Distinguishes from siblings like openfinance_get_item_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?

Explicitly states when to use (stale data), what not to do (no disconnect), alternatives (openfinance_get_item_status for timed_out), and both modes (sync all vs specific items, wait:false for fire-and-forget).

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 valuable behavioral details: real-time nature, warnings for CREDIT accounts, degradation to last-synced balance with realtime: false, and structured error responses. No contradictions 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 moderately long but front-loads the purpose. Every sentence is informative, though some details (e.g., response shape) could be slightly more streamlined. It balances thoroughness with 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?

Given the 1 parameter, good annotations, and no output schema, the description is complete. It covers parameter bounds, error handling, degradation behavior, and response structure (results/errors/warnings). An agent can reliably invoke 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?

With 0% schema description coverage, the description compensates by specifying that account_ids is an array (1–50 items). It adds bounds and clarifies the type beyond the schema, but does not describe the format of individual IDs (e.g., strings).

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 real-time balance per account id via a specific endpoint, and distinguishes from sibling tools like openfinance_get_accounts_detail or openfinance_list_accounts. It includes the verb 'returns' and the resource 'balance payload', making the purpose 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?

The description provides clear context for when to use this tool, such as passing account_ids (1-50) and handling CREDIT accounts. However, it does not explicitly state when not to use it or compare to alternatives like openfinance_get_accounts_detail, so it misses some 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 already indicate readOnly and idempotent behavior. The description adds critical context about batch shape, provider_incident blocks, and warnings about unreliable credit limits/balances. This significantly enhances transparency beyond structured fields.

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

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

Description is concise (4 sentences) with front-loaded main action. Every sentence adds essential value: purpose, parameter usage, batch shape, and critical caveat about data reliability. 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?

For a single-parameter tool without output schema, the description covers purpose, parameter usage, batch response shape, and an important behavioral edge case. It does not detail the full return structure but provides sufficient context for proper 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 has one parameter with no description. The description adds the constraint 'array (1–50)' and hints at usage by passing account IDs. This compensates for the 0% schema coverage, though it doesn't specify ID format or item 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 returns full account objects including extended creditData per ID, specifying the HTTP endpoint. It implies detail retrieval distinguishing it from listing tools, though sibling names are not explicitly mentioned.

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 pass account_ids array (1-50) and warns about provider incidents affecting data reliability. It implies usage for detailed account data but does not explicitly instruct when to use this versus siblings like openfinance_get_account_balance.

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 (readOnlyHint, idempotent, non-destructive), the description discloses the batch shape ({results, errors}), the lack of individual transactions, the sparse/inconsistent billId hint, the limitation that Pluggy does not return a paid/status field, and the correct interpretation of payments[]. These details prevent misuse.

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 longer than typical but every sentence adds value, with clear structure: core purpose, field details, comparison to sibling, usage prerequisites, batch shape, and specific warnings. It could be slightly more concise, but density of information warrants a 4.

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 (batch results, payment semantics, no output schema), the description covers all critical aspects: input preparation, expected output shape, limitations of external data, and authoritative total. No gaps remain for an agent to safely invoke the 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 only parameter (bill_ids) is explained with guidance to pass as an array and to use openfinance_list_credit_card_bills to discover IDs. Schema coverage was 0%, so the description fully compensates by adding usage context and type 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 bill-level detail for credit card bills by ID, enumerates the fields returned (financeCharges, payments with subfields), and distinguishes it from sibling tools like openfinance_list_transactions. The verb 'get' and resource 'credit card bill detail' are specific and 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?

Provides explicit guidance on when to use this tool vs alternatives: use openfinance_list_transactions for itemized transactions, use openfinance_list_credit_card_bills first to discover bill IDs, and warns against reconstructing totals from transactions. It also explains the semantics of payments[] and paid 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?

Annotations declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds behavioral context: the reconnect_url reopens the widget in UPDATE mode without disconnecting or consuming a connection slot, useful for re-authentication. This goes beyond what annotations provide.

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 front-loaded with the main purpose and then adds structured details. Every sentence adds value, though it could be slightly condensed. Overall, it balances completeness and brevity well.

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 partly describes the return format (e.g., '{ count, items }' for bulk). It mentions key fields like status, executionStatus, connector metadata, and reconnect_url. It does not cover error handling or authentication, but it is sufficient for basic 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 has 3 parameters with 0% description coverage. The description explains that 'item' filters to a single bank, omitting it returns all, and 'item_ids' enables bulk execution. It clarifies the intent of each parameter, though 'item_id' vs 'item' is not explicitly distinguished.

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 bank connection status (UPDATED, UPDATING, etc.) and includes details like executionStatus, connector metadata, and reconnect_url. It distinguishes between returning all connections or a single one by omitting or providing the 'item' parameter, differentiating it from sibling tools like openfinance_list_connections.

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 explains when to omit 'item' (for all connections) versus providing it (for a single bank), and mentions bulk support via 'item_ids'. It does not, however, directly contrast with alternatives like force_sync or disconnect, but the usage scenarios 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 already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so safety profile is clear. Description adds batch response shape `{ results, errors }`, which is valuable 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 paragraph but well-organized: purpose, field list, usage hint, parameter instruction. No unnecessary words; 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?

With no output schema, description lists many return fields and batch shape, making return format clear. Provides usage sequence. Missing explicit note on ID validity and error handling, but adequate for the complexity.

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 0% so description compensates by stating 'Pass loan_ids as an array (1-50)'. Adds format and cardinality constraints beyond the schema. Could specify that IDs come from list_loans, 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 it returns full loan contract detail by ID, lists specific fields (interestRates, installments, etc.). Distinguished from sibling openfinance_list_loans by explicit usage hint.

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 'Use after openfinance_list_loans to deep-dive on a specific contract,' providing context. Also specifies array size limit (1-50). Does not mention when not to use or alternative tools, but context is strong.

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 (readOnlyHint, etc.), the description discloses important behaviors: provider_incident block with unreliable balances, identity_notice for deduplication, credit balance being connector-dependent, and bulk execution. No contradictions 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 well-structured, beginning with the main purpose, then covering nuances, and ending with bulk support. While it is lengthy, each section adds value. Front-loading of key points aids quick understanding.

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 (4 parameters, no output schema, multiple edge cases), the description covers usage variations, provider incidents, identity notices, and credit balance caveats. It sufficiently equips an agent to invoke the tool correctly despite missing 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 description coverage, the description compensates by explaining item, type (enum BANK/CREDIT), and item_ids for bulk. However, it does not explicitly describe the item_id parameter (singular), leaving it ambiguous. Thus, it adds partial meaning but is incomplete.

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, distinguishing between BANK and CREDIT types and explaining the overall result fields. It also explicitly differentiates usage between listing all accounts (omit item) and targeting a single bank (pass item), setting it apart from sibling tools like openfinance_list_credit_card_bills.

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 when-to-use guidance: 'OMIT item to list accounts across ALL linked banks' and 'Pass item to target a single bank'. It also warns about credit balance meaning being connector-dependent and directs users to openfinance_list_credit_card_bills for standardized bill amounts. Additionally, it mentions bulk support via item_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, idempotentHint, and destructiveHint. The description adds value by stating caching behavior, single aggregated response, and no batch ids, which goes 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?

The description is three sentences, front-loaded with the main purpose, and adds concise details without unnecessary 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?

Despite having no output schema, the description fully details the response structure (id, description, descriptionTranslated, parentId, parentDescription), making it complete for the 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?

No parameters exist, so baseline 4 applies. The description does not need to add parameter info and correctly omits 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 it returns Pluggy's transaction category taxonomy, specifying it's cached and details the response fields. It distinguishes from sibling tools that list other entities like transactions or 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 indicates when to use (to get categories) and highlights the id's role in updating categories via another tool. It lacks explicit when-not-to-use, but the context is clear given no overlapping 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?

Annotations already provide readOnlyHint=true and destructiveHint=false. The description adds valuable behavioral context: reconnect_url reopens the widget in UPDATE mode, does not require disconnecting, and does not consume a connection slot. 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 informative but somewhat lengthy. It front-loads the core purpose and then details the reconnect_url behavior. Could be slightly more concise but still well-structured.

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 enumerates all returned fields (connector_id, item_id, bank name, reconnect_url, add_connection_url) and explains the behavior of reconnect_url. For a simple list tool, this is 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?

No parameters exist, so baseline is 4. The description does not need to add parameter info. Schema coverage is trivially 100%.

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 saved bank connections with specific fields (connector_id, item_id, bank name, reconnect_url, add_connection_url). It distinguishes from sibling tools like openfinance_list_accounts by focusing on connections rather than 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?

The description explains when to use reconnect_url (for re-authentication, MFA, LOGIN_ERROR, stale data) and notes it does not consume a connection slot or require disconnecting. It implies not to use for new connections (use add_connection_url). However, it does not explicitly contrast with other sibling tools like 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?

Discloses derived payment_status logic, payment cycle semantics, open_bill fallback/reasons, connector asymmetry, warning behavior, and bill-grouping issues. Adds substantial behavioral context beyond readOnlyHint and idempotentHint annotations. 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?

First sentence fronts the core purpose, but the description is very long and dense, lacking structure (paragraphs, bullets). Every sentence adds value, but overall it is not concise; an AI agent may find it hard to parse quickly.

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 (open finance semantics, derived fields, connector asymmetry) and no output schema, the description covers all critical aspects: output fields, payment_status derivation, open_bill behavior, warnings, echo block. Complete for the tool's domain.

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 description carries burden. Thoroughly explains include_open_bill and account_ids, but lacks any description for page, page_size, or account_id (though account_id is implicit). Partially compensates but leaves standard pagination parameters unexplained.

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: 'Returns CLOSED credit card bills for a CREDIT-type account' and lists specific fields. Differentiates from sibling tools like openfinance_get_credit_card_bill (single bill) and openfinance_list_transactions (itemized purchases).

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 contrasts with openfinance_list_transactions for itemized purchases, advises against reconstructing totals, explains when to use open_bill vs balance, and warns about connector asymmetry. Provides clear when-to-use and when-not-to-use 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?

Beyond annotations (readOnlyHint, idempotentHint), the description adds critical behavioral details: error handling returns empty instead of throwing 403, and a detailed data integrity mechanism for mass zeroing with suspect_zeroed flags. This significantly enriches agent 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?

The description is verbose and includes a lengthy data integrity section that, while important, could be condensed. It front-loads the purpose but becomes dense. Some redundancy exists (e.g., listing fields again).

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 covers return structure (total, results, warning) and the special data_integrity_warning. It explains the main fields returned. However, it could better describe pagination behavior and the 'item' parameter.

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 should explain parameters. While it implies item_id/item_ids for connections, and type for filtering, it fails to define the 'item' and 'page'/'page_size' parameters clearly. This leaves ambiguity for an AI 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 it returns investment portfolios for a connection, listing specific asset types (FIIs, stocks, ETFs, etc.) and detailed fields. It distinguishes itself from sibling tools like openfinance_list_investment_transactions by focusing on portfolio positions rather than 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 clear context for when to use this tool (for investment portfolio data) and mentions bulk support via item_ids. However, it does not explicitly exclude cases or compare with other tools like openfinance_list_accounts, though the scope is well-defined.

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 rich behavioral context: lists the types of transactions returned, the fields per row (quantity, value, etc.), and the dependency on another tool. 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 concise, with two short paragraphs. The first states what the tool returns, the second gives a usage hint. No redundant phrases, front-loaded with key facts.

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 4 parameters, no output schema, and safety annotations, the description provides adequate context: core functionality, return fields, dependency on another tool, and bulk support. Missing explicit pagination documentation, but overall complete for the agent to use correctly.

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

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

Schema description coverage is 0%. The description explains the use of investment_id and investment_ids (bulk support) but does not mention page and page_size, leaving those as common but undocumented pagination parameters. Partial compensation for required params.

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 movement history for a specific investment position, listing transaction types (BUY, SELL, TAX, etc.). It distinguishes from siblings by mentioning dependency on openfinance_list_investments for the investment_id and implying it's for detailed investment transactions, not general 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 clear context: 'Use after openfinance_list_investments to get the investment_id.' and bulk support hint. However, it does not explicitly state when not to use this tool vs alternatives like openfinance_list_transactions, though the context implies investment-specific usage.

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 safe read-only behavior. Description adds valuable behavioral details: sequential querying with rate-limit spacing, per-connection {results, errors} response. 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?

Three concise sentences with front-loaded purpose, then parameter behavior, then output structure. Every sentence earns its place. No unnecessary 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 main use cases (with/without items), response structure, and rate-limit behavior. No output schema, but description gives basic response shape. Could mention pagination or limits, but overall complete for a list tool with good annotations.

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% description coverage for the single parameter 'items'. Description fully compensates by explaining items are connection selectors (uuid, id, name) and that each entry fetches one connection. Adds meaning beyond raw 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?

Description clearly states it lists loan contracts per bank connection with GET endpoint. Distinguishes from sibling get_loan_detail by specifying per-connection listing and optional filtering. Verb+resource+scope all 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?

Provides clear context on when to use (list loans for connections/all banks) and how (pass items or omit). Does not explicitly exclude scenarios or mention alternative siblings, but the sibling get_loan_detail is implied for a single loan. No explicit when-not-to-use, but still clear.

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

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

Annotations already indicate read-only, idempotent, non-destructive. The description adds substantial context: auto vs manual pagination, error handling (returns error object instead of throwing), provider_incident block, bulk support, and credit card metadata sparsity. 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, starting with the core purpose and logically progressing through credit card specifics, pagination, detail levels, and edge cases. While verbose, it earns its length given the complexity; could be slightly more concise without losing clarity.

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 covers all output aspects: account echo block, provider_incident, pagination, and error structure. It addresses edge cases like credit card billId sparsity, search truncation, and connection failure. Very complete for a complex 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%, but the description fully explains each parameter: account_id, from/to as ISO dates, page and page_size for pagination modes, detail levels (compact/rich/raw) with use cases, search_queries for substring match with OR semantics and 5000 cap, and account_ids for bulk.

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 type). It distinguishes by specifying that for CREDIT accounts it's the only way to get itemized transactions, and it contrasts with sibling tools like openfinance_list_credit_card_bills for bill totals.

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: when to use for credit cards, warns against reconstructing bill totals, explains when to use different detail levels, recommends checking connection health when total is 0, and mentions proviider incidents. It also tells when not to use (e.g., for bill totals use openfinance_list_credit_card_bills).

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 (readOnlyHint, idempotentHint), description reveals scan cap of 5000/account with truncation flag, provider incident block affecting data, and internal fan-out behavior. No contradictions 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 dense and thorough, but could be more structured with bullet points for parameters. For 9 parameters and complex behavior, length is justified. Front-loads core purpose effectively.

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 full parameter disclosure, the description covers return values (compact summary fields, raw rows), truncation behavior, provider incidents, and bulk execution. No apparent gaps for an AI agent to select and invoke correctly.

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

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

Despite 0% schema coverage, the description explains all 9 parameters: item (connector_id/name/item_id or omit), from/to ISO dates, granularity (monthly/raw), detail (compact/rich/raw), type (BANK/CREDIT), top_n (implied), and item_ids. Each parameter's meaning and usage is clearly described.

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 performs consolidated cash-flow analysis for a bank connection in one call, distinguishing itself from sibling openfinance_list_transactions by eliminating the need to list accounts first. It specifies verb 'analyze' and resource 'connection 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 when-to-use (e.g., 'análise anual/mensal', 'fluxo de caixa'), when-to-omit parameters (item for all connections), and alternatives (granularity 'raw' for itemized rows). Also mentions provider incidents and bulk support, guiding appropriate invocation.

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, which is consistent with the description's 'Checks' verb. The description adds behavioral context: it returns global indicator, degraded components, open incidents, and flags incidents affecting connected banks, which goes beyond what annotations provide.

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 somewhat long but each sentence adds value. It front-loads the core purpose ('Checks the LIVE operational status') and then provides usage guidance and return value details. It could be slightly more concise, but it is well-structured.

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 there is no output schema, the description adequately explains the return values (global indicator, degraded components, open incidents, affected banks). It covers all necessary aspects for an agent to use the tool correctly, including the distinction from the sibling tool and when to invoke it.

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

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

The tool has no parameters, and schema description coverage is 100% (no params to cover). The description does not need to explain parameters. Baseline for 0 params is 4, which is appropriate.

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

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

The description clearly states the tool checks the LIVE operational status of the Open Finance provider, distinguishing it from the user's own connection status via `openfinance_get_item_status`. It specifies the verb 'Checks' and the resource 'provider status', and differentiates from siblings by naming the alternative tool.

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

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

The description explicitly tells when to use this tool: 'whenever data looks incomplete or stale even though a connection shows UPDATED'. It also explains what it helps diagnose (upstream outage vs. connection issue) and mentions the alternative tool `openfinance_get_item_status` for the user's own connection.

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, idempotentHint=true, and destructiveHint=false. The description adds valuable context: it mentions the caveat for non-Open-Finance connectors and that without keywords it returns a hint, never dumping the whole catalog. 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 relatively long but every sentence adds value, covering purpose, usage, parameter details, and special behaviors. It is front-loaded with the main action.

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 thoroughly explains what the tool returns (connector id, access, audience, linked connections, connect_url, caveat) and covers plan behavior and the hint response for empty keywords. It is complete for the tool's complexity.

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 compensates by explaining that keywords is an array of strings (with examples) and is required, and that include_accounts affects whether accounts are returned. 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 uses a specific verb 'searches' and resource 'bank connectors', clearly stating it returns connector id, access type, audience, linked connections, and connect_url. It distinguishes from sibling tools like openfinance_list_connections by focusing on keyword search.

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 states 'Call this BEFORE connecting to hand the user a one-click link to the right bank' and notes that keywords[] is REQUIRED. It also explains how the tool honors the user's plan, providing clear context for usage.

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 the side effect: automatically creates a Category Rule affecting future similar transactions. Also explains that it overrides automatic categorization and describes the batch return shape. No contradictions with annotations (readOnlyHint=false, etc.).

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 paragraph with front-loaded main action. Contains all necessary details but is moderately dense (over 100 words). Every sentence adds value, though a slightly more structured format could improve readability.

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 fully compensates: explains return shape, side effects, parameter sources, and batch error handling. Comprehensive for a batch update 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?

Despite 0% schema description coverage, the description thoroughly explains the items parameter structure, including the required fields transaction_id and category_id, and directs the agent to sibling tools for obtaining valid IDs. Adds meaning far beyond the raw 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?

Description starts with 'Corrects the category of one or more transactions (PATCH /transactions/:id)', using a specific verb and resource. It clearly distinguishes from sibling tools like openfinance_list_transactions and openfinance_list_categories by focusing on updating categories.

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 use: 'use this to fix miscategorized transactions and improve categorization accuracy going forward'. Provides sources for IDs (openfinance_list_transactions, openfinance_list_categories). Lacks explicit when-not-to-use guidance but context strongly implies its purpose.

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 provide idempotentHint=true and destructiveHint=false, indicating safe re-call and non-destructive behavior. The description adds the behavioral detail that a conversation array should be included for reproduction. It does not contradict annotations and adds moderate 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 description is two sentences long, front-loading the purpose and following with a key usage instruction. Every sentence adds value with no unnecessary 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 lack of output schema and 0% schema description coverage, the description should provide more detail. It omits what happens after reporting, the expected format of 'message', and how 'context' influences the report. The tool's overall behavior is only partially 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?

With 0% schema description coverage, the description must compensate. It only clarifies the 'conversation' parameter ('recent messages for reproduction') but does not explain 'context' or 'message'. This leaves significant ambiguity for the 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: 'Report a bug, missing feature, or send feedback.' This is a specific verb ('report') and resource ('bug, missing feature, or feedback'). It is easily distinguishable from sibling tools, which are primarily financial operations and utilities.

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 'Include the conversation array with recent messages for reproduction,' providing some context for when to use the tool. However, it does not explicitly state when not to use it or suggest alternative tools, leaving the agent to infer usage boundaries.

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, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds that it shows version info, but little else 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 sentence, front-loaded with key action and output, 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?

For a zero-parameter read-only tool with full annotations, the description is complete and 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?

No parameters exist (100% schema coverage with empty properties). Baseline 4 applies; no parameter info needed.

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 shows MCP platform and adapter versions. It's distinct from sibling tools like authenticate or connect, which have different purposes.

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 guidance is provided on when to use this tool vs alternatives. While trivial, the guidelines dimension requires explicit cues, which are absent.

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 and idempotentHint=true. The description adds value by specifying the exact content of the returned state (installed MCPs, connection status, catalog tools count), which enriches the transparency without contradicting 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 sentence that is front-loaded with the verb and directly states the purpose. No extraneous words, efficient and clear.

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 covers the return values by listing three key components. The tool is simple and the description is complete for its purpose.

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 the description carries no burden for parameter documentation. The baseline score of 4 is appropriate.

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

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

The description clearly states the verb ('Returns') and the resource ('current toolkit state'), listing specific details (installed MCPs, connection status, catalog counts). This distinguishes it from sibling tools that perform specific actions.

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

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

The description makes it clear that this tool provides a global overview of the toolkit. While it doesn't explicitly state when not to use it, no sibling tool offers the same meta-information, so the usage context is well implied.

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