Uber Conta by Digio MCP

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

Annotations indicate idempotency and non-destructive behavior. The description adds value by detailing the two authentication modes (permanent vs. session) and explaining the flow (log in browser, copy token). It also notes the permanence of the config header method, providing behavioral context beyond what annotations offer.

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 highly concise: two sentences that immediately convey the tool's purpose and usage. Every sentence adds necessary value, and the structure is front-loaded with the most critical 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 an authentication tool with one optional parameter and no output schema, the description is fully complete. It explains both usage modes, how to obtain the token, and the implications of each method. No additional context is needed.

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

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

The schema has no description for the 'token' parameter (0% coverage). The description compensates by explaining that the token is a JWT obtained from browser login, and how to use it for session authentication. This adds significant meaning, though it could be more explicit about the token format.

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

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

The description clearly specifies the tool's purpose: authenticating the user by either configuring a permanent token in the server config or providing a session token. It delineates distinct usage scenarios (permanent vs. session) and differentiates from sibling tools like 'connect' by focusing on authentication.

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

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

The description provides clear guidance on when to use the tool: for session login with a token, or for permanent setup via config header. It also implies calling with no arguments to get the login link. However, it does not explicitly state when not to use this tool or list alternatives among siblings.

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

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

Adds value beyond annotations by detailing conditional return values (authenticated:true vs connect_url). Consistent with readOnlyHint and idempotentHint.

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

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

Two clear sentences with no wasted words, front-loading the core purpose.

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

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

Despite no output schema, the description explicitly covers both scenarios (connected and missing credentials), making it complete for a 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, so schema coverage is 100%. Description does not need to add parameter info; baseline for 0 params 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?

Description clearly states it returns connection status and URLs, with a specific verb-resource pair. The conditional behavior distinguishes it from sibling tools like 'authenticate' which likely performs the 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 context on when to use based on provider state (connected vs missing credentials), but does not explicitly mention when not to use or direct to alternatives like 'authenticate'.

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

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

The description goes far beyond annotations (which only declare readOnlyHint and destructiveHint as false). It reveals key behaviors: invoke works even for uninstalled MCPs, returns connect or checkout links for auth/payment, and that install adds MCP permanently. It also clarifies that writes require workspace owner/admin. 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 long but every sentence serves a purpose. It is front-loaded with the tool's role and core flow. However, the dense paragraph format could be improved with bullet points or sections for clarity. Despite the length, it remains efficient for the tool's complexity.

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

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

Given the tool's complexity (15 parameters, no output schema), the description covers all essential aspects: core flow, auth/payment handling, permanent vs. one-off usage, permissions, and the purpose of each action. It provides enough context for an agent to use the tool correctly without needing to consult external documentation.

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 must compensate. It explains the meaning of the action parameter (search, describe, invoke, etc.) and related parameters like query, mcp_id, tool_id, arguments. However, many parameters (limit, message, immediate, tier_slug, conversation, request_name, cancel_reason, cancel_comment, report_context, request_details) are not described, leaving gaps. The description adds value for the core parameters but is incomplete.

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 'THE official mcp.ai marketplace' and explains its dual role as a catalog and execution platform. It distinguishes itself from sibling tools (mostly openfinance-related) by its unique purpose. The description outlines the core flow (search→describe→invoke) and lists all actions, making the tool's function unambiguous.

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

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

The description provides explicit guidance: 'use THIS tool FIRST, before any external/generic registry', and distinguishes between invoke (one-off use) and install (permanent addition). It also explains when to use other actions like subscribe, cancel, report_bug, and request_mcp, along with permission requirements (owner/admin for writes). This gives an agent clear decision 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 already indicate destructiveHint=true, and the description adds that data becomes unavailable and returns a re-connection URL, providing useful context beyond the annotation.

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 action, no filler. 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?

While the description covers the destructive effect and return value, it lacks parameter documentation, which is a significant gap for a single-parameter tool with 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?

