Monte Bravo MCP

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

The description explains the behavioral difference between calling with and without the token, and notes that config-based tokens are permanent while session tokens are not. Annotations indicate idempotent, which aligns. No contradictions, and the description adds context beyond the annotations about the two login 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 three sentences, each presenting a distinct and necessary piece of information: the context, the best practice, and the alternative usage. No fluff, 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 is simple (one optional parameter, no output schema), the description sufficiently covers the purpose and usage. It could mention error cases or the link format, but it is complete enough for an agent to decide whether and how to invoke it. Sibling tools do not overlap significantly.

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 no description for the 'token' parameter (0% coverage). The description compensates fully by explaining that 'token' is a JWT access token and that omitting it returns a login link. This is clear and actionable.

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 is for authentication ('log in') for MCP.AI IDE agents. It specifies the exact usage: obtaining a token from the browser and either adding it to config for permanent access or passing it as a JWT for session-only login. This distinguishes it from siblings like 'connect' or 'marketplace'.

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

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

The description provides explicit guidance on when to use each mode (config vs. session token vs. no arguments to get link). It implies when to use by outlining the best practices, but does not explicitly exclude alternative tools or 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 declare readOnlyHint, idempotentHint, and destructiveHint. The description adds useful behavioral context beyond annotations, such as returning authenticated:true with empty pending[] when connected, or connect_url when credentials are missing.

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

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

The description is concise, with two sentences that are clear and to the point. No unnecessary information.

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

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

Given no output schema, the description explains the two main states of the tool. While it could detail the exact response fields, it provides enough context 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?

There are no parameters, and schema description coverage is 100%. The description does not need to explain parameters, so it is satisfactory.

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

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

The description clearly states it returns connection status and URLs, with specific behavior for different states. While the name 'connect' is generic, the description clarifies its purpose. However, it could better differentiate from the sibling tool 'authenticate' which likely deals with 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 context on when to use the tool by describing the two possible states (all providers connected vs credentials missing). However, it does not explicitly state when not to use it or mention 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?

The description discloses important behavioral traits beyond annotations: invoke works even when the MCP is not installed, credential/logins return a connect link, paid tools with empty wallet return a checkout/top-up link, and install makes an MCP permanent. It also notes that writes (install/uninstall/subscribe/cancel and the one-off install behind invoke) require owner/admin. Annotations provide readOnlyHint=false and destructiveHint=false, which do not contradict the description; the description adds meaningful operational 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 a single dense paragraph with several long, run-on sentences and many embedded clauses. It front-loads the core purpose and flow well, but the prompt-library section is tacked on at the end and the whole text is harder to parse than it should be. Some bolding or bullet structure would have earned a higher score; every sentence does carry information, but the overall structure lacks conciseness.

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

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

Given the tool's high complexity (23 parameters, 14 actions, no output schema), the description is quite complete: it explains the main flows, write permissions, authentication/link behavior, and prompt-library operations. It does not describe the exact result format of search/list_tools or error conditions, but for a broad dispatcher tool it provides enough context for an agent to choose and invoke the appropriate action.

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

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

Schema description coverage is 0%, and no parameters have descriptions. The description compensates by mapping key action values to their semantics: search, describe, invoke with 'tool_id', install, subscribe/cancel, report_bug, request_mcp, and the prompt-related actions. It explains important argument roles (tool_id, prompt_vars, prompt_slug). However, it does not elaborate on many secondary parameters (limit, tier_slug, cancel_reason, conversation, etc.), so it is not a complete substitute for schema-level 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 opens with a strong, specific statement: 'The official mcp.ai marketplace — the in-platform catalog of every MCP/tool, AND the way to run them.' It clearly names the resource and the core verbs (search, describe, invoke, install, list_tools, subscribe/cancel, prompts). It distinguishes itself from sibling openfinance tools and utility tools by establishing itself as the central MCP catalog and execution layer.

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: 'Core flow: action=search discovers MCPs by intent → describe returns one MCP's full profile ... → invoke RUNS that tool.' It also contrasts invoke vs install ('prefer invoke for a single/occasional use'), names list_tools for 'what is callable right now', assigns billing actions to subscribe/cancel, and states that writes require workspace owner/admin. This is far beyond generic 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 declare destructiveHint=true. The description adds useful context: consent revocation, data deletion, unavailability of data, and a return value for reconnection. 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 concise sentences front-loaded with the main action. Every sentence adds value 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 destructive action, single parameter, no output schema, and sufficient annotations, the description covers the key behavioral aspects. It could improve by documenting the parameter, but overall it is reasonably complete.

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

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

