Safra MCP

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

Discloses that calling with a token grants session-only access, while adding token to config yields permanent connection. This adds context beyond the idempotentHint annotation, though it doesn't detail failure modes or side effects.

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 cover the entire functionality, audience, authentication methods, and invocation. No wasted words; efficient and front-loaded.

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

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

The description is fairly complete for an authentication tool without an output schema. It explains both modes and how to call. It could mention what the returned link looks like, but that's minor.

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 single optional parameter 'token' is fully explained: it's the JWT token to paste for session login, and omitting it returns a login link. This compensates for the 0% schema coverage.

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

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

The description clearly states the tool is for authentication of IDE agents like Cursor. It specifies two distinct methods (permanent config vs session-only) and distinguishes itself from sibling tools like 'connect' by focusing on token-based login.

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

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

Provides explicit guidance on when to use the config approach versus pasting a token, and how to invoke the tool with or without arguments. It lacks a direct comparison to siblings but gives clear usage scenarios.

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

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

Annotations already indicate readOnlyHint and idempotentHint. The description adds specific behavior for two scenarios (all connected vs missing credentials), 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?

Two sentences, front-loaded with main purpose, no redundant information. Every sentence adds value.

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

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

Given no parameters or output schema, the description covers the essential behavior for the two primary states, making it complete for this simple 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 exist, and schema coverage is 100%. Baseline score of 4 applies as per guidelines.

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, distinguishing it from sibling tools like 'authenticate' which performs authentication. Specific verbs and resource names are used.

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, but lacks explicit when-not-to-use or alternatives. However, for a simple parameterless tool, the context is 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?

Annotations already indicate readOnlyHint=false, but the description adds significant behavioral context beyond that: invoke works even when MCP is not installed, returns connect links for credentials or checkout links for payment, install makes permanent, etc. It also details the side effects of each action. 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 relatively long but efficient; each sentence adds value explaining the workflow and key distinctions. It is front-loaded with the core purpose and then expands on details. While it could be more structured (e.g., bullet points), it is not overly verbose.

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

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

Given the complexity (13 parameters, no output schema, annotations present), the description covers the overall system, each action's role, and key behavioral traits. It lacks explicit parameter documentation but provides enough context for an agent to use the tool effectively. Sibling tools are all different, so no confusion.

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, so the description must compensate. It provides general context for parameters like query, action, mcp_id, tool_id, arguments, etc. through the narrative flow, but does not explicitly describe each parameter's format or constraints. This is adequate but not fully compensating for the coverage gap; more explicit parameter documentation would be beneficial.

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 this is the official marketplace catalog and runtime for MCPs/tools. It explains the core flow of search, describe, and invoke, distinguishing between one-off and permanent usage, and lists other actions. The purpose is specific and well-defined.

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: use this tool FIRST before external registries, use search to discover, use invoke for one-off runs, use install only for permanent inclusion, and mentions when to use other actions like subscribe/cancel. It also notes that writes require workspace owner/admin, giving clear context for when to use 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?

The description discloses the destructive nature (revoking consent, deleting data) and the return of a reconnect URL. The annotations already mark destructiveHint=true, so the description adds value by detailing what is destroyed and what is returned.

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 and front-loaded with the main action. However, it lacks parameter guidance which would make it more efficient. It earns its place but could be more compact.

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

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

The description covers the primary effect and return value, which is good given no output schema. However, the missing parameter explanation is a significant gap, making it incomplete for a tool with one required 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?

The parameter 'item' is not explained in the description. With 0% schema coverage, the agent must guess that 'item' identifies the bank. No examples, format, or mapping from 'specific bank' to the parameter is provided.

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, deletes connection data, and makes bank data unavailable. It distinguishes from sibling tools like openfinance_list_connections and openfinance_get_item_status.

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

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

The description explains the tool is for disconnecting a bank and notes that it returns a reconnect URL. It implicitly tells when to use it, but lacks explicit when-not-to-use or alternative guidance, though sibling context makes it clear this is the only disconnect 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 readOnlyHint=false and destructiveHint=false. The description adds rich behavioral context: it details the waiting mechanism (up to 60s), polling behavior, return fields (status, executionStatus, lastUpdatedAt, synced), timeout indication, and needs_action scenarios (e.g., LOGIN_ERROR). This goes far 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 dense but not excessively long. It opens with the primary action and key constraint (waits for finish). It then covers usage, parameters, return values, and edge cases in a logical order. A minor tightening could reduce length, but it remains efficient.

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

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