The parameter 'item' is not described in schema or description; the tool says 'for a specific bank' but does not explain that 'item' identifies the bank, leaving agents unable to determine what value to provide.

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 revokes consent and deletes connection data for a specific bank, distinguishing it from sibling tools like openfinance_list_connections or openfinance_force_sync.

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

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

The description implies when to use (to disconnect a bank) and clarifies consequences, but does not explicitly state when not to use or mention alternatives, though siblings are distinct 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 indicate readOnlyHint=false, aligning with mutation. The description adds significant behavioral context: PATCH then poll mechanism, ~60s timeout, return fields including status, executionStatus, lastUpdatedAt, synced, needs_action, timed_out. It also explains optional wait behavior.

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 and front-loads the main action, then usage context, then parameters, then return values. While it could benefit from bullet points, it remains concise and well-organized for the amount of information conveyed.

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 2 parameters, no output schema, but complex async behavior, the description covers the return format, possible statuses, and references a sibling tool for re-checking. It is complete and self-contained.

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

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

Schema coverage is 0%, but the description fully explains both parameters. It details that items can be an array of selectors (item_id, connector_id, or connector_name) and that omitting items syncs all. The wait parameter is explained with fire-and-forget 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 the verb 'Forces the bank to re-sync' and specifies the resource 'one or more connections'. It distinguishes itself from sibling tools like openfinance_get_item_status by mentioning the waiting and polling behavior, and contrasts with disconnecting/reconnecting.

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

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

Explicitly tells when to use: 'when a balance or transaction list looks stale'. It also explains what it avoids: 'WITHOUT disconnecting/reconnecting'. Guidance on alternative behavior for fire-and-forget and handling of needs_action/timed_out is provided.

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, but the description adds significant behavioral context: credit accounts may return BALANCE_FETCH_ERROR with warnings, and upstream failures degrade to last-synced balance with 'realtime: false' and warnings. No contradiction with annotations.

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

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

The description is extremely concise with no unnecessary words. It starts with the main action, then logically adds edge cases and response shape, making it 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 the tool's simplicity (single parameter) and no output schema, the description adequately covers the response shape and error scenarios. Minor missing detail: exact format of account_ids, but the schema and the '1–50' limit suffice.

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

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

The schema has 0% description coverage, but the description compensates by explaining that account_ids must be an array of 1-50 strings. This adds crucial meaning beyond the raw schema.

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

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

The description clearly states that the tool returns real-time balance per account id, specifying the GET endpoint and limiting to 1-50 account_ids. It differentiates from sibling tools like openfinance_get_accounts_detail by focusing solely on balance retrieval.

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

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

The description provides clear context on when to use the tool (for real-time balance) and how it handles errors (credit accounts and upstream failures). It doesn't explicitly contrast with alternatives, but the behavior is well outlined, making usage intuitive.

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, non-destructive. Description adds valuable context: batch shape, provider_incident block, and warning about unreliable values. 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?

Four sentences, each with distinct value: purpose, parameter spec, batch shape, and edge case warning. Extremely concise with no fluff.

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 single-parameter tool with no output schema, description covers purpose, parameter limits, batch shape, and important edge case. Lacks description of the return object fields beyond creditData, but reasonable given 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 coverage 0%, but description explains account_ids is an array (1-50). However, it lacks format details for the strings, which would help the agent construct valid requests.

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 full account objects with extended creditData per id. Distinguishes from siblings like openfinance_list_accounts by specifying 'full account objects' and batch shape.

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 context: pass account_ids as array (1-50), batch shape, and warning about provider incident. While not explicitly stating when not to use, it implies usage for detailed views.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. Description adds valuable behavioral context: batch shape { results, errors }, Pluggy's lack of paid/status field, and the subtle behavior that payments[] during this bill's cycle typically reflect payment of the previous bill.

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

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

The description is lengthy but well-structured: front-loaded with purpose, then caveats and usage tips. Every sentence adds value. Could be slightly tightened for extreme conciseness, but it's highly functional.

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

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