Schema coverage is 0% and the description does not clarify the 'item' parameter (e.g., bank ID or name). It only mentions 'specific bank', which leaves the parameter meaning ambiguous.

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

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

The description clearly states the action: revokes consent and deletes connection data for a specific bank. It uses specific verbs and resources, and distinguishes from sibling tools like connect or list_connections by its destructive nature.

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 notes the consequence (data no longer available) and return (reconnection URL). However, it does not explicitly state when to use versus alternatives like openfinance_list_connections 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 indicate mutation (readOnlyHint=false). Description adds details: waits up to ~60s, polls until item stops updating, returns reconnect_url for MFA scenarios, and confirms no disconnect/reconnect needed.

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

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

Single dense paragraph that effectively front-loads key action. Could be improved with structure (e.g., bullet points), but no waste and covers all necessary 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?

Comprehensive for 2-param tool without output schema. Details return structure (results, errors), status fields, timed_out handling, and MFA reconnection flow. References sibling tool for continued polling.

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

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

Schema coverage 0%, but description compensates fully: explains wait as boolean for sync mode, items as array of selectors (item_id, connector_id, etc.), and omitting syncs all linked banks.

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 'forces bank to re-sync connections' with specific verb-resource. Distinguishes from sibling openfinance_get_item_status by explaining that it pulls fresh data without disconnect/reconnect.

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

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

Explicitly says when to use (stale balance/transaction list) and provides usage variants: omit items to sync all, set wait=false for fire-and-forget. References sibling tool for polling on timeout.

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 readOnly and idempotent. Description adds non-obvious behaviors: BALANCE_FETCH_ERROR for CREDIT accounts, degradation to last-synced balance with realtime:false and warning, and structured response with errors array. Adds value beyond annotations.

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

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

Concise single paragraph with clear front-loading of main purpose, followed by edge cases and response shape. Every sentence adds value 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 no output schema, description fully captures response shape. Covers multiple error and degradation scenarios, making the tool's behavior predictable without needing to consult external docs.

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

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

Schema has 0% description coverage for the single parameter. Description adds critical constraint: array length 1-50. Also explains response shape. Provides meaning beyond schema structure.

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

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

The description clearly states the tool returns real-time balance per account id via a specific endpoint. It distinguishes from siblings by focusing on balance retrieval, not listing accounts or other 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?

Specifies usage: pass account_ids as array (1-50). Describes edge cases (CREDIT accounts, upstream unavailability) and response structure. Lacks explicit when-not or alternatives, but context is sufficient.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false. The description adds important behavioral context: batch response shape {results, errors}, and a provider_incident block that can make credit limits/balances unreliable. This adds value beyond 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 three sentences with zero waste. First sentence states purpose, second gives parameter guidance, third warns about data reliability. Information is front-loaded and every sentence serves a distinct 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 single parameter, clear annotations, and no output schema, the description covers the core functionality and a critical caveat. It does not detail the full return structure, but the warning about provider_incident is essential. Adequate 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?