Given the tool has 2 parameters, no output schema, and many sibling tools, the description is remarkably comprehensive. It explains the return object (results, errors), each field's meaning, timeout behavior, how to retry with openfinance_get_item_status, and the fire-and-forget alternative. All critical information is present.

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

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

Schema coverage is 0%, so description carries full burden. It explains both parameters: 'items' as an array of selectors (item_id, connector_id, or connector_name) with the option to omit for all banks, and 'wait' as a boolean for synchronous vs fire-and-forget mode. This is precise 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 forces a bank to re-sync connections and waits for it to finish. It specifies that it pulls fresh data without disconnecting/reconnecting, distinguishing it from sibling tools like openfinance_disconnect_bank. The verb 'force sync' and resource 'bank connections' 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 provides explicit usage context: 'Use this when a balance or transaction list looks stale' and describes how to target specific items or sync all. It also explains the fire-and-forget option via wait=false. Although it doesn't list exhaustive alternatives, the guidance is clear and practical.

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

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

Annotations already indicate read-only and idempotent behavior; description adds value by detailing how credit account errors are handled (non-throwing warning) and the exact response shape.

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

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

Two sentences, no fluff. The first sentence captures the core purpose, and the second adds error handling and response shape. Every sentence earned its place.

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

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

Given no output schema, the description provides the response shape. It covers key aspects (real-time, array input, error handling) but omits prerequisites like authentication. Adequate 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?

With 0% schema description coverage, the description adds crucial size constraint (1-50) and links the parameter to account IDs, but doesn't explain where to obtain those IDs. This suffices for the simple single-parameter case.

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, specifies the HTTP method and endpoint, and distinguishes from siblings like list and detail tools by focusing on 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 provides clear guidance on how to use the tool (pass account_ids array of 1-50) and handling of credit account errors, but lacks explicit differentiation from siblings.

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

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

Annotations confirm readOnlyHint and idempotentHint. Description adds behavioral details: batch processing with results/errors, array size limit, and inclusion of extended creditData. 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: first states purpose and return content, second gives usage instruction and output shape. No extraneous text, front-loaded with key information.

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

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

For a simple read-only detail tool with one parameter and no output schema, description covers purpose, input constraints, and output shape ({ results, errors }). Sufficient for agent invocation.

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

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

Schema has 0% description coverage and only lists type. Description compensates by specifying array constraint (1–50) and implying required status, adding critical meaning beyond schema.

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

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

Description clearly states 'Returns full account objects including extended creditData per id', specifying verb, resource, and extra details. Distinguishes from sibling openfinance_list_accounts by emphasizing detail retrieval for specific IDs.

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 constraint 'Pass account_ids as an array (1–50)' and notes batch shape, but does not explicitly state when to use this tool vs. alternative openfinance_list_accounts.

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

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

Annotations already declare readOnlyHint and idempotentHint. Description adds key behavioral details: batch shape {results, errors}, payments[] reflects payments during this bill's cycle (not necessarily this bill paid), and the caveat about Pluggy not returning a paid/status field. 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?

Relatively long but well-structured with key information front-loaded. Every sentence adds value, covering purpose, usage, and caveats. Minor redundancy could be trimmed but overall 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?

Comprehensive for a tool without output schema: explains return shape, nuances of payment interpretation, and cross-references sibling tools for additional functionality. Addresses likely user questions about paid status and batch behavior.

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?

Single parameter bill_ids with 0% schema description coverage. Description explains it is an array of IDs and recommends using the sibling tool to discover them. Provides usage guidance but lacks explicit format example or constraints 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 specifies it returns 'bill-level detail for one or more credit card bills by id' and lists included fields (financeCharges, payments). It clearly distinguishes from listing individual transactions via openfinance_list_transactions, which is a sibling tool.

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

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

Explicitly advises to use openfinance_list_credit_card_bills first to discover ids, and to use openfinance_list_transactions for itemized transactions. Also warns that payments[] may not indicate paid status and suggests checking via the sibling 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?