Given the complexity of credit card bills, the description covers returns, exclusions (transactions), batch shape, connector-specific notes (Pluggy, Brazilian Open Finance), and cross-tool guidance. No output schema exists, but description compensates with return shape details.

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 fully explains the single parameter bill_ids: it's an array, should use list_credit_card_bills to discover ids, and the tool returns a batch shape. This adds essential meaning beyond the raw schema.

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

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

The description clearly states it returns bill-level detail for credit card bills by id, specifying fields (financeCharges, payments[]). It distinguishes from sibling tools like openfinance_list_credit_card_bills (listing) and openfinance_list_transactions (itemized transactions), which is explicit.

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: use list_credit_card_bills first to discover ids, use list_transactions for itemized transactions, and prefer list_credit_card_bills for paid status. Also warns against reconstructing totals from transactions by billId.

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

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

Annotations already indicate readOnly, idempotent, non-destructive. Description adds context on return values (executionStatus, connector metadata) and the two usage modes, enhancing 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 wasted words; 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?

For a simple tool with one optional parameter and no output schema, the description covers the two usage modes, return format hints, and is sufficient for the agent to select and invoke 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?

The single parameter `item` has 0% schema description coverage, but the description fully explains its effect: omit for all banks, pass for a single bank. 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?

Clearly states it returns bank connection status with specific values (UPDATED, UPDATING, LOGIN_ERROR, etc.) and distinguishes 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 include the `item` parameter for different behaviors. Lacks explicit when-not-to-use or alternatives, but 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 declare readOnlyHint, destructiveHint, and idempotentHint. The description adds useful behavioral details: it returns a batch shape with results and errors, and lists the specific fields returned. This goes beyond annotations, though it could mention authentication or rate 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?

The description is a single well-structured paragraph that packs a lot of information without redundancy. It could benefit from bullet points for readability, but it is concise and front-loads the core purpose.

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

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

Given the absence of an output schema, the description covers the return fields extensively, provides usage context, and specifies parameter limits. It mentions the batch shape with results and errors, which compensates for missing output documentation. Slightly more detail on error handling would raise it to 5.

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 specifies that loan_ids is an array and adds the constraint of 1-50 items, which is not in the schema. It also describes the batch response shape. This adds significant meaning beyond the bare schema.

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

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

The description clearly states it returns full loan contract detail by ID (GET /loans/:loanId) and explicitly distinguishes it from the sibling tool openfinance_list_loans, which is for listing. The verb 'get' and resource 'loan detail' are 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 explicitly states when to use: 'Use after openfinance_list_loans to deep-dive on a specific contract.' This provides clear guidance and implies not to use for listing. No alternatives are mentioned but the context is sufficient.

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

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

Beyond annotations (readOnlyHint, idempotentHint), the description adds critical behavioral context: credit balance meanings vary by connector, provider incidents can make balances unreliable, account name is the legal entity not the brand, and response structure changes based on `item`. 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 somewhat lengthy. It is well-structured, starting with the main purpose, then details, parameter usage, and warnings. Every sentence adds value, but could be slightly more concise without losing clarity.

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

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

Given the absence of an output schema and the complexity of the tool, the description covers all necessary aspects: return fields, parameter usage, caveats, alternative tools, and provider incidents. It is complete for an agent to select and invoke the tool correctly.

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

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

Schema description coverage is 0%, so the description fully compensates by explaining the `item` parameter (omit for all, pass for single bank) and the `type` enum (BANK/CREDIT). It also clarifies response behavior and the meaning of fields like bank, connector_id, and creditData.

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, specifying types BANK and CREDIT along with fields like balance, number, type, subtype, bankData, and creditData. It distinguishes itself from siblings like openfinance_list_credit_card_bills by noting that for standardized bill amounts, that tool should be 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 explicitly explains when to omit or pass the `item` parameter: omit to list all linked banks, pass for a single bank. It also advises using openfinance_list_credit_card_bills for standardized open-bill amounts and warns about credit balance connector-dependency.

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

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

