Monte Bravo MCP

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

Annotations (idempotentHint=true) are consistent. Description adds context about permanent vs session login and that calling without args returns a link. 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?

Three sentences, front-loaded with purpose. Slightly dense but no wasted words. Could benefit from clearer structure (e.g., bullet points) but remains 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?

Lacks output schema and description of return value (e.g., success/error). For a simple auth tool, it's adequate but incomplete regarding behavior after calling.

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 compensates fully by explaining the token parameter is a JWT and how to pass it (with or without args).

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

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

The description clearly states the tool's purpose (authentication) and distinguishes it from siblings like 'connect' and 'marketplace' by specifying two authentication methods: permanent via config or session-only via token argument.

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 how to obtain the access token (log in, copy), best practice (add to config), and alternative (paste token) with calling conventions. Lacks explicit when-not-to-use, 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 declare readOnlyHint=true and destructiveHint=false. The description adds useful context about the output fields (authenticated, pending, connect_url) and behavior under different conditions, which is 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?

Two sentences, highly concise, no redundancy. Every word provides 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?

For a zero-parameter read-only status tool, the description fully explains the output with examples, compensating for lack of output schema.

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

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

No parameters exist, so the description adds no param info, but schema coverage is 100% (none to cover). Baseline for 0 parameters is 4.

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

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

The description clearly states the tool returns connection status and URLs, and explains the response content for different states (all providers connected vs. missing credentials). This distinguishes it from siblings like authenticate or marketplace.

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

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

The description implies use for checking connection status. While it doesn't explicitly mention when not to use or provide alternatives, the context (siblings like authenticate) makes it clear enough.

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 many behaviors beyond annotations: invoke works even if MCP not installed, returns connect or checkout links, install makes permanent, actions require ownership, etc. Annotations are consistent (readOnlyHint=false, destructiveHint=false). No contradictions, and the description adds rich behavioral context.

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

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

The description is long but dense and front-loaded with the core purpose. Every sentence adds value. It could benefit from more structure (e.g., bullet points), but for the complexity, it is appropriately sized 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?

Given the complexity (13 params, multiple actions, no output schema), the description is thorough. It explains the core flow, edge cases (credentials, wallet), distinctions between similar actions, and mentions installed_in_toolkit vs installed_in_workspace. It provides complete guidance for an agent to use 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?

Although schema description coverage is 0%, the description compensates by explaining the core flow and how key parameters (action, query, mcp_id, tool_id, arguments) are used. It doesn't detail every parameter (e.g., limit, message, immediate, tier_slug, conversation, request_name), but the overall guidance adds significant meaning, reducing reliance on the raw schema.

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

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

The description clearly states it is the official mcp.ai marketplace, for discovering and running MCPs/tools. It specifies actions like search, describe, invoke, install, etc., and distinguishes itself from external registries, providing a specific verb-resource combination.

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 instructs to use this tool first before any external registry for finding capabilities. It gives detailed guidance on when to use invoke vs install, how to handle credentials and wallet issues, and separates list_tools, subscribe/cancel, report_bug, request_mcp, providing clear when-to-use and when-not-to-use criteria.

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 set destructiveHint=true, and the description adds context: it revokes consent, deletes data, and returns a reconnect URL. No contradiction. However, it does not detail authorization needs or whether the action can be undone beyond reconnecting.

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 superfluous words. Front-loads the main action and consequences, then mentions the return value. Extremely 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 destructive tool with one parameter, the description covers the effect, result, and return value. Missing parameter guidance and error scenarios, but overall adequate given 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 schema has 0% description coverage for the parameter 'item'. The description says 'specific bank' but does not explain what format the 'item' takes or how to obtain it (e.g., from list_connections). This leaves the agent guessing.

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 for a specific bank, making the data unavailable. It distinguishes from sibling tools (no other disconnect tool exists) and includes a return value.

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 use when disconnecting a bank, but lacks explicit guidance on when to use this versus alternatives (e.g., pausing) or prerequisites (e.g., must have an active connection). No mention of related sibling tools like 'connect' for reconnection.

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

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

Discloses that it waits up to ~60s, may return 'needs_action' or 'timed_out', and pulls fresh data without disconnecting. All behavioral traits beyond annotations are covered, and there is 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 front-loaded with action and key behavior. Every sentence adds value; however, it is somewhat lengthy, preventing a perfect score.

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 structure ({results, errors}) and key fields. It covers all necessary context for an agent to invoke the tool correctly, including edge cases and alternatives.

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

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

