BTGPactual MCP

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

Annotations indicate idempotentHint=true and destructiveHint=false, and the description explains that calling with no args returns a login link, while calling with a token performs authentication. This adds contextual behavior beyond annotations, such as the two possible outcomes. 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 efficient, front-loading the purpose and then detailing two usage scenarios. Every sentence is informative, though slightly verbose with 'MCP.AI for IDE agents (Cursor, etc.):' which could be trimmed.

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 a simple tool, the description covers the main behaviors but lacks details on error handling, token validation outcomes, or what the returned link looks like. It is adequate but not fully comprehensive.

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

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

The schema has 0% description coverage, but the description compensates by clarifying that the 'token' parameter is for pasting a JWT for session login, and that omitting it returns a link. It adds meaning beyond the schema's type/format.

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

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

The description clearly identifies the tool as an authentication mechanism for MCP.AI IDE agents, specifying the action (log in, copy token, paste or configure) and the resource (access token). It distinguishes from siblings like 'connect' and 'marketplace' by focusing on authentication.

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 each method: permanent via config header or session-only by pasting the token. It also explains the alternative of adding to config as the 'best' approach, though it doesn't explicitly list when not to use the 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 mark it read-only, idempotent, non-destructive. The description adds behavioral detail: it returns authenticated:true and empty pending[] when connected, or connect_url when missing credentials. This enriches the agent's understanding beyond annotations.

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

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

Two sentences, no filler. The first sentence states the core purpose, the second clarifies two states. Every part 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 no output schema, the description adequately describes the likely response (authenticated:true vs connect_url). It covers the tool's behavior sufficiently for an agent to understand the result. No major 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?

No parameters exist; schema coverage is 100%. Baseline for zero-param tools is 4. The description adds no parameter info, which is appropriate since none 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 clearly states the tool returns connection status and URLs. It describes two specific scenarios (all providers connected vs missing credentials), making the purpose precise. This distinguishes it from sibling tools like authenticate or 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 implicitly indicates usage: check connection status or get URLs when needed. It explains what to expect in different states. However, it does not explicitly state when to avoid using this tool or provide direct alternatives, though the sibling list provides context.

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

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