Annotations (readOnlyHint=true, idempotentHint=true, destructiveHint=false) already indicate safe behavior. The description adds caching behavior and a single aggregated response, which are beyond annotations. No contradictions.

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

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

Three sentences: first states purpose, second details response fields, third notes caching and no batch ids. Every sentence adds value, front-loaded with key information, 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 zero parameters and no output schema, the description fully explains what the tool returns and how to use it (e.g., categoryId for update). Annotations cover safety. Context is sufficient for correct selection and 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?

The input schema has no parameters, so schema_description_coverage is 100% trivially. The description adds value by detailing the response structure (fields: id, description, descriptionTranslated, parentId, parentDescription), which compensates for the 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?

The description clearly states the tool returns the transaction category taxonomy via GET /categories, cached per session. It specifies the resource (categories) and action (list), distinguishing it from sibling list tools like list_accounts or list_transactions.

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

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

The description provides clear context for when to use the tool: to obtain category IDs for openfinance_update_transaction_category, and notes language preferences (Portuguese for pt-BR users). It lacks explicit when-not or alternative tools, but the use case is well-defined.

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, so the description's main added value is listing the return fields. It does not describe quotas, rate limits, or any other behavioral traits. 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?

Single sentence, concise and front-loaded with key information. Every word adds value—no fluff.

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 fully covers what the tool does, what it returns, and its purpose. For a simple list tool, this is 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 in the input schema (schema coverage 100% vacuously). Description adds meaning by explaining the return fields (connector_id, item_id, bank name, add_connection_url), which compensates for lack of parameter documentation.

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

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

Description clearly states the tool returns saved bank connections with specific fields (connector_id, item_id, bank name, add_connection_url). Differentiates from sibling tools like openfinance_list_accounts which list accounts rather than 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?

Description implies usage for viewing saved connections and obtaining a URL for adding more. While it doesn't explicitly state when not to use or compare to alternatives, the context of sibling tools (e.g., openfinance_list_accounts, openfinance_list_transactions) allows an agent to infer appropriate usage. Slight improvement could be adding a note about when to use this vs. other list tools.

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

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

The description adds substantial behavioral context beyond annotations (readOnlyHint, idempotentHint): payment semantics, derived status logic, connector limitations, bill grouping reliability warnings, and error behavior (returns warning instead of failing). 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 very long (multiple paragraphs) and could be more structured with bullet points. However, all information is necessary for correct tool usage; conciseness is sacrificed for completeness. Agent may struggle with length but detail is essential.

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

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

Given the complexity of credit card bill semantics and lack of output schema, the description is remarkably complete. It covers return fields, derived status logic, connector asymmetry, error handling, cross-references to other tools, and warns against common mistakes like summing transactions by billId.

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

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

With 0% schema description coverage, the description compensates by explaining account_id, include_open_bill, and account_ids for batch support. Page and page_size are not explicitly explained but are standard pagination parameters. Overall adds significant meaning.

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 CLOSED credit card bills for a CREDIT-type account, listing specific fields and derived data. It distinguishes itself from openfinance_list_transactions by noting that tool is for itemized purchases.

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

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

The description provides extensive when-to-use and when-not-to-use guidance, including payment allocation rules, derived payment_status, when to use include_open_bill, connector asymmetry, and explicitly mentions alternatives like openfinance_list_transactions.

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

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

Annotations already indicate readOnlyHint=true and idempotentHint=true. The description adds value by disclosing the error handling behavior (returns total, results, warning instead of throwing on 403) and listing return fields, which enhances transparency 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 concise and well-structured: first sentence states purpose and asset types, second lists example fields, third covers error handling. Every sentence adds unique value without 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?

The description covers return content and error behavior but omits parameter explanations and any pagination details. Given the tool has 4 optional parameters and no output schema, the description is incomplete for effective use.

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

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