Schema has one parameter with 0% description coverage. The description explains it's an array of 1-50 items and implies they are account IDs (per id). It adds the batch response shape. However, it does not specify the format or type of the strings, leaving some ambiguity. Still, it compensates partially.

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. It specifies the endpoint and distinguishes from list accounts by highlighting detailed data. The verb 'Returns' and resource 'account objects' are specific.

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

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

The description explains to pass account_ids as an array (1-50) and describes batch shape. It provides a critical usage warning about provider_incident blocks. However, it does not explicitly state when to use this tool over siblings like openfinance_list_accounts, though the detail level is implied.

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

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

Annotations already indicate readOnlyHint, destructiveHint, and idempotentHint. The description adds crucial behavioral context: Pluggy doesn't return a paid/status field, payments[] reflect previous bill payments, and bill totals should not be reconstructed from transactions. 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: purpose first, then exclusions, then guidance and warnings. Every sentence adds value, but the length could be slightly reduced without losing information. Overall, it is 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 one parameter and no output schema, the description fully covers what an agent needs: return fields, batch shape, limitations, and cross-tool dependencies. It is comprehensive and prevents misuse.

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

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

Schema coverage is 0%, so the description must compensate. It explains that bill_ids should be an array and that IDs come from openfinance_list_credit_card_bills. While it doesn't specify ID format or constraints, the guidance is sufficient for correct 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 bill-level detail for credit card bills by ID, listing specific fields like financeCharges and payments. It explicitly distinguishes from sibling tools by stating what it does NOT return (individual transactions) and directing users to openfinance_list_transactions for itemized 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 provides explicit when-to-use (need bill-level detail) and when-not-to-use (need itemized transactions). It names the alternative tool (openfinance_list_transactions) with specific parameters and date range. It also warns about the meaning of payments[] in Brazilian Open Finance and advises using openfinance_list_credit_card_bills for paid status.

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

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

The description adds context beyond annotations: it discloses the reconnect_url behavior, possible status values (UPDATED, UPDATING, LOGIN_ERROR), and that it doesn't consume a connection slot. Annotations already indicate read-only, idempotent, non-destructive, consistent with description.

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, front-loaded with the main purpose, and each sentence adds value. No wasted words.

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

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

Given no output schema, the description covers return fields, multiple usage modes, and reconnect URL. Could mention behavior when both 'item' and 'item_ids' are provided, but overall sufficient for a read-only tool with good annotations.

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

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

Schema coverage is 0%, so the description must carry parameter meaning. It explains the effect of omitting 'item' vs passing it, and mentions bulk via 'item_ids'. However, it does not differentiate 'item' from 'item_id', nor specify constraints like data types beyond schema. Still adds substantial 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?

The description clearly states the tool returns the current status of a bank connection, listing specific fields (status, executionStatus, connector metadata, reconnect_url). It differentiates from sibling tools like openfinance_list_connections by focusing on status and providing a reconnect mechanism.

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

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

The description explains when to omit or include the 'item' parameter for all vs single bank, and mentions bulk support with 'item_ids'. It does not explicitly contrast with alternatives like openfinance_list_connections or openfinance_force_sync, but the usage patterns are clear.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description adds value by detailing the batch response shape ({ results, errors }) and the parameter constraint (array of 1-50). 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 paragraph that fronts the core purpose and then adds details; while thorough, it could be slightly more concise (e.g., reducing field listing). However, every sentence serves a 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 and only one parameter, the description provides sufficient completeness: it enumerates key fields, specifies parameter constraints, explains the batch response format, and includes a usage workflow reference. No gaps that would hinder an AI agent.

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

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

The input schema has 0% description coverage; the description fully compensates by specifying that loan_ids is an array of strings limited to 1-50 items, and explains the expected batch response shape, adding crucial context for correct invocation.

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

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