No contradiction with annotations (readOnlyHint, idempotentHint, destructiveHint). Description adds context about response structure (count, items vs single) and the nature of the operation (read-only status retrieval). Does not delve into details of executionStatus or connector metadata, but annotations already cover safety.

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 fluff, front-loaded with the core purpose. Every sentence adds value. Optimal length.

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

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

For a simple tool with one optional parameter and no output schema, the description covers the essential functionality and usage scenarios. Could mention that status values include UPDATED, UPDATING, LOGIN_ERROR (already partly listed). Complete enough 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?

Only one parameter (`item`) with 0% schema description coverage. Description fully compensates by explaining the semantic difference: omitting returns all banks with `{ count, items }` structure, passing returns single bank. This adds significant value 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?

Description clearly states it returns the current status of a bank connection, lists example status values, and distinguishes between two modes (all banks vs. single bank). Differentiates 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?

Provides explicit guidance on when to omit or pass the `item` parameter for different use cases. Does not explicitly mention when not to use or list alternatives, but the context is clear and 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?

Beyond annotations (readOnlyHint, idempotentHint, destructiveHint), the description discloses critical behavioral traits: the connector-dependent meaning of CREDIT balance, the distinction between 'name' (legal entity) and 'bank' (brand), and the purpose of creditData fields. 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 somewhat long but every sentence adds value. It is well-structured with clear sections for purpose, usage, warnings, and cross-references. A slight reduction in verbosity could improve conciseness, but it remains highly effective.

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

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

Given the absence of an output schema and the parameter schema having 0% coverage, the description thoroughly covers all needed context: parameter usage, output fields, behavioral caveats, and relationships to sibling tools. It leaves no gaps for the agent to interpret ambiguously.

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 provides no descriptions for the two parameters ('item' and 'type'). The description compensates fully by explaining that omitting 'item' aggregates across all banks while passing it targets a single bank, and that 'type' filters between BANK and CREDIT. 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 that the tool returns accounts for a bank connection, distinguishing between BANK and CREDIT types, and explains the output fields. It differentiates from sibling tools like openfinance_list_credit_card_bills and openfinance_get_account_balance by specifying unique capabilities such as listing across all banks or targeting a single bank.

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 omit the 'item' parameter (to list across all linked banks) versus passing it (to target a single bank). It warns against treating CREDIT balance as the current month's bill and recommends openfinance_list_credit_card_bills for standardized bill amounts. This covers when-to-use, when-not-to-use, and 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?

Adds caching behavior and response format details (single aggregated response) beyond readOnlyHint annotation. No contradictions.

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

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

Two concise sentences front-loading the purpose and then detailing response structure. No wasted words.

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

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

For a zero-parameter read-only tool, description provides adequate detail on caching, response fields, and links to related tool. No gaps.

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

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

No parameters, so schema covers fully. Description adds meaning by explaining output fields (id, description, parentId, etc.), compensating for lack of output schema.

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

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

Clearly states it returns Pluggy's transaction category taxonomy, a specific resource. Distinguishes from siblings like openfinance_list_transactions by being the only category listing tool.

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

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

Explains that id is used by openfinance_update_transaction_category, implying usage context. No explicit when-not or alternatives, but clear enough for an 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 declare readOnlyHint and idempotentHint. The description adds value by specifying the returned fields and the add_connection_url for linking additional banks, which is behavioral context beyond the annotations.

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

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

The description is a single, focused sentence that immediately conveys the tool's purpose and key outputs. No unnecessary words.

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

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

For a simple list tool with no parameters and a constant output structure, the description fully covers the return fields. No output schema exists, but the description compensates adequately.

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 coverage is 100%. The description does not need to explain parameters, and the baseline score of 4 is appropriate.

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

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

The description clearly states the tool returns saved bank connections and lists specific fields (connector_id, item_id, bank name, add_connection_url). It differentiates from sibling tools by focusing on bank connections rather than accounts or transactions.

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

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

No guidance on when to use this tool versus alternatives. The description implies it's for retrieving stored connections, but does not mention context like initial setup or reconnection scenarios.

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

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

Annotations already indicate read-only, idempotent. The description adds deep behavioral context: payment landing logic, derived payment_status, connector asymmetry for open_bill, and caution about PAST_DUE_UNCONFIRMED. No contradiction with annotations.

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

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

