Banrisul MCP

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

Discloses the authentication flow behavior (browser login, token paste, link generation) beyond what annotations provide. Annotations indicate idempotent, which is consistent. 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?

While a bit long, the description is well-structured with clear separation of scenarios and uses formatting for code snippets. Every sentence adds value, 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?

Given the simple parameter set and no output schema, the description covers the essential usage scenarios. It does not detail the return value, but the implied outcomes (link or session) are sufficient for an 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?

The only parameter 'token' is explained in context (optional, session-only if provided, omitted to get link), adding meaning to the schema. Schema description coverage is 0%, so the description fully compensates.

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 is for authentication for MCP.AI IDE agents, describing two distinct modes (config-based permanent token or session-based token paste) and its role in the authentication flow. No sibling tool competes for this purpose.

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 call with token vs without, and mentions the alternative of adding token to config for permanent use. Could be more explicit about when not to use (e.g., for other auth methods), but the context 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 indicate readOnly, idempotent, non-destructive. Description adds specific return behavior for connected vs missing credentials, providing useful 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?

Two clear, front-loaded sentences with no waste. Efficiently conveys purpose and conditional behavior.

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 return scenarios. Lacks details on potential errors or edge cases, but sufficient for a simple status tool with no input and no output schema.

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

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

No parameters, baseline 4. No additional description 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?

Clearly states it returns connection status and URLs, with specific scenarios. Implicitly distinguishes from sibling 'authenticate' but lacks explicit differentiation.

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 or not use this tool versus alternatives. Usage is implied but not stated.

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

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

The description goes beyond annotations by detailing behavioral traits such as invoke working without installation, credential handling via connect links, and payment flows. It also specifies permission requirements, making the tool's behavior highly transparent.

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

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

The description is well-structured with a clear hierarchy: definition, core flow, invoke vs. install, and other actions. It is front-loaded but slightly verbose; still efficient for the 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 the tool's complexity (15 parameters, multiple actions), the description covers the main workflow, permissions, and edge cases comprehensively. It lacks detail on some parameters and outputs, but overall provides sufficient context.

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 the 'action' parameter thoroughly and linking it to other parameters like mcp_id, tool_id, and arguments. However, it does not describe many other parameters (e.g., limit, query, message), leaving gaps.

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 mcp.ai marketplace, a meta-tool for discovering and running MCPs. It specifies the core flow of actions (search, describe, invoke) and distinguishes itself from external registries, making the purpose unmistakable.

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 this tool ('use THIS tool FIRST') and contrasts invoke vs. install for single vs. permanent use. It also notes that writes require workspace owner/admin, offering 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?

Annotations already indicate destructiveHint=true. The description adds that the bank's data will no longer be available and that it returns an add_connection_url to re-connect, which provides useful behavioral context beyond the annotation. 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 three sentences long, with the main action in the first sentence. Each sentence adds unique information (action, consequence, return value). No redundancy or 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?

For a simple tool with one required parameter, no output schema, and annotations present, the description covers the main action, outcomes, and return value. Minor gaps: does not describe the format of the add_connection_url or behavior if the bank is already disconnected, but overall 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?

The input schema has one required string parameter 'item' with no description (0% coverage). The tool description does not clarify what 'item' represents (e.g., a bank identifier), leaving the parameter ambiguous. The description should have defined this to compensate for the schema's lack of information.

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 specifies the verb (revokes/deletes), resource (Open Finance consent/connection data for a specific bank), and outcome (data no longer available, returns reconnection URL). It distinguishes well from sibling tools, as 'disconnect' is unique among the openfinance_* 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 the tool should be used to revoke consent and delete bank data, but provides no explicit guidance on when to use it versus alternatives, nor does it mention prerequisites or when not to use it. No exclusions or context on side effects beyond the basic outcome.

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 the tool polls up to ~60s and returns final status, executionStatus, lastUpdatedAt, etc. It mentions potential issues like needs_action and timed_out. Annotations only provide basic hints, so the description adds significant behavioral context about synchronous waiting and error states.

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 every sentence adds value. It is front-loaded with the core purpose and method. Minor structure improvements could group details more systematically, but it remains efficient.

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 object structure ({ results, errors }) and the fields within results (status, executionStatus, lastUpdatedAt, synced, needs_action, timed_out). Edge cases like fire-and-forget and follow-up tool usage are 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?