The description clearly states it returns full loan contract detail by ID, enumerating specific fields (interestRates, amortizationScheduled, etc.), and distinguishes from the sibling openfinance_list_loans by indicating this is a deep-dive tool for specific contracts.

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_loans, providing a clear workflow. Specifies the batch shape and array size limit (1-50), but does not mention when not to use or alternative tools for other data.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so safety is clear. The description adds critical behavioral context: CREDIT balance meaning varies by connector, provider_incident block can make values unreliable, identity_notice requires deduplication by account number. These go well 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 relatively long but every sentence adds value. It is front-loaded with the core purpose, followed by parameter guidance, then edge cases and warnings. Minor redundancy exists (e.g., repeating 'bank' field explanation), but overall it is structured well.

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

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

Given the tool's complexity (multiple account types, connector-dependent behaviors, incident handling, deduplication) and lack of output schema, the description covers all important aspects: response structure, edge cases for credit balances, provider incidents, identity notices, and bulk support. It is 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?

Schema has 0% description coverage, so description compensates. It explains the effect of omitting vs passing item, and mentions item_ids for bulk support. However, it does not explicitly explain the 'type' parameter or differentiate between 'item' and 'item_id' clearly, leaving some ambiguity.

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

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

The description clearly states it returns accounts for a bank connection, listing specific fields like balance, number, type, subtype. It distinguishes between BANK and CREDIT types and explains the meaning of fields like name and bank, differentiating itself from siblings like openfinance_list_credit_card_bills.

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

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

Explicitly tells when to omit item (to list all accounts) vs pass item (to target a single bank). Provides warnings about CREDIT balance being connector-dependent and recommends alternative tool (openfinance_list_credit_card_bills) for standardized bill amounts. Also explains when not to trust certain values due to provider incidents.

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. The description adds valuable context: caching for the session, single aggregated response, and no batch ids. This goes beyond annotations.

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

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

Every sentence is informative. Front-loaded with the main purpose, then details on fields, language, caching. No fluff or repetition.

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

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

Given zero parameters and no output schema, the description fully explains the response structure (fields, caching) and usage hint (language). Complete for a simple retrieval 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 has no parameters (100% coverage). Description adds no parameter semantics, but baseline for zero parameters is 4. No missing 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 states it returns Pluggy's transaction category taxonomy, mentioning caching and specific fields like id, description, descriptionTranslated, parentId, parentDescription. It also links the categoryId to another tool, but does not explicitly distinguish from siblings, though it is unique among them.

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 on language preference (Portuguese for pt-BR users), but does not explicitly state when to use this tool versus alternatives. Since there is no direct sibling for categories, context is adequate.

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 valuable behavioral details about the reconnect_url (UPDATE mode, no slot consumption, no disconnection needed) and the add_connection_url, going beyond what annotations provide.

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

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

The description is somewhat lengthy (4 sentences) but each sentence provides essential information. It is front-loaded with the primary purpose and structured logically. Minor reduction could improve conciseness without losing clarity.

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

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

For a parameterless list tool with annotations present, the description covers returned fields and special URL behaviors. It lacks details on pagination or empty results, but these are less critical for this simple tool. Overall, 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 tool has zero parameters, so the baseline is 4. The description is not required to explain parameters, and it adds no parameter information, which is appropriate.

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

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

The description clearly states the tool 'Returns the saved bank connections' and lists specific fields (connector_id, item_id, bank name, etc.), distinguishing it from sibling tools that handle accounts, transactions, or other resources.

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

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

The description explains when to use the reconnect_url (re-authentication, MFA, LOGIN_ERROR, stale data) and its behavior, but does not explicitly state when to use the tool itself versus alternatives. The context is clear for a simple list operation.

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

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

Annotations only indicate readOnlyHint=true and idempotentHint=true. The description adds deep behavioral context: derived payment_status logic, open_bill derivation, connector asymmetry, and warning about bill grouping reliability. 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?