Despite 0% schema description coverage, the description fully explains the `items` parameter (array of selectors, omit to sync all) and the `wait` parameter (true by default, false for fire-and-forget). This adds complete meaning beyond the schema.

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

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

The description clearly states it forces a re-sync and waits for completion, with a specific verb 'forces' and resource 'connections'. It distinguishes from sibling tools like openfinance_get_item_status by mentioning it as a fallback for timed-out cases.

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

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

Provides explicit when-to-use context (stale balance/transactions), when-not-to-use (needs_action means reconnect, timed_out means re-check), and alternatives (openfinance_get_item_status). Also explains 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 the tool as read-only, idempotent, and non-destructive. The description adds significant behavioral details: it is a GET request, the account_ids array constraint (1-50), the specific error behavior for credit accounts (structured warning instead of throwing), and the response shape (results/errors structure). 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 concise, using only four sentences to convey the core action, parameter constraint, error behavior, and response structure. It is front-loaded with the main purpose and efficiently covers necessary details without waste.

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

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

Given a single parameter and no output schema, the description adequately covers the input constraint, error handling, and response shape. It is mostly complete for a simple balance fetch tool, though it could mention authentication prerequisites or rate limits. The presence of annotations reduces the need for additional context.

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

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

With 0% schema description coverage, the description adds the format (array) and range (1-50) for the single parameter account_ids, which provides basic meaning beyond the schema. However, it does not explain what constitutes an account ID or provide further semantic nuance.

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

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

The description clearly states it returns real-time balance per account ID, referencing the specific endpoint (GET /accounts/:id/balance). It specifies the resource (balance) and distinguishes from sibling tools like openfinance_list_accounts which lists accounts rather than fetching balances.

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 handling of CREDIT accounts that may return a Pluggy error with a warning, providing usage context. However, it does not explicitly guide when to use this tool vs alternatives like openfinance_get_accounts_detail or others, nor does it state 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 indicate readOnlyHint and idempotentHint, and the description adds that it returns extended creditData and the results/errors batch structure. This complements the annotations without contradiction.

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

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

Three sentences, each adding value: purpose, input constraints, and output shape. 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 covers the return format and key details. It is complete for a low-complexity 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?

With 0% schema description coverage, the description fully explains the only parameter account_ids: it's an array of strings with a batch size limit (1-50). This adds essential meaning beyond the schema.

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

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

The description clearly states it returns full account objects with extended creditData per ID, and mentions the batch processing behavior. It distinguishes itself from sibling tools like openfinance_list_accounts which likely return a summary list.

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

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

It specifies the input format (array of 1-50 account_ids) and the batch shape. It could explicitly mention when to use this tool over alternatives, but the guidance is clear and helpful.

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 and idempotent. Description adds critical behavioral context: Pluggy does not return paid/status, explains the billing cycle meaning of payments[], and warns against assuming payment status from this tool. 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?

Well-structured with clear sections, but slightly verbose. Could be trimmed without losing clarity, but it remains effective and front-loaded.

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

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

Despite no output schema, description fully explains return shape ({ results, errors }) and field details. Also covers relationships with other tools and billing cycle context. Complete for a tool with one parameter.

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

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

Schema has 0% description coverage; the description compensates by explaining that bill_ids is an array and that ids come from openfinance_list_credit_card_bills. Adds clear usage instruction for the only parameter.

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

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

The description clearly states it returns bill-level detail by id, specifying fields like financeCharges and payments. It also explicitly says what it does NOT do (return individual transactions), which distinguishes it from sibling tools.

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

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

Provides explicit guidance: use openfinance_list_transactions for itemized transactions, use openfinance_list_credit_card_bills first to discover bill ids, and clarifies the meaning of payments[] and how to check paid status.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds value by detailing the returned data (statuses, executionStatus, connector metadata) and the two operational modes. It does not contradict annotations and provides useful behavioral context beyond the structured fields.

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

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

The description is concise, consisting of two well-structured sentences. It front-loads the main purpose and immediately provides actionable usage variants without 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?

Given no output schema, the description outlines the return structure for the all-case (`{ count, items }`) and mentions executionStatus and metadata. For a simple tool with one parameter, this is mostly adequate, but the return format for a single bank is not explicitly 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?