The description details behavioral traits beyond annotations: invoke runs one-off without permanent toolkit addition, install makes permanent, writes require admin, and actions like search/describe vs install/uninstall have different effects. No contradiction with annotations (readOnlyHint false, openWorldHint true, 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?

The description is lengthy but well-structured with clear sections. Each sentence adds value, though some repetition could be trimmed. It front-loads the key purpose and flow.

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 (13 parameters, multiple actions, no output schema), the description is remarkably complete. It covers the main flow, edge cases, and relationships to other tools. No output schema, but the description explains expected outcomes (connect links, checkout links, tool list) sufficiently.

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 compensates by explaining the core parameters implicitly through the flow (action, query, mcp_id, tool_id, arguments). However, not all 13 parameters are individually described, leaving some 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 it's the official marketplace and catalog of MCPs/tools, and it lists specific actions (search, describe, invoke, install, etc.) with distinct purposes. It distinguishes itself from external registries and sibling tools like 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?

Explicit guidance: 'use THIS tool FIRST' before external registries, explains when to use invoke vs install, and clarifies prerequisites (workspace owner/admin for writes). Also covers edge cases like credential needs and wallet empty with retry instructions.

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 flag destructiveHint=true and readOnlyHint=false. The description adds that bank data becomes unavailable and provides the reconnection URL, offering behavioral context beyond annotations. 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?

Two sentences efficiently convey the action, effect, and a key return value. No extraneous information.

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

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

For a simple destructive tool with one parameter and no output schema, the description covers the main behavioral aspects but omits parameter semantics. It is adequate but incomplete due to missing parameter guidance.

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 covers 0% of parameter descriptions, and the tool description does not explain the required 'item' parameter. The agent has no guidance on what value to provide (e.g., bank ID, connection ID). This is a critical gap.

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

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

The description clearly states the tool revokes Open Finance consent and deletes connection data. It uses specific verbs ('revokes', 'deletes') and identifies the resource ('bank connection'), clearly distinguishing it from sibling tools like openfinance_list_connections or openfinance_force_sync.

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 disconnecting a bank, and mentions a reconnection URL for future needs. However, it does not explicitly state when not to use it or compare it to alternatives (though no close alternative exists). The context is clear enough for an AI agent.

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 have no behavioral details. Description adds critical behavior: polls until sync finishes (up to ~60s), returns final status, executionStatus, lastUpdatedAt, synced, and explains potential states (needs_action, timed_out). 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 well-structured: function, when, what happens, params, return values. Every sentence adds value, no fluff. Could be slightly more concise, but still effective.

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 covers return fields (results, errors, status, executionStatus, lastUpdatedAt, synced, needs_action, timed_out). Also explains behavior with wait. Comprehensive for a complex force-sync tool.

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

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

Input schema has 0% coverage. Description compensates fully: explains items as array of selectors (item_id, connector_id, connector_name) and that omitting items syncs all. Also explains wait parameter (default true, set false for fire-and-forget). Adds meaning beyond type-only 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 forces a re-sync of bank connections and waits for completion. It distinguishes from sibling tools like openfinance_get_item_status and openfinance_list_connections by specifying the unique action of forcing a sync without disconnecting.

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

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

Explicit usage guidelines: use when balance or transactions look stale, no need to disconnect/reconnect. Provides alternative for re-checking (openfinance_get_item_status) and mentions fire-and-forget option with wait: false.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds value by disclosing that credit accounts may return a structured warning instead of throwing an error, and by outlining the response shape with results and errors arrays.

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, no wasted words. The description front-loads the core purpose and then adds essential details like error handling and response structure.

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

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

For a simple single-parameter tool with no output schema, the description covers the key aspects: what it does, error behavior, and response format. It could mention edge cases like empty arrays but is otherwise 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?

With 0% schema description coverage, the description compensates by explaining that account_ids is an array of strings with a 1-50 range. It does not detail ID format but provides sufficient context for usage.

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

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

The description clearly states the tool returns real-time balance for account IDs, specifying the HTTP method and endpoint. It distinguishes from siblings like openfinance_list_accounts by focusing on balance retrieval, though it does not explicitly differentiate from similar 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 mentions the input format (array of 1-50 account_ids) and notes error behavior for credit accounts. However, it does not provide explicit guidance on when to use this tool versus alternatives like openfinance_get_accounts_detail, nor does it mention prerequisites or limitations.

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 read-only, idempotent, non-destructive. Description confirms read behavior and adds batch return shape { results, errors }, 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?

Two concise sentences, front-loaded with purpose, no extraneous text.

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 read tool with one param and no output schema, description covers purpose, parameter constraints, and return shape. Lacks error details but adequate.

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

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

Schema has 0% coverage, but description adds that account_ids is an array with size limit (1-50). Does not specify item format, but adds value.

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 returns full account objects with extended creditData, specifies the HTTP endpoint, and distinguishes from listing tools by mentioning per-id detail.

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 mentions passing account_ids as an array (1-50) and implies use for detailed retrieval. No explicit alternatives but context makes it 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 readOnlyHint=true, idempotentHint=true, destructiveHint=false align with description. Description adds context about batch shape {results, errors}, Pluggy's missing paid/status field, and the nuanced meaning of payments[] (previous bill payment). 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 comprehensive but somewhat lengthy. However, it is well-structured with front-loaded purpose, limitations, and usage notes. Every sentence contributes value. Could be slightly more concise but still 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?

Given no output schema, description explains return fields and batch shape. Single parameter is fully expounded. Edge cases (payments meaning) are addressed. The agent has sufficient information to use this tool 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 has only one parameter with 0% coverage, but description explains bill_ids as an array, tells how to discover IDs via sibling tool, and notes batch shape. 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 returns bill-level detail for credit card bills by ID, lists specific fields (financeCharges, payments[] with subfields), and distinguishes from openfinance_list_transactions for individual transactions.

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

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

Explicitly instructs to first use openfinance_list_credit_card_bills to discover IDs, warns about payments[] interpretation, and recommends alternative tool for paid status. Also clarifies when not to use this 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 indicate readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds value by explaining the dual behavior (all vs. specific bank) and what the response includes (status, executionStatus, connector metadata). No contradiction.

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

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

The description is two sentences, front-loading the key purpose and usage. 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 no output schema, the description mentions the return structure for both modes (single status fields, bulk returns count and items). It is mostly complete, though a sample output would be helpful. For a simple read-only tool, it is adequate.

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

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

Schema coverage is 0% (no description for parameter). The description compensates by explaining that omitting 'item' returns all banks status and passing it returns a single bank's status. It does not specify the expected format of 'item', but the role is clearly communicated.

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 possible statuses like UPDATED, UPDATING, LOGIN_ERROR, and mentions executionStatus and connector metadata. It distinguishes two modes: omitting 'item' for all linked banks or passing 'item' for a single bank. This differentiates 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 says when to omit or include the 'item' parameter, guiding the agent on usage for bulk vs. single bank status retrieval. It does not explicitly contrast with sibling tools, but the context of use 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 valuable context: return structure, field meanings (e.g., name vs bank), balance interpretation warnings, and reference to creditData fields. 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 detailed but every sentence adds necessary information. Could be slightly more concise, but it's well-structured and front-loaded with key details.

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

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

For 2 optional params and no output schema, description is complete: explains return fields, bank identification, balance caveats, creditData fields, and directs to sibling tool for standardized bill amounts. 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?

Schema has 2 params with 0% description coverage. Description explains both: item usage (omit vs pass) and type enum (BANK/CREDIT) with their meanings. This compensates well for the missing schema descriptions.

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

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

Description clearly states the tool returns accounts for bank connections, listing types (BANK/CREDIT) with specific fields. It distinguishes from sibling tools like openfinance_list_credit_card_bills by explaining when to use each.

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 omit item to list all banks vs pass item for a single bank. Also warns about the meaning of balance being connector-dependent, though it doesn't explicitly state when not to use the 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 provide readOnlyHint, idempotentHint, destructiveHint, openWorldHint. Description adds valuable context: response is cached for the adapter session and is a single aggregated response with no batch ids. 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 covering purpose, entry structure, and response nature. No superfluous words; all information is relevant and well-organized.

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 tool with no output schema, the description explains the output fields (id, description, descriptionTranslated, parentId, parentDescription), caching behavior, and relation to another tool. Sufficient for 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?

Input schema has zero parameters (100% schema description coverage). No need for parameter elaboration. 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?

Clearly states it returns Pluggy's transaction category taxonomy, specifies the API endpoint (GET /categories), and explains the structure of entries (id, description, etc.). Distinct from sibling tools which focus on accounts, transactions, or banking 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?

Implicitly guides when to use: when needing category taxonomy, especially for updating transactions with openfinance_update_transaction_category. Notes language preference (descriptionTranslated for pt-BR). Lacks explicit when-not-to-use or alternatives, but no direct sibling alternative exists.

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 and idempotentHint. The description adds meaningful behavioral context by detailing the returned fields and the purpose of add_connection_url, which helps the agent understand the output's utility. 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 concise sentence that front-loads the purpose and lists key return values. Every part is necessary, 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?

Despite no output schema, the description lists four important fields returned. For a simple list tool with no parameters, this is adequate. Missing details like pagination or error handling, but the tool's simplicity reduces the need.

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

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

There are zero parameters (input schema is empty), so per guidelines the baseline is 4. The description adds no parameter information, which is appropriate given there are none.

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 function: returning saved bank connections for the install, and specifies the exact fields returned (connector_id, item_id, bank name, add_connection_url). This distinctively differentiates it from siblings like list_accounts or 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?

The description implies when to use the tool (to view saved bank connections) but does not explicitly state when not to use it or provide alternatives. Given the sibling tool list, the context is fairly clear, so a slight deduction for lacking explicit 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?

Extensive behavioral details beyond annotations: payment_date logic, derived payment_status, connector asymmetry, warning on non-enabled product, all consistent 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?

Long but well-structured with sections (IMPORTANT, CONNECTOR ASYMMETRY) and front-loaded intent; every sentence adds value, though 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?

Comprehensive for a complex tool with 5 params and no output schema: covers derived fields, payment logic, fallbacks, warnings, and relations to siblings; no gaps evident.

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, description explains account_id, account_ids, include_open_bill in detail; page/page_size implied but not explicitly explained, deducting slightly.

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 CREDIT accounts, listing specific fields and distinguishing it from openfinance_list_transactions for 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?

Explicit guidance: explains when to use it (list closed bills), when not (use openfinance_list_transactions for transactions), opt-in for open_bill, and connector asymmetry scenarios.

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, idempotentHint, and nondestructive behavior. The description adds valuable context about error responses (returns {total, results, warning} on 403 or upstream errors) and the fields included in results, complementing 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 a single long sentence that packs much information but lacks structure. It could be broken into bullet points or clearer sections for readability. However, it does front-load the core purpose.

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

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

Given there is no output schema, the description explains return fields (balance, amount, rates, etc.) and error behavior adequately. However, it omits parameter documentation, which is a significant gap for 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?

The description does not explain any of the 4 parameters (item, page, type, page_size). With 0% schema description coverage, the description fails to provide meaning beyond the schema. The type parameter has an enum but no explanation in text.

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

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

The description clearly states the tool returns investment portfolio details for a connection, listing specific asset types and data fields. It effectively distinguishes itself from sibling tools like openfinance_list_investment_transactions by focusing on portfolio overview.

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

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

The description specifies that the tool is for broker/bank connections with INVESTMENTS product enabled, and mentions error handling (returns structured error instead of throwing). However, it does not explicitly guide when to use this tool over alternatives or when not to use it.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, providing a clear safety profile. The description adds context about bulk support and lists the specific returned fields and transaction types, going beyond what annotations convey.

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, front-loaded with the core purpose and details. Every sentence adds value—first sentence explains what and what it returns, second sentence provides usage context and bulk support. 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 complexity of financial transactions and the absence of an output schema, the description provides a comprehensive list of transaction types and fields. It also references the prerequisite tool and bulk support. A minor gap is lack of mention of pagination behavior or rate limits, but overall it sufficiently equips an agent for correct usage.

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

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

Schema description coverage is 0%. The description explains the use of investment_id (obtained from openfinance_list_investments) and investment_ids for bulk, but does not clarify page and page_size parameters. While it adds some meaning, it does not fully compensate for the missing parameter documentation.

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

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

The description clearly states it returns movement history for investment positions, enumerates transaction types (BUY, SELL, TAX, etc.), and lists specific fields. This distinguishes it from sibling tools like openfinance_list_investments (which lists positions) and other list 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 advises to use after openfinance_list_investments to obtain the required investment_id. This provides clear sequential context. While it doesn't explicitly state when not to use alternatives, the specialization for investment transactions and bulk support implicitly differentiate it from other list tools among 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 indicate read-only and idempotent behavior. The description adds valuable behavioral context, including that multiple connections are queried sequentially with rate-limit spacing, and that output returns `{ results, errors }` per connection. 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 extremely concise—two sentences with no wasted words. It front-loads the main action and then provides necessary details. 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 simple input (one optional param) and no output schema, the description covers the key aspects: parameter semantics, behavior across multiple connections, and return structure. It could mention any pagination or limits, but it's adequately complete for an 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%, so the description carries full burden. It explains `items` as an array of connection selectors (item_id uuid, connector_id, or connector_name) and describes the effect of omitting it. This 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 the tool lists loan contracts per bank connection, tying it to a specific resource and endpoint (GET /loans). It distinguishes from siblings like openfinance_list_accounts or openfinance_list_transactions by focusing solely on loans.

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 guidance on when to use the `items` parameter (for specific connections) and when to omit it (all linked banks). It also explains sequential querying with rate-limit spacing. It could be more explicit about alternatives, but the context is sufficient.

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

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

Adds significant context beyond annotations: explains CREDIT PENDING vs POSTED behavior varies by connector, search query semantics, aggregation limit of 5000, and error response format. No contradiction with annotations (readOnlyHint=true, destructiveHint=false).

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 comprehensive but somewhat verbose. It front-loads the main purpose, but includes many details in a dense paragraph. Could be slightly more concise while retaining all essential information. 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?

Given the tool's complexity (7 parameters, credit card nuances, error states), the description is highly complete. It covers usage, edge cases, sibling differentiation, and response format (though no output schema). Provides guidance for troubleshooting zero results.

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?

Since schema description coverage is 0%, the description fully compensates by detailing each parameter: from/to as ISO YYYY-MM-DD, page_size max 500, search_queries as case- and accent-insensitive substring match with OR semantics, and bulk support via account_ids. This adds substantial value beyond the bare schema.

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

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

Clearly states it returns transactions for BANK or CREDIT accounts, and distinguishes between them. It also differentiates from sibling tools like openfinance_list_credit_card_bills by specifying that for CREDIT accounts this is the only way to get itemized transactions.

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

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

Provides explicit guidance on when to use this tool vs alternatives (e.g., for standardized open-bill total use openfinance_list_credit_card_bills). Also advises on date filters, pagination, search queries, and error handling. Mentions checking connection health for zero results on credit accounts.

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?

Description adds significant behavioral context beyond annotations: it resolves accounts internally, fans out transactions, caps at 5000/account with truncation flag, and details return structure (compact vs raw). No contradiction with annotations which state readOnlyHint and idempotentHint.

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 thorough and well-front-loaded with the core purpose. Every sentence adds value, but length could be slightly reduced for extreme conciseness. However, it remains readable and efficiently 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 high complexity (6 params, no required, no output schema), the description covers all necessary aspects: input parameters, use cases, return structure (compact vs raw, totals, monthly evolution, top items, per-account breakdown, truncation flag). No gaps for an AI agent to select and invoke the tool 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?

All 6 parameters are semantically explained despite 0% schema coverage. 'item' is described as connector_id/name or item_id, 'from'/'to' as ISO dates, 'granularity' with monthly/raw explanation, 'type' as BANK/CREDIT, and 'top_n' is implied by 'largest N each'. This fully compensates for missing schema descriptions.

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

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

Description clearly states it provides consolidated cash-flow analysis for a whole bank connection, resolving accounts internally. It distinguishes itself from sibling tools like openfinance_list_accounts and openfinance_list_transactions by noting that no prior calls are needed, and specifies use cases like 'análise anual/mensal' and 'fluxo de caixa'.

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

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

Explicitly tells when to use (cash-flow analysis, top expenses) and when not to (if raw transactions needed, set granularity). It advises against calling openfinance_list_accounts first, but does not name alternative tools directly. Still, provides clear guidance on omitting 'item' to analyze all linked banks.

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=true, idempotent=true, and destructive=false. The description adds valuable behavioral context beyond annotations, detailing what the tool returns: global indicator, degraded components, open incidents, and `your_banks_affected`. This gives full transparency for an AI agent.

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 yet comprehensive, with a clear structure: purpose first, then usage scenario, then return details. Every sentence adds value without redundancy. It is well 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?

Despite having no output schema, the description fully explains the return value contents (global indicator, degraded components, incidents, and user-specific affected banks). For a parameterless status check, this provides complete contextual information.

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

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

The tool has 0 parameters and schema coverage is 100%. With no parameters, the description does not need to add parameter info. Baseline for 0 params is 4, and the description appropriately avoids extraneous detail.

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

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

The description clearly states 'Checks the LIVE operational status of the Open Finance provider' with a specific verb and resource. It also explicitly distinguishes from the sibling tool `openfinance_get_item_status`, 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 explicit when-to-use guidance: 'whenever data looks incomplete or stale even though a connection shows UPDATED'. It also explains what the tool does not do (replacing connection status check) and why it should be used to differentiate provider-side issues from connection problems.

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 valuable behavioral details: returns a hint if no keywords are provided (never dumps the whole catalog) and filters based on the user's plan.

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 with no unnecessary words. It front-loads the primary purpose, then details return values and behavior, and ends with a usage reminder. Every sentence serves a clear 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 the number of parameters (2), no output schema, and the tool's role in a larger workflow, the description is complete. It covers inputs, outputs, and special behaviors (hint, plan-based filtering) without needing to reference sibling tools.

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

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

Schema description coverage is 0%, so the description must compensate. It does so effectively: explains keywords[] as an array of strings (e.g., ['nubank','btg']), states it is REQUIRED, and describes include_accounts as controlling whether linked accounts are included.

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 (keywords), and specifies what it returns (connector id, access type, audience, linked connections, accounts, connect_url). It also distinguishes this from other operations by instructing to 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?

The description gives explicit usage guidance: call this BEFORE connecting, keywords are required, and it honors the user's plan. However, it does not explicitly mention when not to use this tool or suggest alternatives among the sibling tools.

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

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

The description discloses key behaviors: overrides automatic categorization, creates a Category Rule for future transactions, and details batch handling with per-item errors. Annotations are neutral (all false), so no contradiction. The description carries the full burden and does so well.

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 lengthy but each sentence is informative. It is front-loaded with the main action and proceeds logically to parameter explanation, behavioral impact, and output format. Minor structural improvements could be made, but overall it is 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?

Given no output schema, the description fully explains the return shape (updated, results, errors) and batch behavior. It also covers the side effect of creating a rule. It lacks details on error handling specifics or constraints on category_id, but is fairly complete for a single-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?

Schema description coverage is 0%, so the description must compensate. It explains the 'items' parameter structure and provides context on where to get the required IDs (from list tools). This adds significant meaning beyond the raw schema, though it does not detail any constraints on valid values.

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

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

The description clearly states the tool 'corrects the category of one or more transactions' with the HTTP method PATCH. It specifies the resource ('transactions') and the action ('corrects category'), distinguishing it from sibling listing 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 gives clear usage guidance: use to fix miscategorized transactions, and explains the side effect of teaching Pluggy. It also tells where to obtain transaction_id and category_id from other tools. However, it does not explicitly state when NOT to use it or mention alternatives.

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

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

Annotations indicate idempotentHint=true, destructiveHint=false. The description does not contradict them and adds the importance of including conversation for reproduction. However, it does not disclose what happens upon submission (e.g., ticket creation, email), rate limits, or authentication requirements.

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 (two sentences) and front-loaded with the purpose. No unnecessary words, but could be slightly more formal.

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?

Lacks output schema, and the description does not explain return values or success/failure behavior. For a simple feedback tool with 3 parameters, it is minimally complete but missing parameter semantics limits its usefulness.

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 only mentions 'conversation array' but fails to explain the other parameters ('context', 'message'), their purpose, or expected formats. This is a significant gap for a 3-parameter tool.

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's purpose: 'Report a bug, missing feature, or send feedback.' It specifies the verb and resource, distinguishing it from sibling tools that focus on authentication or 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 provides guidance: 'Include the conversation array with recent messages for reproduction.' This helps the agent understand the required input context. However, it does not explicitly mention when not to use the tool or provide alternatives for similar actions.

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, which clearly communicate safety and idempotency. The description adds the specific output context ('MCP platform and adapter versions') but does not disclose additional behavioral traits 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 a single sentence that directly states the tool's function with no extraneous words. It is front-loaded and 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?

For a simple tool with no parameters and a well-defined output (versions), the description is complete. It adequately informs the agent about what the tool returns, and the lack of an output schema is acceptable given the simplicity.

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

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

The tool has no parameters and schema coverage is 100%. The description does not need to add parameter information beyond the schema, as there are none. 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?

The description uses the specific verb 'show' and clearly identifies the resource as 'the current MCP platform and adapter versions', making the tool's purpose unambiguous. It distinguishes itself from siblings like 'toolkit_info' by focusing specifically on version information.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as 'toolkit_info' or other informational tools. An explicit recommendation or exclusion 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?

Annotations already mark readOnlyHint and idempotentHint as true. The description adds concrete behavioral insight by listing what data is returned (installed MCPs, connection status, catalog tools count), going 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 a single, well-structured sentence that front-loads the purpose ('Returns the current toolkit state') and lists specific outputs. Every part earns its place with 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 tool's simplicity (zero parameters, no output schema, and rich annotations), the description is adequate. However, it could be slightly enhanced by noting that the response is a snapshot or that it does not alter state, but this is already covered by 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?

There are no parameters, so the baseline is 4. The description does not need to add parameter meaning, and the schema coverage is 100% vacuously. No further semantic guidance is required.

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

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

The description explicitly states the verb 'Returns' and the resource 'current toolkit state', with specific items (installed MCPs, connection status, catalog tools counts). This clearly distinguishes it from sibling tools like authenticate or connect that perform 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 implies it is used to inspect toolkit state, which is a read-only diagnostic action. No explicit when-to-use or alternatives are given, but the context is clear given the tool's name and zero parameters.

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