With 0% schema description coverage, the description must explain parameters but does not. It mentions return fields but fails to describe the four parameters (item, page, type, page_size). This is a significant gap for usability.

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 an investment portfolio for a connection, listing specific asset types (FIIs, stocks, ETFs, etc.). It distinguishes from sibling tools like openfinance_list_investment_transactions by focusing on the overall portfolio holdings.

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

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

The description provides context (for broker/bank with INVESTMENTS product) but does not explicitly guide when to use this tool vs alternatives like openfinance_list_investment_transactions or openfinance_list_accounts. Usage is implied but not compared.

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, idempotent, non-destructive. Description adds valuable detail on returned fields (quantity, value, netAmount, expenses breakdown) and bulk support. 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 paragraphs, no waste. Front-loaded with purpose and return data. Every sentence serves a clear function.

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 return data, prerequisite, and bulk mode. Lacks explanation of pagination parameters, but given annotations and typical list tools, this is a minor gap.

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

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

Schema has no descriptions (0% coverage). Description explains investment_id and investment_ids (bulk support) but omits page and page_size. Partially compensates but leaves pagination unexplained.

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

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

The description clearly states the tool returns movement history for an investment position, listing specific transaction types (BUY, SELL, TAX, etc.). It distinguishes itself from sibling tools like openfinance_list_investments and openfinance_list_transactions.

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

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

Explicitly advises to use after openfinance_list_investments to obtain the investment_id. Implicitly suggests when to use this tool over others, though no direct when-not or alternative comparisons.

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 details beyond annotations: sequential querying with rate-limit spacing, and return structure `{ results, errors }` per connection. No contradiction with readOnlyHint=true.

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

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

Two efficient sentences: first states purpose and endpoint, second explains the sole parameter and its omission behavior. No extraneous words, front-loaded with key action.

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

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

No output schema exists, but description states return format (`{ results, errors }` per connection). Covers what the tool does, parameter usage, rate-limit behavior, and response shape. Complete for a simple list tool.

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

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

Schema has 0% coverage for the only parameter `items`. Description explains that items are 'connection selectors (item_id uuid, connector_id, or connector_name)' and that each entry represents a connection. This fully 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 'Lists loan contracts per bank connection (GET /loans)'. Verb 'list' and resource 'loan contracts per bank connection' are specific. Distinguishes from siblings by specifying connection-based scoping and optional items parameter for filtering.

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 include the `items` parameter (for specific connections) and when to omit it (for all linked banks). Also mentions sequential queries with rate-limit spacing. Does not explicitly compare to alternatives, but the focus on loans makes usage 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 declare readOnlyHint and idempotentHint. The description adds substantial behavioral context: per-connector inconsistencies (sparse billId, pending/posted variation), auto-pagination up to 5000 with truncation, error returns on upstream failures, and provider incident caveats. 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 long but well-structured, with front-loaded main purpose and organized details. Some sentences are verbose, but the complexity warrants the length. Could be slightly more concise without losing clarity.

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

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

Given 8 parameters and no output schema, the description covers output structure (account echo block, truncation, provider_incident), edge cases (zero total for credit accounts, connector-specific behavior), and error handling. It is complete and leaves minimal gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It thoroughly explains each parameter: from/to date filters, search_queries with case-insensitive OR semantics, pagination (default auto-page vs explicit page), detail levels (compact/rich/raw) with their specific fields, and bulk account_ids. Adds 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 transactions for bank accounts (BANK or CREDIT type) and explicitly distinguishes its role for CREDIT accounts as the only way to get itemized transactions, referencing 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?