The schema has 0% coverage for the single optional parameter 'item'. The description explains its effect (omit for all, pass for single) and the return format for the all case. However, it does not specify what type of identifier 'item' expects (e.g., bank ID or connection ID), leaving ambiguity. The description partially compensates for the lack of schema 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 the status of a bank connection with specific statuses (UPDATED, UPDATING, LOGIN_ERROR, etc.), executionStatus, and connector metadata. It also distinguishes between querying all connections and a single one, differentiating it from sibling tools like openfinance_list_connections.

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

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

The description explicitly provides usage guidance: omit `item` for all banks or pass `item` for a single bank. However, it does not mention when not to use this tool or explicitly contrast with alternatives like openfinance_list_connections, though 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?

Beyond annotations (readOnlyHint, idempotentHint, destructiveHint), the description discloses critical behavioral traits: the connector-dependent meaning of CREDIT balance, the distinction between account 'name' and 'bank' brand, and the role of creditData fields (balanceCloseDate, balanceDueDate). This prevents misinterpretation of the balance field for credit cards.

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 and front-loaded with the core purpose. While it is lengthy, every sentence adds value—covering return fields, usage patterns, caveats, and cross-references. It could be slightly more concise by grouping related details, but the structure is logical and readable.

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, 0% schema coverage, and a complex domain (banking accounts with different types), the description is remarkably complete. It explains all key return fields (balance, bank, connector_id, creditData), distinguishes between account types, warns about balance interpretation, and points to the appropriate sibling tool for credit card bills. No missing context for effective tool selection.

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 well by explaining both parameters: 'item' (optional, for single bank targeting) and 'type' (implicitly filtered by account type, though not explicitly stated as a filter). It adds context that omitting 'item' aggregates across connections. However, it does not explicitly state that passing 'type' restricts results to that account type, which is a minor omission given the enum.

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

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

The description clearly states the tool returns accounts for a bank connection with detailed fields (balance, number, type, subtype, bankData, creditData). It distinguishes between BANK and CREDIT account types and explains the difference between account 'name' (legal entity) and 'bank' (brand). It also differentiates behavior when 'item' is omitted vs provided, setting it apart from sibling tools like openfinance_list_credit_card_bills.

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

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

Explicitly explains when to omit 'item' (list across all linked banks) vs pass 'item' (target a single bank). It provides an example usage: 'use this when the user asks for my accounts/cards without naming a bank'. It also directs users to openfinance_list_credit_card_bills for standardized open-bill and total debt amounts, clarifying when this tool is insufficient.

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, not destructive. The description adds valuable context: caching behavior, the exact fields returned (id, description, descriptionTranslated, parentId, parentDescription), and that it's a single aggregated response. 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 two sentences, no wasted words. It starts with the primary purpose and then adds necessary details about caching and output 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?

Given no output schema, the description thoroughly explains the return fields and their meanings (including Portuguese for pt-BR users). It also notes caching and the single-response nature. Complete for this 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?

No parameters exist, so schema coverage is 100%. The description provides meaning about the output fields, which compensates for the lack of parameters. It adds value beyond the schema by explaining the returned fields and their use.

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

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

The description clearly states the tool returns Pluggy's transaction category taxonomy, specifies the API endpoint (GET /categories), and mentions caching. It distinguishes itself from sibling tools that deal with transactions, accounts, etc.

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

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

The description explains it is cached for the session and returns a single aggregated response with no batch ids. While it doesn't explicitly say when to use vs alternatives, the context of siblings makes it clear. Lacks explicit when-not-to-use guidance.

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

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

Annotations already provide readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds no behavioral traits beyond stating it 'returns' data, which is already implied. No extra context about side effects, prerequisites, or limits.

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

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

A single clear sentence with no wasted words. Information is front-loaded and easy to parse.

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 provides adequate return field coverage. However, it lacks details on pagination, error handling, or edge cases. Still, for a simple list tool with no parameters, the description is nearly complete.

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

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

No parameters exist (schema coverage 100%). Baseline for 0 params is 4. Description adds no parameter info but correctly implies the tool has no inputs.

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 saved bank connections and lists the exact fields (connector_id, item_id, bank name, add_connection_url). It distinguishes itself from siblings like openfinance_list_accounts and openfinance_list_transactions by focusing solely on 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?