Very long description with multiple paragraphs. Front-loaded with purpose, but extensive details make it less concise. Every sentence adds value, but could be more 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 complexity (5 params, no output schema), the description is extremely thorough: covers input, output structure, derived fields, edge cases, warnings. It is practically a mini-manual.

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 description must compensate. It thoroughly explains include_open_bill and account_ids (bulk). However, page and page_size parameters are not described, leaving some 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 it returns CLOSED credit card bills for a CREDIT-type account, listing specific fields (dueDate, totalAmount, payments, etc.). It distinguishes itself from siblings like openfinance_get_credit_card_bill (singular) and openfinance_list_transactions.

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

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

Explicit guidelines: when to use include_open_bill, warnings about payment semantics and connector asymmetry, and advice against reconstructing bill totals from transactions. Also mentions alternative tool openfinance_list_transactions for itemized charges.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds significant behavioral context: error handling (returns structure instead of throwing), data integrity checks via transaction history cross-referencing, and specific warnings. 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 detailed but well-structured with paragraphs for different aspects (purpose, error handling, data integrity). It is front-loaded with the main purpose. While somewhat lengthy, all sentences add value, so it's acceptable.

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 6 parameters and no output schema, the description covers output behavior thoroughly, including error handling and data integrity. However, it lacks parameter explanations, which is a gap. Overall, it provides enough context for an agent to use the tool correctly in most scenarios.

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

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

Schema description coverage is 0%, so the description must compensate. It only explains item_ids for bulk execution but does not clarify parameters like item, page, type, or page_size. This leaves the agent guessing about their meaning and 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 explicitly states it returns investment portfolio data for a connection, listing specific asset types like FIIs, stocks, ETFs, etc., and details the fields included. This clearly distinguishes it from sibling tools such as openfinance_get_account_balance 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?

The description provides guidance on bulk execution via item_ids and explains behavior when INVESTMENTS is not enabled. It also discusses data integrity warnings, telling the agent not to sum suspect_zeroed rows. However, it does not explicitly state when to avoid using this tool or compare directly with alternatives.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. Description adds transaction types, specific fields (expenses, agreedRate, etc.), and bulk behavior. 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 efficient paragraphs with no fluff. Front-loaded with main purpose, then usage hints. Every sentence adds value.

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

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

With annotations present, description provides usage context, return details, and bulk support. Lacks explanation of pagination parameters, but overall sufficient for a list tool.

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

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

Schema coverage is 0% (no param descriptions). Description mentions investment_id and investment_ids, but omits page and page_size parameters entirely, leaving their semantics undocumented.

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), resource (movement history for investment position), and lists transaction types (BUY/SELL/TAX/INTEREST/AMORTIZATION/TRANSFER). Distinguishes from sibling openfinance_list_investments.

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 get investment_id, and mentions bulk support for investment_ids. Provides contextual ordering without excluding 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 read-only, non-destructive, idempotent. Description adds sequential query behavior and return format, providing valuable 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?

Three sentences, front-loaded purpose, 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?

With no output schema, description includes return format. Covers all key behaviors for this one-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 has 0% coverage, but description fully explains 'items' as connection selectors with types and usage, compensating completely.

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 'lists loan contracts per bank connection' with specific verb and resource. Distinguishes from siblings like openfinance_get_loan_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?

Explains when to use 'items' parameter and when to omit for all banks. Mentions sequential queries and rate limiting. Could explicitly 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?

Discloses extensive behavioral details: pagination auto vs manual, error handling (returns warning object), credit card metadata sparsity, connector-dependent date coverage, provider_incident block, and bulk support. 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 very long and dense, covering many edge cases. While well-organized with clear sections, it could be more concise for agent consumption.

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 params, multiple modes, credit card specifics), the description covers all aspects: pagination, filtering, credit card metadata, error handling, provider incidents, and cross-references to sibling tools. No output schema, but response structure is described.

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

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

Despite 0% schema coverage, the description thoroughly explains each parameter: date format (ISO YYYY-MM-DD), search_queries semantics, detail enum (compact/rich/raw) with effects, pagination params with defaults and behavior, and account_ids for bulk.

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

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