Description is very long and dense. While well-structured with sections, it sacrifices conciseness for completeness. Could be trimmed without losing essential guidance.

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 high complexity, coverage is strong: output fields, payment semantics, cross-bill matching, open bill derivation, connector asymmetry, and error warning. Missing details on pagination and bulk behavior are minor gaps.

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

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

With 0% schema coverage, description compensates well for include_open_bill (detailed) and account_ids (mentioned), but does not explain page, page_size, or pagination behavior. Bulk support is mentioned but lacks specifics on limits or result 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 'Returns CLOSED credit card bills for a CREDIT-type account' and lists specific fields. It distinguishes from siblings like openfinance_get_credit_card_bill and openfinance_list_transactions by explaining scope and relationships.

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 use this tool, when not to assume paid status from payments[], and directs to openfinance_list_transactions for itemized purchases. Also covers opt-in for open_bill and warns about connector asymmetry.

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 context: it gracefully handles 'INVESTMENTS not enabled' errors (403) by returning a {total:0, results:[], warning} structure instead of throwing, and mentions it handles other upstream errors similarly.

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 without unnecessary words. It could be slightly improved by separating the error-handling into a distinct sentence, but overall it is efficient and front-loads the main purpose.

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

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

Given no output schema, the description provides return structure (total, results, warning) and lists many returned fields like balance, amount, dueDate, etc. It covers error behavior. However, it does not describe three out of four parameters (item, page, page_size) in detail, which slightly reduces completeness.

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

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

Schema coverage is 0%, so the description must compensate. It describes the 'type' parameter by listing values like 'FIIs, stocks, ETFs, fixed income (CDB/LCI/LCA/Tesouro)', which maps to the enum. However, it does not explain 'item', 'page', or 'page_size'. Partial compensation.

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 identifies the resource as 'investment portfolio for a connection', listing many asset types and fields. This clearly differentiates it from sibling tools like openfinance_list_investment_transactions (transactions vs. portfolio) and 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 implies usage for retrieving investment portfolio data when the INVESTMENTS product is enabled, and explicitly states that it returns a warning object on 403 instead of throwing. However, it does not provide explicit when-to-use or when-not-to-use guidance relative to other similar tools.

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

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

Annotations already indicate readOnly and idempotent. The description adds behavioral detail: return fields (quantity, value, amount, netAmount, etc.) and itemized expenses, plus bulk execution capability. No contradictions.

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

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

Two concise sentences: first states purpose and return fields, second gives usage order and bulk support. No waste, front-loaded.

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

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

For a read-only list tool with no output schema, the description adequately explains return data and dependencies (requires prior investment list). Pagination details are missing but not critical for basic usage.

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

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

With 0% schema coverage, the description partially compensates by explaining investment_id and investment_ids usage. However, page and page_size parameters are not described, leaving a gap for pagination semantics.

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

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

The description clearly states it returns 'movement history for a specific investment position' and enumerates transaction types (BUY/SELL/TAX/INTEREST/AMORTIZATION/TRANSFER), distinguishing it from sibling tools like 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?

Provides explicit guidance to use after openfinance_list_investments to get the investment_id, and mentions bulk support via investment_ids. No explicit 'when not to use', but 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?

Discloses sequential execution with rate-limit spacing and return format beyond annotations. Annotations already indicate readOnly and idempotent, 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?

Two sentences cover purpose, parameter usage, and return format without redundancy. Ideal 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?

Covers essential aspects for a listing tool with optional filtering and sequential handling. Could mention error handling briefly, but sufficient given no output schema.

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

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

Schema has 0% coverage; description fully compensates by explaining each connection selector type and the effect of omitting or passing multiple items.

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, distinguishing from sibling tools like openfinance_list_accounts. Includes endpoint and scope.

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

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

Provides explicit guidance on when to pass 'items' vs omit, and explains sequential querying with rate limiting. Does not directly contrast with siblings, but the purpose is specific 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?

Adds significant behavioral context beyond annotations: explains PENDING vs. POSTED behavior varies by connector, aggregation logic when using search_queries (up to 5000 transactions), error handling (returns warning/error instead of throwing), 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 long but every sentence adds value. Well-structured with sections: general use, credit card specifics, filtering, error handling, bulk support. Slightly verbose for a 5, but 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 behavior, error handling, and credit card nuances well. It could mention the output format (e.g., results array with total) but does describe the error format. Other tools like openfinance_get_item_status are referenced for troubleshooting, adding 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?