Schema coverage is 0%, so the description fully explains both parameters: 'items' as an array of selectors and the option to omit for all banks, and 'wait' as boolean for fire-and-forget. This adds meaning well beyond the bare schema.

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

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

The description clearly states the tool forces a re-sync of connections and waits for it to finish. It specifies the verb 'forces', the resource 'connections', and distinguishes from sibling tools like 'openfinance_get_item_status' which is mentioned as a follow-up. The HTTP method and polling behavior are also described.

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 (when balance/transaction list looks stale) and provides alternatives (use openfinance_get_item_status for timed-out cases). It also explains when to use the 'wait: false' parameter for fire-and-forget behavior.

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 and idempotentHint. Description adds valuable context about BALANCE_FETCH_ERROR for credit accounts and structured warnings, plus response shape.

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

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

Three sentences, each carrying essential information. Front-loaded with verb, resource, and endpoint. 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?

Covers purpose, parameter usage, error handling, and response structure. With no output schema, the description provides sufficient context. Minor omission: no mention of idempotency or rate limits, but annotations cover safety.

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 description adds meaning by specifying account_ids is an array with a size limit of 1-50, and that it contains account IDs.

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 real-time balance per account id and specifies the endpoint. However, it does not explicitly differentiate from sibling tools like openfinance_get_accounts_detail or 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?

Provides guidance on passing account_ids as an array of 1-50 and notes error handling for credit accounts. But lacks explicit when-to-use vs alternatives or 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 already declare readOnlyHint=true and safe behavior. The description adds transparency about the batch shape and the provider_incident block, warning about potentially unreliable data. This goes beyond annotation info.

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, each carrying essential information: purpose, parameter usage, and warning. It is front-loaded and concise 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 no output schema, the description explains the batch return shape and the provider_incident warning, which covers key aspects. It could mention error handling, but for a simple parameter tool, it is sufficiently 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?

The input schema has no descriptions (0% coverage), but the description compensates by specifying that account_ids should be an array of strings (1-50). It also explains the return shape, adding meaning beyond the schema.

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

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

The description clearly states the tool returns full account objects with extended creditData per ID, specifying the endpoint and batch shape. It distinguishes from siblings like openfinance_list_accounts by emphasizing extended 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 the parameter usage (array of 1-50 IDs) and the return shape. However, it doesn't explicitly compare to other similar tools or state when not to use this tool, but the context of 'extended creditData' implies it's for detailed account retrieval.

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. Description adds critical nuances: payments[] reflects payments from previous bill cycle, and Pluggy does not return paid status. 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?

Description is fairly long but well-organized with key points first. Every sentence adds value, though minor redundancy exists (e.g., explaining payments[] twice). Still efficient 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?

No output schema, but description fully details return shape ({results, errors} batch, financeCharges, payments with fields). Covers behavioral caveats and cross-tool dependencies, making it self-contained for agent use.

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, but the description explicitly explains bill_ids parameter: pass as array, and use list_credit_card_bills first to discover ids. This clarifies usage 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 the tool returns bill-level detail for credit card bills by id, specifying fields (financeCharges, payments) and differentiating from list_transactions. Verb 'Returns' plus resource 'bill-level detail' makes purpose unmistakable.

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 instructions: first use openfinance_list_credit_card_bills to discover ids, and use openfinance_list_transactions for itemized transactions. Warns about payments[] interpretation in Brazilian Open Finance, guiding correct 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 readOnlyHint=true and idempotentHint=true, so the safety profile is clear. The description adds behavioral context beyond annotations: it explains the response format variations (count/items vs single) and mentions connector metadata. This is useful, though it could further detail the response structure.

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 only two sentences long, with no unnecessary words. It front-loads the main purpose and efficiently covers both usage modes. 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 the tool's simplicity (1 optional parameter, no output schema), the description is complete. It explains the input behavior, the response fields (status, executionStatus, connector metadata), and the structural difference between single and bulk calls. No important information is missing.

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

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