The description clearly states it returns transactions for bank/credit accounts. It distinguishes itself as the ONLY way to get itemized credit card transactions and contrasts with openfinance_list_credit_card_bills for bill totals.

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

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

Explicitly tells when to use this tool (for credit card itemized transactions) and when to use alternatives (openfinance_list_credit_card_bills for standardized totals). Provides guidance on connection health checks, force sync, and provider incidents.

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 disclosing truncation at 5000 transactions per account with a truncated flag, potential provider_incident block affecting data completeness, and bulk support via item_ids. Annotations only indicate read-only and idempotent, so this additional context is highly valuable.

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, starting with the main purpose, then parameter details, and ending with edge cases. It is slightly verbose with examples like 'análise anual/mensal', but every sentence adds value. A more concise version could omit some examples, but current length is justified by 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 9 parameters, no output schema, and many sibling tools, the description is remarkably complete. It covers what the tool does, how to use it, parameter formats and defaults, response contents (summary fields like por_mes, top_despesas), truncation behavior, and provider incidents. Without output schema, it provides sufficient detail for correct 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 description coverage, the description fully compensates by explaining every parameter: item (connector_id, connector_name, or item_id), from/to as ISO dates, granularity with default and raw option, type for BANK/CREDIT, detail levels (compact, rich, raw), top_n implied in top_despesas, and item_ids for batch. No formal param descriptions exist, so this is critical.

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 provides consolidated cash-flow analysis for a bank connection in one call, resolving accounts internally. It uses specific verb 'analyze' and resource 'connection transactions', and distinguishes itself from siblings like openfinance_list_transactions by explaining it avoids separate account listing.

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 use this tool: for annual/monthly cash flow analysis, and explains that it eliminates the need for prior account listing. It also provides use case examples. However, it could more directly state when alternatives like openfinance_list_transactions are preferred (e.g., for per-account raw data), but the context is still clear.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the description confirms it's a non-destructive read. It adds context that the tool queries a public status page and returns global indicator, degraded components, open incidents, and affected banks. This adds value beyond annotations but no deep behavioral surprises.

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: first states the core purpose, second provides usage guidance and details. No filler words, front-loaded with the main action, and each sentence earns its place. Very 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 zero parameters and no output schema, the description covers the tool's purpose, use case, and return value details comprehensively. It does not mention rate limits or edge cases, but for a simple status-check 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 tool has zero parameters with 100% schema coverage (empty schema). The description compensates by listing all returned fields (global indicator, degraded components, incidents, your_banks_affected), which adds meaning beyond the schema. Per guidelines, baseline is 4 for 0 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?

Description clearly states it checks the LIVE operational status of the Open Finance provider's public status page. It distinguishes itself from sibling tool openfinance_get_item_status by specifying it checks provider health, not the user's connection. The verb 'Checks' and resource 'provider status' are specific and unambiguous.

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

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

Explicitly tells when to use: 'whenever data looks incomplete or stale even though a connection shows UPDATED'. It explains the tool reveals upstream outages and helps differentiate provider-side problems from connection issues. While it doesn't explicitly state when not to use, the context is clear enough for the 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 already indicate readOnly, idempotent, non-destructive. Description adds significant behavioral info: caveat warnings, plan-based visibility, never dumps catalog, and return contents.

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?

Packed with necessary information but slightly verbose. Front-loaded with main purpose. Each sentence adds value, though some details could be streamlined.

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

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

With no output schema, description details the return fields (connector id, access, audience, connections, accounts, connect_url) and special behaviors. Lacks explicit output format but sufficient for a search 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 has 0% parameter descriptions, so description compensates by explaining keywords usage with examples and include_accounts purpose. Minor discrepancy: schema marks keywords optional, description says 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?