Provides explicit guidance on when to use this tool versus alternatives, such as directing users to openfinance_list_credit_card_bills for standardized open-bill totals, and warns against summing by billId. Also details pagination, date filters, keyword search, and error handling.

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 non-destructive. The description adds valuable behavioral details: scan caps at 5000/account with truncated flag, provider_incident block when provider has open incident affecting totals, and default vs raw granularity behavior. These go 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 lengthy but each sentence adds value. It front-loads the key benefit and uses concise wording. Minor structural improvement could be splitting into bullet points for readability, but it remains clear and non-redundant.

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 thoroughly explains the return structure: compact summary with total entradas/saídas/saldo_liquido, monthly evolution por_mes, top_despesas/recebimentos, per-account breakdown, and for raw granularity, consolidated transaction rows with optional rich detail. Also covers truncation and provider_incident flags.

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

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

With 0% schema description coverage, the description fully compensates by explaining every parameter: item accepts connector_id/connector_name/item_id or omitted for all, from/to are ISO dates, granularity and detail with enum options and effects, type filters accounts, and top_n implicitly relates to top expenses/receipts. Defaults and behavior are clearly articulated.

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 bank connection, aggregating transactions in one call. It distinguishes from siblings by noting that it eliminates the need to call openfinance_list_accounts first or carry account UUIDs. The verb 'list transactions by item' is specific and the description clarifies the aggregation purpose.

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

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

The description explicitly states when to use it: for cash-flow analysis, monthly evolution, top expenses/receipts. It provides usage examples in Portuguese and explains when to use different granularity/detail levels. However, it does not directly contrast with the sibling openfinance_list_transactions to guide when to prefer raw transaction listing over aggregation.

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, making safety profile clear. Description adds value by detailing the output (global indicator, degraded components, incidents, affected banks) and noting it checks a public status page, which is not obvious from 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 purpose and then provides usage guidance and output details. While informative, it could be slightly more concise, but it is well-structured and avoids 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?

Despite no output schema, the description fully explains the return value: global indicator, degraded components, open incidents, and affected banks. It also references the sibling tool for context. The tool is simple (no params) and the description covers all necessary information.

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

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

No parameters exist, so schema coverage is 100% by default. Description does not need to add parameter info; baseline of 4 is appropriate.

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

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

The description clearly states the tool checks the LIVE operational status of the Open Finance provider, using specific verbs and distinguishing from the sibling tool openfinance_get_item_status. It explicitly contrasts provider health vs. connection 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?

Provides explicit when-to-use guidance: when data looks incomplete or stale despite an UPDATED connection. It explains how to differentiate provider-side problems from connection issues, and mentions the sibling tool as alternative.

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

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

Beyond annotations (readOnlyHint, idempotentHint), the description adds transparency by explaining that some connectors have a caveat about not auto-updating, that the tool surfaces this to guide user preference, and that it respects the user's plan (PF hides PJ banks). 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 well-structured, starting with the primary action and then detailing return values, warnings, and usage notes. It is slightly long but every sentence contributes necessary information, making it efficient for an AI agent.

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, the description adequately describes the return value structure (connector id, access, audience, connections, connect_url). It also accounts for edge cases (no keywords, caveats, plan filtering). For a tool with two parameters and no nested objects, this is sufficiently complete.

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

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

With 0% schema description coverage, the description compensates by explicitly clarifying that keywords[] is required despite not being in the required list, and explains the effect of include_accounts (returns accounts when true). This adds meaningful semantic value beyond the raw schema.

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

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

The description clearly states the tool's action ('Searches the available bank connectors by name'), specifies the required input format (keywords array), and details the returned information (connector id, access, audience, connections, connect_url). It distinguishes itself from sibling tools like openfinance_list_connections by focusing on search-and-select before connecting.

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

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

The description provides clear guidance: 'Call this BEFORE connecting to hand the user a one-click link to the right bank.' It also explains that keywords is required and that without it the tool returns a hint. It mentions that the tool honors the user's plan, but does not explicitly state when not to use it versus alternatives like authenticate or connect.

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 fully discloses behavioral traits: it overrides automatic categorization, teaches Pluggy by creating a Category Rule for future similar transactions, and explains batch error handling with per-item errors not failing the batch. Annotations provide no additional info (all false), so the description carries the burden and excels.

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

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