The input schema has a single 'item' parameter with no description (0% coverage). The description fully compensates by explaining that omitting the parameter returns all banks' statuses, while passing it returns a single bank's status. This is essential information not derivable from the schema alone.

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 current status of a bank connection, listing example statuses (UPDATED, UPDATING, LOGIN_ERROR, etc.), executionStatus, and connector metadata. It also distinguishes two usage modes (with or without 'item'), making the purpose specific and distinct 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 explicitly provides usage guidelines: omit 'item' to get all linked banks' status, pass 'item' for a single bank. This tells the agent exactly when to use each mode, and the sibling list shows alternative tools for other purposes.

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. The description adds value by detailing the return shape including specific fields, batch response format '{ results, errors }', and the parameter length constraint, which goes beyond the annotations without 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 efficient: first sentence states purpose and key return fields; second gives usage guidance; third details parameter; fourth notes response shape. No superfluous text, every sentence 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?

Given the simple input schema and no output schema, the description fully covers what the tool returns, how to sequence it, parameter limits, and response structure. It is complete for an agent to correctly select and 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 adds crucial meaning: it constrains 'loan_ids' to an array of strings with 1-50 items, and explains how to use it (IDs from list_loans implied). This compensates for the schema gap, though it could be clearer that items are loan IDs from the listing.

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 'Returns full loan contract detail by id' specifying the exact verb and resource, and lists detailed fields. It distinguishes from sibling tools by advising use after openfinance_list_loans, making its unique purpose 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 states 'Use after openfinance_list_loans to deep-dive on a specific contract,' providing a clear usage context and sequencing. It also gives a parameter constraint ('Pass loan_ids as an array (1-50)'), but does not include explicit when-not-to-use or alternative tools, though the sibling list is available.

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?

Goes beyond annotations by explaining the meaning of CREDIT `balance` (connector-dependent), the billing cycle fields, and the `provider_incident` block indicating unreliable data. 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 thorough but somewhat verbose. It front-loads the main purpose, but additional details make it longer than necessary. Could be tightened without losing information.

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

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

Despite no output schema, the description fully explains return values, edge cases (connector-dependent balance, provider incidents), and relationships to sibling tools. 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 provides contextual usage for both parameters: `item` filtering and `type` enum values. It explains the effect of omitting `item` but does not give an isolated parameter description, which is slightly less clear.

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 accounts for a bank connection, distinguishing between BANK and CREDIT types, and lists the returned fields. It differentiates from sibling tools like openfinance_list_credit_card_bills by specifying when to use that tool instead.

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 `item` for all banks vs. pass `item` for a single bank, and warns not to treat CREDIT `balance` as monthly bill. It also directs users to openfinance_list_credit_card_bills for standardized bill amounts.

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. The description adds valuable behavioral context: that results are cached for the session, the response is a single aggregated structure, and it explains the parent-child tree relationships. 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 a single, well-structured sentence that front-loads the core purpose, then adds essential details in a natural order. Every clause adds value, with no redundancy or filler.

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

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

Given the tool has no parameters and no output schema, the description fully covers what the agent needs: the source API, caching behavior, the exact fields returned, and the relationship to the sibling update tool. 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?

With zero parameters and 100% schema description coverage, the baseline is 4. The description adds meaning by explaining the output structure (id, description, descriptionTranslated, parentId, parentDescription), which helps the agent understand what the tool returns without needing to inspect an output 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 Pluggy's transaction category taxonomy, specifying the API endpoint, caching, and key fields (id, description, descriptionTranslated, parentId, parentDescription). It distinguishes itself from siblings like openfinance_update_transaction_category by noting the id is used for that 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 provides practical usage hints, such as preferring 'descriptionTranslated' for pt-BR users and noting that the response is a single aggregated cache (no batch ids). It implicitly guides when to call this tool (before updating a category) but lacks explicit when-not-to-use or alternatives beyond the sibling reference.

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. The description adds value by specifying the returned fields and the inclusion of an add_connection_url, which is behavioral context 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?

Single, well-structured sentence that immediately conveys the purpose and key details without any extraneous information. Efficient and front-loaded.

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

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

For a simple list tool with no parameters, the description adequately covers the return values. It does not address pagination or limits, but given the nature of bank connections, this is likely acceptable. The absence of an output schema is compensated by the description.

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

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

No parameters exist, schema coverage is 100%. The description adds meaning by listing the return fields, which is helpful given no output schema. Baseline 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?

Description clearly states it returns saved bank connections and enumerates the fields (connector_id, item_id, bank name, add_connection_url), distinguishing it from sibling tools like openfinance_list_accounts 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?