Clearly states it searches bank connectors by name and returns detailed match info including a connect_url. Differentiates from siblings like 'connect' by being the pre-connection search step.

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 call 'BEFORE connecting' and notes that keywords is required, with a fallback hint. Lacks explicit exclusions or alternatives, but context makes usage straightforward.

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=false, destructiveHint=false), the description discloses that recategorizing creates a Category Rule for future similar transactions, explains batch error handling (per-item errors do not fail the whole batch), and specifies the return shape. This adds significant value.

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 slightly verbose but front-loaded with the main action. Every sentence adds value, covering side effects, batch behavior, and error handling. A minor trim could improve conciseness.

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

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

Given the complexity (side effect, batch processing, error handling) and lack of output schema, the description is complete. It explains the return shape, error list, and the learning mechanism, leaving no critical gaps.

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

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

Schema coverage is 0%, but the description fully explains the 'items' parameter as an array of { transaction_id, category_id }, and tells where to get these IDs (from openfinance_list_transactions and openfinance_list_categories). This compensates for the lack of schema descriptions.

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

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

The description states 'Corrects the category of one or more transactions (PATCH /transactions/:id)', which uses a specific verb and resource. It clearly distinguishes from sibling tools like openfinance_list_transactions and openfinance_list_categories.

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

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

The description explicitly says 'use this to fix miscategorized transactions and improve categorization accuracy going forward', providing clear when-to-use guidance. It does not explicitly state when not to use or name alternative tools, 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 provide idempotentHint=true; description adds reproduction context but no other behavioral traits beyond write intent. Does not contradict annotations.

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

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

Two sentences, no wasted words, first sentence states purpose, second provides guideline.

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; description lacks return value explanation and full parameter guidance. Adequate for a simple feedback tool but not 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?

With 0% schema description coverage, description only clarifies 'conversation' parameter purpose but not 'message' (required) or 'context'. Insufficient for 3 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?

Description clearly states the tool reports bugs, missing features, or feedback, distinguishing it from sibling tools focused on Open Finance or 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?

Explicitly advises including the conversation array for reproduction, though does not specify when to use vs alternatives, which are absent.

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

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

Annotations already provide readOnlyHint=true, idempotentHint=true, destructiveHint=false; description adds no behavioral context beyond confirming it's a read operation.

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

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

Single sentence with no wasted words, clearly front-loaded with the action and result.

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, no-output-schema tool with rich annotations, the description is complete and 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?

No parameters exist, so schema coverage is 100%; description adds meaning by specifying what versions are shown.

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

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

The description clearly states the tool shows 'MCP platform and adapter versions', with a specific verb 'Show' and resource, distinguishing it from sibling tools like 'toolkit_info'.

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

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

Usage is self-evident for a version display tool; no alternatives or exclusions needed, though explicit guidance is minimal.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds value by detailing the exact information returned (installed MCPs, statuses, accounts, tool counts), which goes beyond the annotations and helps the agent predict the output.

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 main verb and resource, then lists the key components. Every part earns its place with no redundant language.

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 no-parameter info tool with no output schema, the description clearly enumerates the types of data returned (MCPs, status, accounts, tool counts), which gives the agent a solid expectation. It could add more detail about the return format or edge cases, but the current level is sufficient for the tool's 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 zero parameters, and schema coverage is 100% (trivially). The description doesn't need to explain parameters, and with no params to clarify, a baseline of 4 is appropriate.

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

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

The description uses a specific verb 'Returns' and clearly identifies the resource as 'the current toolkit state'. It enumerates the exact contents (installed MCPs, connection status, accounts, catalog tool counts), which distinguishes it from sibling tools that perform actions or retrieve domain-specific data.

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

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

The description implies this is the go-to tool for a system-level overview of MCPs and connections, providing clear context. It doesn't explicitly state when not to use it or name alternatives, but the sibling list shows other tools are specialized for finance operations, making the usage context clear enough.

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