Schema coverage is 0%, so description carries full burden. It explains all parameters: from/to (ISO YYYY-MM-DD), page/page_size (max 500), search_queries (case-insensitive, OR semantics, aggregates up to 5000), and account_id/account_ids. Adds meaning beyond schema types.

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

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

The description clearly states it returns transactions for bank accounts (BANK or CREDIT) and differentiates itself from siblings like openfinance_list_credit_card_bills and openfinance_list_transactions_by_item. It specifically explains the credit card use case, making the purpose unambiguous.

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

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

Provides explicit guidelines: when to use this vs. openfinance_list_credit_card_bills (itemized vs. bill totals), how to handle truncated results (narrow date range), and what to do if total=0 for CREDIT accounts (check connection health). Also mentions bulk support for batched execution.

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, so the tool is safe. The description adds critical behavioral traits beyond annotations: default granularity returns a compact summary, scan caps at 5000/account with a truncation flag, and internal account resolution. 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 comprehensive but slightly verbose; every sentence provides value. It is front-loaded with the primary purpose and expands logically. Could be trimmed by a few words but remains clear and 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 no output schema, the description fully explains the return format: compact summary with totals, monthly evolution ('por_mes'), top expenses/revenues, per-account breakdown, and the truncation flag. It also covers edge cases like omitting 'item' and granularity options, making it complete 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?

Despite 0% schema description coverage, the description thoroughly explains all six parameters: 'item' can be connector_id/connector_name/item_id, 'from'/'to' are ISO dates, 'granularity' defaults to monthly vs raw, 'type' filters BANK/CREDIT, and 'top_n' (implied for top expenses/receipts). This fully 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 clearly states it performs 'consolidated cash-flow analysis for a whole bank connection over a period in one call', using a specific verb ('analyze') and resource ('connection transactions'). It distinguishes itself from siblings like openfinance_list_transactions by resolving accounts internally, eliminating the need for separate account listing calls.

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

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

The description provides clear context on when to use: for 'análise anual/mensal', 'fluxo de caixa', 'entradas e saídas', 'maiores gastos/recebimentos'. It also explains when to use granularity:'raw' for itemized rows and that omitting 'item' analyzes all banks. However, it does not explicitly state when not to use this tool relative to siblings beyond the implicit alternative of using openfinance_list_accounts first.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering safety and idempotency. The description adds valuable behavioral context: it checks a public status page, returns global indicator, degraded components, open incidents, and flags affected banks. This enriches transparency beyond the annotations.

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

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

The description is a single paragraph that is well-structured: it starts with purpose, then usage context, then return fields. It is concise but packed with information. Minor improvement could be splitting into bullet points, but 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 the tool has no parameters and no output schema, the description is exceptionally complete. It explains the return values in detail (global indicator, degraded components, open incidents, `your_banks_affected`) and covers the use case and distinction from related tools. An agent can confidently invoke this tool.

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

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

The tool has zero parameters, so schema description coverage is 100% with no need for parameter details. The description adds meaning by explaining the return value structure (global indicator, components, incidents, affected banks), which compensates for the lack of an output schema. Baseline for no-parameter tools 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 verb 'Checks' and the resource 'LIVE operational status of the Open Finance provider'. It explicitly distinguishes from the sibling tool `openfinance_get_item_status` by noting this is about the provider's health, not the connection's status.

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

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