Usage is implied as a simple retrieval operation, but no explicit guidance on when to use it versus alternatives such as openfinance_get_item_status, which could provide more detail on a specific connection. With many sibling tools, some when-to-use guidance would improve 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?

Adds significant behavioral context beyond annotations: payment cycle semantics, derived payment status logic, connector asymmetry, and opt-in behavior for include_open_bill. No contradiction with readOnlyHint=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?

Well-structured with front-loaded purpose and logical sections (important notes, open bill, connector asymmetry). While lengthy, the complexity justifies the detail; minimal 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?

Comprehensively covers return fields (payments, payment_status, open_bill, etc.) and important nuances. No output schema, so description must explain return values, which it does thoroughly.

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?

Adds meaning for include_open_bill (explains opt-in and derived fields) and mentions account_ids for bulk support. However, page and page_size parameters are not described, leaving a gap given 0% schema coverage.

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 closed credit card bills for a CREDIT-type account, listing specific fields. It distinguishes itself from siblings like openfinance_get_credit_card_bill and openfinance_list_transactions by mentioning individual transaction retrieval.

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

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

Explicitly states when to use (get closed bills, optional open bill) and when not to (for itemized purchases, use openfinance_list_transactions). Provides caution about payment status misinterpretation, giving clear 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 declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true. Description adds value by explaining error handling (returns safe object instead of throwing) and enumerating fields in each row. 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?

Description is a single paragraph that efficiently states purpose, data contents, and error behavior. No fluff. Front-loaded with main purpose.

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

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

Given no output schema, description adequately covers return format (total, results, warning) and per-row fields. However, it does not explain pagination or parameter usage, leaving some context 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 has 4 parameters with 0% description coverage. Description does not mention any parameter, their roles, or how to use them (e.g., 'type' enum values correspond to asset types listed, but no connection made). Agent gets no guidance beyond schema names.

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 verb 'Returns' and resource 'investment portfolio' with specific asset types. It distinguishes from siblings by focusing on portfolio snapshot, though not explicitly.

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

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

Description does not provide when-to-use or when-not-to-use guidance, nor does it mention alternatives like openfinance_list_investment_transactions. Usage is implied but not explicit.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true. The description adds valuable behavioral context: the specific transaction types returned, the detailed fields (including expenses breakdown), and the bulk capability. 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?

Two short paragraphs with no redundant information. First sentence clearly states the core purpose and key transaction types. Second paragraph adds bulk support. 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 thoroughly explains the return fields and transaction types. It provides the usage context (after getting investment_id from another tool). Missing pagination details (page/page_size) and parameter formats, but overall adequate for a listing tool.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the purpose of investment_id and investment_ids (for bulk). However, it does not describe the page and page_size parameters (pagination). The description adds some value but not complete coverage for all 4 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 the tool returns movement history for a specific investment position, listing specific transaction types (BUY/SELL/TAX/INTEREST/AMORTIZATION/TRANSFER) and fields (quantity, value, amount, netAmount, etc.). It distinguishes itself from sibling tools like openfinance_list_investments, which provides the investment_id needed to use this 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 says 'Use after openfinance_list_investments to get the investment_id', providing clear sequencing guidance. It also mentions bulk support via investment_ids. However, it does not explicitly state when not to use or list direct alternatives among the many sibling 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 (readOnlyHint, idempotentHint, destructiveHint), description reveals sequential querying with rate-limit spacing and per-connection results/errors. Provides good behavioral 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?

Two concise sentences; first states purpose, second explains parameter and 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?

Given one parameter, no output schema, description covers purpose, parameter format, optionality, multi-connection behavior, and return structure (results/errors). Complete for agent invocation.

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

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

With 0% schema coverage, description fully explains the `items` parameter: accepts array of connection selectors (item_id, connector_id, connector_name) and that omitting it lists all linked banks. 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?

Description clearly states the tool lists loan contracts per bank connection, specifying the HTTP method and endpoint. It distinguishes from sibling list tools by focusing on loans and mentioning per-connection behavior.

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?

Description explains when to pass `items` vs omit it, and notes sequential querying with rate-limit spacing. However, it does not explicitly state when not to use the tool or provide 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?