No guidance on when to use this tool versus alternatives (e.g., openfinance_list_accounts, openfinance_get_item_status). The description only states what it returns, not the best context for invocation.

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

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

Annotations already indicate readOnlyHint and idempotentHint. Description adds rich behavioral details: payment cycle logic, derived payment_status calculation, connector asymmetry for open bills, and the meaning of total_pending_debt. 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?

Description is lengthy and contains repetitive explanations (e.g., the payment_status logic is explained twice). While well-structured with sections, it could be more concise. Some sentences could be merged or simplified without losing 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?

Highly complete given the tool's complexity. Covers main returns, derived fields, payment status derivation, open bill option with connector asymmetry, and how to find associated transactions. No output schema, so description provides all necessary context for 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?

Schema description coverage is 0%, so description must compensate. It thoroughly explains include_open_bill and mentions account_ids for bulk support. However, page and page_size parameters are not explained, and account_id is only implied. At least provides meaning for 3 of 5 params.

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

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

Description clearly states it returns closed credit card bills for a CREDIT-type account, specifying the fields. It distinguishes itself from sibling tools like openfinance_get_credit_card_bill and openfinance_list_transactions, making the tool's 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?

Provides explicit guidance: tells when to use this tool for bill-level summaries vs. openfinance_list_transactions for itemized purchases. Explains opt-in for open_bill and why it's opt-in. Also warns about the payment array semantics, guiding correct interpretation.

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 readOnlyHint, idempotentHint, and destructiveHint, which are consistent. The description adds value by detailing the error handling behavior ('Returns {total, results, warning} instead of throwing when INVESTMENTS isn't enabled (403) or other upstream errors'), which goes beyond annotations.

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

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

The description is well-structured, starting with the main purpose, then listing asset types and key fields, and ending with error handling. It is informative without excessive verbosity, though could be slightly shorter.

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

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

The tool has no output schema, but the description covers the return format and error behavior. However, it lacks guidance on parameter usage, leaving a gap in contextual completeness for a tool with four optional parameters.

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 the description does not explain any of the four parameters (item, page, type, page_size). The agent must infer from the schema, which only provides the enum for 'type'. This is insufficient 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 states 'Returns the investment portfolio for a connection' with a specific list of asset types (FIIs, stocks, ETFs, etc.), clearly defining what the tool does and distinguishing it from siblings like openfinance_list_accounts or openfinance_get_account_balance.

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 retrieving investment data from a connection, but does not explicitly state when to use this tool versus alternatives like openfinance_list_investment_transactions or openfinance_list_accounts, nor does it mention 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 and idempotentHint=true, confirming safe read-only behavior. The description adds significant detail on return structure (fields, expenses breakdown) and transaction types, complementing the annotations without contradiction.

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

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

The description is brief (two paragraphs) and front-loaded with key information. No redundant sentences, but could be slightly more structured (e.g., separate sections for parameters and output).

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 output fields, transaction types, and usage sequencing well. Missing details on pagination behavior (page/page_size) prevent a perfect score.

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 explains investment_id (prerequisite) and investment_ids (bulk support), but does not mention page and page_size parameters. With 0% schema description coverage, these omissions leave ambiguity for pagination usage.

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

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

The description clearly states that the tool returns movement history for investment positions, listing specific transaction types (BUY, SELL, TAX, etc.) and output fields. It distinguishes itself from sibling tools like openfinance_list_investments, which lists investments rather than transactions.

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

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

Explicitly instructs to use after openfinance_list_investments to get investment_id, and mentions bulk support for batched execution. However, does not specify when to use page/page_size parameters or 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?

Adds behavioral context beyond annotations: sequential querying with rate-limit spacing, return format '{ results, errors }' per connection. Annotations already indicate read-only and idempotent, but description enriches understanding with 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, each earning its place. First sentence states purpose and endpoint. Second explains parameter usage and behavior. No fluff, 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?

Covers parameter semantics and return format partially. For a list tool with no output schema, it explains the overall result structure. Could mention that results are per-connection, but sibling patterns may clarify. Still adequate for the complexity.

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

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

Schema only declares 'items' as array of strings (0% coverage). Description compensates fully by explaining they are connection selectors (item_id uuid, connector_id, or connector_name) and how omitting changes behavior. Provides crucial context missing from 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 lists loan contracts per bank connection via GET /loans. The verb 'lists' and resource 'loan contracts' are specific, and the description distinguishes it from sibling list tools by specifying 'per bank connection'.

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

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

Provides clear when-to-use guidance: pass 'items' to filter specific connections, omit for all banks. Mentions sequential querying with rate-limit spacing. Lacks explicit when-not-to-use or alternative tool references, 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?

Adds substantial behavioral context beyond annotations: upstream error handling (returns error/warning instead of throwing), auto-pagination up to 5000 with truncation warning, search_queries OR semantics, and varying behavior by bank for CREDIT pending/posted. All while annotations already declare readOnlyHint=true, idempotentHint=true, and 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?

While lengthy (multiple paragraphs), each sentence earns its place given the tool's complexity. Well-structured: starts with purpose, then CREDIT-specific details, parameter explanations, pagination, error handling, and sibling references. Could be slightly more concise but justified.

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 8 parameters, 1 required, no output schema, the description is remarkably complete. Covers edge cases (truncation, upstream errors, different detail levels, bulk, connection health check). References sibling tools for related functionality. No gaps identified.

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

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

Schema has 0% description coverage, but the description thoroughly explains all parameters: account_id required, to/from (ISO YYYY-MM-DD), page (omit for auto, explicit for manual with page_size max 500), detail enum (compact/rich/raw with coverage notes), search_queries (array, case/accent-insensitive substring OR match, 5000 limit), and account_ids for bulk. Adds critical meaning absent from schema.

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

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

The description clearly states it returns transactions for BANK or CREDIT accounts, explicitly differentiating from sibling tools like openfinance_list_credit_card_bills (for bill summaries) and openfinance_list_transactions_by_item. It specifies the resource (transactions) and action (list), with scope (by account_id).

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

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

Provides explicit when-to-use guidance: for CREDIT accounts, this is the only way to get itemized transactions; for bill totals, use openfinance_list_credit_card_bills. Also advises using openfinance_list_accounts for closing/due dates and openfinance_get_item_status if total is 0. Pagination mode (auto vs manual) is explained with conditions.

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

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

Beyond annotations (readOnlyHint, idempotentHint, destructiveHint), the description explains default granularity returns compact summary, the structure of output, truncation at 5000/account with a flag, and the effect of detail levels (rich/raw). No contradiction with annotations.

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

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

The description is a single paragraph that front-loads the main purpose. It is slightly long but well-structured, covering purpose, parameters, use cases, and behavior. Minor redundancy (e.g., Portuguese terms) 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 the complexity (7 parameters, no output schema, 0% schema coverage), the description is extremely complete: it covers all parameters, output structure, truncation, and use cases. It fully compensates for missing metadata.

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

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

Despite 0% schema description coverage, the tool description fully explains all parameters: item (connector_id/name or item_id), from/to (ISO dates), granularity (monthly/raw), detail (compact/rich/raw), type (BANK/CREDIT), and top_n (via top_despesas/recebimentos).

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

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

The description clearly states the tool's purpose: 'Consolidated cash-flow analysis for a whole bank CONNECTION over a period, in ONE call.' It specifies the verb (analyze), resource (transactions by connection), and distinguishes from siblings by emphasizing it resolves accounts internally and provides aggregated summaries.

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 lists use cases: 'Use this for 'análise anual/mensal', 'fluxo de caixa', 'entradas e saídas', 'maiores gastos/recebimentos'. It also explains when not to use raw granularity unless needed, and notes that omitting the item parameter analyzes 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 declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds that it checks a public status page, returns specific fields, and flags incidents affecting your banks—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?

Efficient and well-structured: first sentence states purpose, then usage guidance, then return details. No waste.

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

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

Despite no output schema, the description fully explains return values and usage context, making it complete for a simple status check tool.

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

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

No parameters, schema coverage 100%. Baseline 3 per guidelines; description adds no parameter info but none is 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 it checks the LIVE operational status of the Open Finance provider, distinguishes from sibling tool 'openfinance_get_item_status', and lists what it returns (global indicator, degraded components, incidents, affected banks).

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

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

Explicitly states when to use: 'whenever data looks incomplete or stale even though a connection shows UPDATED' and explains it differentiates upstream outages from connection issues.

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: caveat warnings on credential connectors, plan-based filtering, and return of a pre-selected connect_url. Annotations already indicate read-only, idempotent, non-destructive, so no contradiction.

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

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

Description is well-structured with front-loaded action and detailed return information. Slightly long but every sentence adds value; could be tightened but not at expense of 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?

Given no output schema, description covers return fields, caveat, and plan filtering. Lacks explicit error handling or no-results behavior, but for a search tool this is acceptable.

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

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

With 0% schema coverage, description effectively explains both parameters: keywords (array of strings, required) and include_accounts (boolean). Provides example usage but no formal constraints beyond examples.

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 searches bank connectors by name (keywords) and lists return fields. It emphasizes it should be called before connecting, distinguishing it from other tools that perform actions like connect or 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?

Explicitly states when to use (before connecting) and that keywords are required; mentions plan filtering. However, it does not explicitly compare to sibling search-like tools (e.g., marketplace) or state 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?

The description reveals significant behavioral traits beyond annotations: it overrides automatic categorization, creates a Category Rule that affects future transactions, and details batch error handling. Annotations are consistent (readOnlyHint=false) and the description adds 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 a single dense paragraph covering purpose, usage, side effects, and return shape. It is front-loaded with the main action but could benefit from slight restructuring (e.g., separate sentences for batch behavior).

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

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

Without an output schema, the description fully explains the return shape and per-item error behavior. It also covers the teaching side effect and provides sufficient context for a mutation tool with moderate 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?

Despite 0% schema description coverage, the description explains the structure of `items` as an array of { transaction_id, category_id } and tells where to obtain each ID (openfinance_list_transactions and openfinance_list_categories), adding crucial context beyond the schema.

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

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

The description starts with 'Corrects the category of one or more transactions', clearly stating the action ('Corrects') and resource ('category of transactions'). It distinguishes from sibling tools like list_transactions and list_categories by describing the update operation and its side effect of creating Category Rules.

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

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

The description explicitly states the use case: 'use this to fix miscategorized transactions and improve categorization accuracy'. It references sibling tools for obtaining required IDs but does not 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 indicate idempotentHint=true and destructiveHint=false, and the description confirms it's a non-destructive reporting action. No contradictions, but the description adds little beyond what annotations already 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?

Two sentences, straight to the point, no unnecessary words. High information density.

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 reporting tool with no output schema, the description covers the essential purpose and key input. However, it lacks details on outcomes or response format, but this is acceptable given 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?

Schema description coverage is 0%, and the description only mentions the conversation parameter briefly. The other parameters (context, message) are not explained beyond their names, which is insufficient for an agent to understand nuances.

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 reports bugs, missing features, or feedback, which is specific and distinct from sibling tools that are mostly related to OpenFinance 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?

It advises including the conversation array for reproduction, providing clear usage context. However, it does not explicitly state when not to use it or mention alternatives, but given the niche purpose, this is minor.

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, meaning the tool is safe and idempotent. The description adds minimal behavioral context beyond confirming it shows versions, so it meets the baseline but does not exceed.

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 of 11 words, front-loaded and efficient. Every word 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 has no parameters, no output schema, and a straightforward purpose, the description is fully complete. An agent can understand exactly what to expect.

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, and schema coverage is 100%. Per rubric, 0 parameters gives a baseline of 4. The description does not need to add parameter 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 the tool shows 'the current MCP platform and adapter versions,' using a specific verb and resource. It is unambiguous and distinguishes itself from sibling tools like authenticate or openfinance tools.

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

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

The description does not provide explicit guidance on when to use this tool versus alternatives. While the simple purpose makes it obvious, it lacks when-not or alternative recommendations, which is a minor gap.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds value by specifying the exact content returned (installed MCPs, connection status, catalog tools). This goes beyond the safety profile provided by 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?

A single sentence that is front-loaded with the action ('Returns the current toolkit state') and provides specific details. Every part of the sentence earns its place with no waste.

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

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

Given no output schema and no parameters, the description provides a general but sufficient overview. It could list the specific fields returned for greater completeness, but the current description adequately sets expectations.

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 and schema_description_coverage is 100% (vacuously). The description does not need to add parameter information. Baseline for no parameters is 4.

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

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

The description clearly states the tool returns toolkit state including installed MCPs, connection status, and catalog tool counts. This is a specific verb+resource that distinguishes it from sibling tools which are mostly Open Finance operations 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?

The description implies use for checking state but provides no explicit when-to-use or when-not-to-use guidance. No alternatives are mentioned. Usage context is generally understandable but not formally stated.

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