The description provides explicit when-to-use guidance: 'whenever data looks incomplete or stale even though a connection shows UPDATED'. It contrasts with the alternative (`openfinance_get_item_status`) and explains what the tool reveals (upstream outage, 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 declare readOnlyHint, idempotentHint, and destructiveHint false, so safety is clear. The description adds valuable behavioral context: honors user's plan (PF hides PJ banks), returns a hint if no keywords, and never dumps the catalog. 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 dense sentences covering key points without fluff. It efficiently conveys purpose, usage, parameters, and return behavior. Could be slightly more structured but is appropriate for length.

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

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

Given no output schema, the description adequately lists return fields (connector id, access, audience, linked connections, connect_url) and key behaviors. It covers what an agent needs to know to invoke and interpret results, though a note on pagination or error handling is missing.

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

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

Schema coverage is 0%, but the description compensates well: explains keywords[] as an array of bank names to search, emphasizes it is REQUIRED despite no schema required constraint, and clarifies include_accounts affects whether linked accounts are returned. Provides concrete 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?

The description clearly states the tool searches bank connectors by name (keywords), returning connector details and a connect URL. It specifies the exact resource and action, and distinguishes itself from siblings by explicitly noting it never dumps the full catalog, unlike list-style tools.

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

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

The description explicitly advises calling this tool BEFORE connecting to provide a one-click link, and notes that keywords[] is REQUIRED (returns a hint otherwise). It provides usage context but does not explicitly contrast with alternative tools like openfinance_list_connections.

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 only readOnlyHint=false, so description carries full burden. It thoroughly explains side effects (creates Category Rules affecting future transactions), batch behavior (per-item errors don't fail batch), and response shape. Adds significant 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?

Description is moderately long but well-structured: purpose first, then parameter details, then behavioral side effect, then response format. Every sentence adds value, though some might be slightly verbose.

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 input format, behavioral impact, error handling, and output structure. References sibling tools for ID sources. Despite no output schema, the description provides sufficient response shape. Leaves no major gaps for a batch update tool.

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

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

Schema has 0% description coverage, but description fully explains the 'items' parameter: it's an array of objects with transaction_id and category_id, and explicitly tells where to get these IDs from other tools. This compensates for 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?

Clearly states the verb 'Corrects' and resource 'category of one or more transactions', with explicit HTTP method and endpoint (PATCH /transactions/:id). Distinguishes itself from sibling tools like openfinance_list_transactions by being the dedicated update tool.

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

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

Provides explicit guidance on when to use (fix miscategorized transactions), where to obtain required IDs (from openfinance_list_transactions and openfinance_list_categories), and explains the side effect of creating Category Rules. Lacks explicit 'when not to use' but context is clear.

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

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

Annotations already indicate idempotentHint (true) and destructiveHint (false). The description adds useful behavioral context by specifying that the conversation array should be included for reproduction. However, it does not disclose what happens after submission (e.g., storage, forwarding).

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

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

The description is extremely concise, using two sentences to deliver purpose and usage guidance without extraneous words. Every phrase adds value.

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

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

Given no output schema and limited parameter descriptions, the description provides only minimal completeness. It explains the key input (conversation) but omits details on the tool's internal behavior or response. For a simple reporting tool, it is adequate but not rich.

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

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

With 0% schema description coverage, the description must compensate. It explains the 'conversation' parameter well but does not describe the 'context' parameter or provide details beyond the schema. The required 'message' parameter is obvious from the tool's purpose.

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 with specific verbs ('Report') and resources ('a bug, missing feature, or send feedback'). It distinguishes itself from sibling tools, which are all finance-related, making it unique.

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 when to use the tool and what to include ('Include the conversation array with recent messages for reproduction'). It does not explicitly state when not to use or alternatives, but the context is clear enough for a generic feedback tool.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description adds value by specifying the exact content (platform and adapter versions) without contradicting annotations.

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

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

The description is a single, short sentence that directly conveys the tool's action. 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 parameters and no output schema, the description adequately states the tool's function. Minor omission: could mention output format, but not critical for a simple version display.

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 schema covers everything. The description adds no parameter info, but none is needed; baseline is 4 for zero parameters.

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

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

The description clearly states the tool shows current MCP platform and adapter versions, which is specific and distinct from the sibling tools. No tautology or ambiguity.

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 tool's purpose is self-explanatory as a read-only version checker, but the description does not explicitly compare to siblings like toolkit_info or provide 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 declare readOnlyHint, idempotentHint, and destructiveHint. The description adds value by specifying exactly what data is returned (installed MCPs, connection status, catalog tool counts). 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?

One sentence, no fluff, completely clear. Every word earns its place.

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

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

With no parameters and no output schema, the description fully explains the return value. Annotations cover safety. Complete for a simple status 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?

Tool has no parameters, so schema coverage is 100%. Baseline for 0 parameters is 4; description adds no parameter info because none exist.

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 'Returns the current toolkit state: installed MCPs, their connection status, and how many catalog tools each exposes.' This clearly identifies the tool's purpose and differentiates it from sibling tools like authenticate, connect, and 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?

The description implies usage for checking state but does not provide explicit guidance on when to use this tool versus alternatives. No exclusions or alternatives are mentioned. Acceptable because the tool is simple, but missing explicit guidance.

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