Beyond the readOnlyHint and idempotentHint annotations, the description discloses critical behavioral traits: CREDIT account transaction coverage varies by connector (PENDING vs POSTED), upstream errors return a structured error instead of throwing, the detail parameter controls verbosity and token cost, and a provider_incident block may appear when the provider has an open incident. 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 well-structured with logical sections, but it is somewhat verbose. Some information about CREDIT accounts is repeated (e.g., billId linking) and the bulk support mention is tacked on at the end. However, every sentence adds unique value, and the length is justified by the tool's 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 the tool's complexity (8 parameters, no output schema, multiple behavioral nuances), the description covers nearly all aspects: pagination, error handling, detail levels, connnector-specific behavior, and inter-tool dependencies. It lacks an explicit structure of the returned transaction object, but it does describe the error response format and mentions fields added by 'rich' detail. A slightly more structured return specification would make it fully complete.

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

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

Despite 0% schema description coverage, the description explains every parameter: account_id/account_ids for bank selection, from/to for date filters (ISO format), search_queries for substring matching with OR semantics and aggregation up to 5000, page and page_size for manual pagination (max 500), and detail enum values (compact, rich, raw) with clear explanations of what each provides.

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

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

The description clearly states 'Returns transactions for a bank account (BANK or CREDIT type)', specifying the verb and resource. It distinguishes from siblings by explaining that for CREDIT accounts it is the only way to get itemized transactions, and it references other tools like openfinance_list_credit_card_bills and openfinance_list_accounts for complementary functionality.

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 and when-not-to-use guidance, including alternatives for bill totals (openfinance_list_credit_card_bills) and statement due dates (openfinance_list_accounts). It details pagination strategies (auto vs manual), bulk execution via account_ids, and troubleshooting steps for zero results on CREDIT accounts (check connection health via 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?

Beyond annotations (readOnlyHint, idempotentHint), the description discloses a 5000/transaction cap with truncation flag and a provider_incident block for incomplete data, adding critical behavioral 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 densely packed with valuable information but is long. It is front-loaded with the main purpose, and every sentence earns its place. Could be slightly better structured but not wasteful.

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 is present, but the description provides a high-level summary of the return structure (totals, monthly evolution, top expenses, per-account breakdown) and mentions the provider_incident block. Covers the essential context for a 7-parameter 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 thoroughly explains each parameter: item options, date format, granularity effects, detail levels, and type filter. It adds meaning 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?

The description clearly states it's for 'Consolidated cash-flow analysis for a whole bank CONNECTION over a period, in ONE call.' It distinguishes from siblings by noting it internally resolves accounts, eliminating the need for 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?

Explicitly says not to call openfinance_list_accounts first, gives example use cases like 'fluxo de caixa', and explains when to use granularity:'raw' vs default. However, it does not specify when to use alternative tools like openfinance_list_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 indicate safe read (readOnlyHint=true). The description adds behavioral details: returns global indicator, degraded components, open incidents, and your_banks_affected. 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?

Description is slightly long but every sentence is informative. Front-loaded with purpose and usage, then return details. Could be trimmed slightly but 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?

No output schema, but description fully details return values: global indicator, degraded components, open incidents, and your_banks_affected. Sufficient for a simple 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?

No parameters in input schema. Description does not need to add parameter info; baseline 4 applies for 0-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?

Clearly states the tool checks the LIVE operational status of the Open Finance provider, distinguishing it from openfinance_get_item_status. Uses specific verb 'checks' and resource 'provider status', differentiating 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?

Explicitly describes when to use: when data appears incomplete or stale despite an updated connection, to identify upstream outages or known incidents. Provides clear context but no explicit '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?

Disclosures include caveat about non-Open-Finance connectors requiring manual reconnection, plan-based filtering (PF hides PJ banks), and that returning a hint when keywords are omitted. Annotations (readOnly, idempotent, non-destructive) are consistent and reinforced.

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 flows logically, but it is somewhat lengthy. However, every sentence adds value, front-loading the core purpose. Could be slightly more 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?

Without an output schema, the description fully details return fields (id, access, audience, accounts, connect_url, caveat). Covers missing parameters and edge cases (hint when no keywords, plan filtering).

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?

Both parameters are explained: keywords as required array of strings for bank names, include_accounts as boolean to include account details. This compensates for 0% schema coverage.

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 and returns detailed match info. It distinguishes from sibling tools by focusing on connectors before connection, with specific output fields and a clear action ('Call this BEFORE connecting').

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 ('Call this BEFORE connecting'), and provides guidance on required parameter usage ('keywords[] is REQUIRED — without it returns a hint'). Contrasts with other tools implicitly.

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 the operation overrides automatic categorization and creates a Category Rule, teaching Pluggy. Also explains batch error handling (per-item errors don't fail the whole batch). This goes well beyond the annotations (readOnlyHint=false, destructiveHint=false) by detailing side effects and failure modes.

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

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

The description is a single focused paragraph that front-loads the action and covers prerequisites, side effects, and response format. It is not overly verbose, but could benefit from slight structural formatting (e.g., bullet points) for easier scanning.

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 update with side effects and error handling), the description fully covers what it does, prerequisites, future implications, and response shape. With no output schema, the detailed response description is essential and well provided.

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 clearly explains the items array structure: array of { transaction_id, category_id } with source guidance for each ID. This adds meaning beyond the bare schema, though no additional constraints or formats are specified.

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 'Corrects the category of one or more transactions (PATCH /transactions/:id)', specifying a concrete action and resource. It distinguishes itself from sibling resources like openfinance_list_transactions and openfinance_list_categories by focusing on mutation.

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 instructions on the IDs to use (coming from openfinance_list_transactions and openfinance_list_categories) and the side effect of category rules. It advises using this tool to fix miscategorizations, though it lacks explicit 'when not to use' or 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?

Annotations already indicate idempotentHint=true (safe to retry) and destructiveHint=false (non-destructive). The description adds that the conversation array should be included for reproduction. No additional behavioral traits are disclosed beyond what annotations provide. 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 a concise two-sentence structure. It front-loads the purpose in the first sentence and provides usage guidance in the second. No extraneous information. Every sentence 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?

Given the tool's simplicity (no output schema, few parameters), the description covers the core purpose and one usage hint. However, it lacks details on expected response or additional context for effective usage, making it adequate but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions the 'conversation' parameter's purpose (for reproduction) but does not explain 'context' or 'message' beyond their names. The description adds minimal meaning to the parameters, leaving 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.' It specifies the action (report) and the resource (bug/feature/feedback). This distinguishes it well from sibling tools which are unrelated (authentication, finance 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 includes guidance to 'Include the conversation array with recent messages for reproduction,' which hints at usage context. However, it does not explicitly state when to use this tool versus alternatives, nor does it provide exclusions or prerequisites. Usage is implied but not fully prescriptive.

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, destructiveHint=false. The description adds no extra behavioral details. With full annotation coverage, the description isn't required to add more, so a 3 is fair.

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

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

A single, clear sentence with no wasted words. perfectly concise and front-loaded.

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

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

For a simple version tool with no parameters and clear annotations, the description is complete enough. It provides the essential information without needing more.

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, and schema coverage is 100% (empty schema). The description doesn't need to provide parameter info. Baseline for 0 parameters is 4, and it's adequate.

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 versions, specifically platform and adapter. It's concise and unambiguous, with no confusion from siblings since no other version tool exists.

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 vs alternatives, but it's a simple info tool. The context implies usage when version info is needed. A 3 is appropriate as it's minimal but sufficient for such a straightforward tool.

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 description carries a lower burden. It adds value by specifying the exact content of the return (installed MCPs, status, catalog tool counts), which goes beyond the 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?

The description is a single sentence that front-loads the purpose and includes all necessary details without any wasted words. It is appropriately sized for the tool's simplicity.

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 has no output schema, the description fully explains what is returned (installed MCPs, connection status, catalog tool counts). This is complete for a status-reporting tool with simple output.

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

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

The tool has zero parameters and schema coverage is 100%. The description adds no parameter information, which is appropriate. Baseline 4 applies as no additional parameter semantics are 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 uses the specific verb 'Returns' and clearly identifies the resource ('current toolkit state') with concrete details: installed MCPs, connection status, and catalog tool counts. This clearly distinguishes it from sibling tools like 'authenticate' or 'connect'.

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 context by stating what information is returned, but it does not explicitly provide when-to-use or when-not-to-use guidance or alternatives. Given the tool's simplicity, the context is sufficient, but lacks explicit exclusions.

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