The description is three sentences long and front-loaded with the main purpose. Each sentence adds value, but it could be slightly more concise. However, it is well-structured and not wasteful.

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

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

Given the tool has one parameter with nested objects, no output schema, and no annotations beyond basic hints, the description covers usage, behavior, and response format comprehensively. It explains the return shape including updated, results, and errors, which is sufficient 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?

Schema description coverage is 0%, so the description must compensate. It explains that items is an array of objects with transaction_id and category_id, and importantly specifies where to obtain these IDs (from openfinance_list_transactions and openfinance_list_categories), adding significant semantic value beyond the schema structure.

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

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

The description clearly states the tool corrects the category of transactions using PATCH /transactions/:id. It distinguishes from sibling read-only tools like openfinance_list_transactions by being an update operation. The verb 'Corrects' is specific and appropriate.

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 provides explicit guidance on how to use the tool: pass items as an array with transaction_id and category_id, with sources from other tools. It implies when to use (fix miscategorized transactions) and describes the side effect of creating a Category Rule. However, it does not explicitly state when not to use it, but 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 provide idempotentHint=true and destructiveHint=false, covering safety. The description adds no further behavioral context (e.g., backend effects, authentication needs). It adds the reproduction hint but that's a usage guideline, not behavioral.

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 (one sentence, 15 words) and front-loaded with the purpose. It could be slightly more structured but is not 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?

For a 3-parameter tool with no output schema and minimal annotations, the description lacks completeness. It omits explanations for 'message' and 'context', which are important for correct invocation.

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

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

Schema has 0% description coverage, so description must compensate. It explains the 'conversation' parameter ('Include the conversation array with recent messages') but does not describe the required 'message' or optional 'context' 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's purpose with specific verbs and resources: 'Report a bug, missing feature, or send feedback.' This distinguishes it from sibling tools, none of which handle issue reporting.

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

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

The description gives explicit guidance to include the conversation array for reproduction. It implies when to use (reporting issues) but does not explicitly exclude alternatives 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds that it shows specific version information. No additional behavioral traits are disclosed beyond what annotations provide, but the description is consistent and adequate.

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

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

The description is a single sentence that clearly communicates the purpose without any unnecessary words. It is front-loaded and efficient.

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

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

For a simple version-display tool with no parameters and no output schema, the description is fully adequate. It tells the user exactly what the tool does, and no further context is needed.

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 coverage is 100% by definition. The description does not need to add parameter details. A baseline of 4 is appropriate as there is no loss of information, though the description could mention that no input is required.

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

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

The description clearly states the tool displays current MCP platform and adapter versions, with a specific verb 'show' and resource 'versions'. It effectively distinguishes itself from sibling tools that deal with authentication, openfinance, 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?

No explicit guidance on when to use or alternatives is provided. However, the tool's simplicity makes usage self-evident, but there is no mention of when it might be useful versus other info tools like 'toolkit_info'.

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, confirming no side effects. The description adds value by detailing exactly what the output contains (installed MCPs, connection status, catalog counts), which is useful 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, well-structured sentence that front-loads the key action ('Returns the current toolkit state') and lists the specific outputs. No extra 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 zero parameters and no output schema, the description adequately communicates what the tool returns. While it does not specify the exact format or structure of the output, it covers the main content sufficiently for an agent to understand the tool's purpose.

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

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

There are no parameters, so the description does not need to add meaning beyond the schema. The schema has 100% coverage and no properties to explain, making the description sufficient.

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

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

The description clearly states the tool returns the current toolkit state, specifying three key pieces of information: installed MCPs, their connection status, and catalog tool counts. This distinguishes it from siblings like 'authenticate' or 'connect', which serve different purposes.

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 explicitly state when to use this tool versus alternatives. It is implied that this tool is for obtaining an overview of the toolkit state, but no exclusions or alternative guidance is provided.

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