Crefisa MCP

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

Description explains the two behavioral modes (link generation vs token acceptance) and notes the permanent config option. Annotations already indicate non-destructive and idempotent; description adds context about the login flow.

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?

Information-dense single paragraph that front-loads purpose. Could be slightly better structured (e.g., bullet points), but every sentence adds 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?

Covers input and usage modes thoroughly, but lacks description of the output/return value (e.g., confirmation, token). With no output schema, the description should inform the agent about what the tool returns.

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 only parameter 'token' is explained as a JWT string. The description specifies when to provide it (after user pastes) and how it's used (session-only login). Compensates well 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 handles authentication for IDE agents, providing a login link or accepting a token. It distinguishes from sibling tools like 'connect' and 'marketplace' by focusing solely on credential handling.

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 describes when to use (to log in), how to use (with or without token), and recommends a best practice (adding to config for permanent access). Clearly explains the two modes: session-only vs permanent.

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 readOnly, idempotent, not destructive. Description adds specific behavioral details on return values under different conditions (all connected vs. missing credentials), which is valuable beyond annotations.

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

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

Two sentences, no fluff, front-loaded with purpose. Every sentence provides value.

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

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

Given no parameters and no output schema, the description explains return behavior for two scenarios. It is fairly complete but could mention that it is a read-only operation (already in annotations).

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

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

No parameters so schema coverage is 100%. Description adds meaning about the output based on state, which is helpful. 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?

The description clearly states it returns connection status and URLs, which distinguishes it from sibling 'authenticate' which likely performs authentication. However, it does not explicitly differentiate from other status tools like 'openfinance_provider_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?

Implied usage for checking connection status, but no explicit when-not-to-use or alternative tools mentioned. Could be improved by noting that if not connected, use '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?

Discloses key behaviors: invoke works even if MCP not installed, returns connect/checkout links on auth/payment failures, and warns that writes require owner/admin. Adds value beyond annotations.

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

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

Description is long but well-structured around the core workflow, front-loading purpose and key instructions. Some redundancy could be trimmed, but content is valuable and organized.

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

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

Given the tool's complexity (13 params, multiple actions, no output schema), the description covers the main workflow and edge cases (auth, payment, permissions). However, some parameter details are 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%, requiring the description to compensate. It explains the high-level flow and mentions some parameters (action, mcp_id, tool_id, arguments) but does not provide detailed semantics for all 13 parameters, leaving gaps.

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's the official marketplace for MCPs and tools, covering all actions (search, describe, install, invoke, etc.) and distinguishing it from siblings (mostly openfinance tools).

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

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

Provides explicit guidance: use this tool FIRST before external registries, explains core flow (search→describe→invoke), when to use invoke vs install, and notes permission requirements for writes.

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

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

Description matches destructiveHint annotation, explicitly stating data deletion and unavailability, and adds that a reconnection URL is returned, enhancing transparency.

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

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

Three concise, front-loaded sentences with no redundant information; each 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?

Adequate for a simple one-parameter tool with destructive annotations, but lacks parameter definition and return structure detail due to missing 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 description coverage is 0%, and the description only vaguely refers to 'a specific bank', not clarifying the 'item' parameter's format or 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 revokes Open Finance consent and deletes connection data for a specific bank, distinguishing it from sibling tools like connect or list_connections.

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

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

No guidance on when to use this tool versus alternatives; only describes the action without context for selection.

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 key behavioral traits: waits up to ~60s, returns specific fields like status, executionStatus, needs_action, timed_out. Adds value beyond annotations (readOnlyHint: false, destructiveHint: false) by explaining edge cases and outcomes.

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

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

Description is comprehensive and front-loaded with the main action, but slightly verbose. Every sentence adds value, so still 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?

Covers all necessary context: return structure, possible statuses, behaviors (timed_out, needs_action), and parameter usage. No output schema exists, but description fills the gap thoroughly.

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?

Provides rich explanation for both parameters: 'items' describes selectors and omission behavior, 'wait' explains fire-and-forget vs synchronous. With 0% schema coverage, description fully compensates.

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 specifies the verb 'forces the bank to re-sync' and the resource 'one or more connections', clearly distinguishing from sibling tools by highlighting the wait behavior and the ability to sync all or specific connections.

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

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

Explicitly states when to use ('when a balance or transaction list looks stale') and what it does ('pulls fresh data WITHOUT disconnecting/reconnecting'). Lacks explicit when-not-to-use or alternatives, 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 indicate read-only, idempotent, non-destructive behavior. The description adds that CREDIT accounts may return a Pluggy BALANCE_FETCH_ERROR with a warning instead of throwing, and describes the response shape ({ results, errors }). 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?

Two sentences: first states purpose and endpoint, second adds constraints and error handling. Every sentence carries essential information; 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?

The description covers purpose, parameter constraints, error handling, and response structure. Given the tool has one parameter and annotations, the description is fully adequate for an agent to use it correctly.

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

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

Schema has no descriptions (0% coverage), but the description adds the array type and a size constraint (1–50). It also hints at error behavior per account type, providing extra 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?

The description clearly states the tool returns a real-time balance payload per account ID, referencing the exact GET endpoint. It distinguishes from sibling tools like openfinance_get_accounts_detail or openfinance_list_accounts by focusing 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 instructs to pass account_ids as an array with a 1–50 limit and mentions special handling for CREDIT accounts. While it doesn't explicitly say when not to use this tool, the purpose is clear from the name and context.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. The description adds operational behavior: batch array size limit (1-50), response shape ({ results, errors }), 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 concise sentences that front-load the purpose and provide essential details 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?

Given the simplicity (one parameter, no nested objects, no output schema), the description covers key aspects: what is returned (full objects, extended creditData) and batch handling. Could mention error scenarios or rate limits, but is adequate.

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

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

Schema coverage is 0% for parameter descriptions. The description adds the size constraint (1-50) and hints that account_ids are IDs, but does not fully explain where to obtain them or what each string represents. Partially 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?

The description clearly states it returns full account objects with extended creditData per ID, distinguishing it from sibling tools like openfinance_list_accounts. It specifies the endpoint and batch response 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?

The description implies usage for retrieving detailed account data by ID, mentioning batch size (1-50) and response shape. It lacks explicit when-not or alternative suggestions, but the purpose is clear against siblings.

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

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

Annotations already provide readOnlyHint, destructiveHint, idempotentHint. Description adds value by detailing batch response shape ({ results, errors }) and a key behavioral nuance: payments[] typically belong to the previous bill, so presence does not indicate this bill was paid. 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 relatively long but well-structured with clear sections: what it returns, what it doesn't, how to use parameters, and a caveat. Every sentence provides useful information, though minor redundancy could be trimmed.

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

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

Given the tool's low complexity (1 parameter, no output schema) and annotations covering safety, the description is thorough. It explains return fields, parameter usage, and a critical behavioral insight about payment interpretation, leaving no major gaps.

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

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

The only parameter (bill_ids) has 0% schema coverage, but the description explains it is an array, how to pass it, and suggests using list_bills to discover IDs. This adds necessary context beyond the schema.

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

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

The description clearly states the tool returns bill-level detail for credit card bills by id, specifying included fields (financeCharges, payments) and what it does NOT return (individual transactions). It distinguishes from sibling tool 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 states when to use this tool (get bill-level detail) and when not (for individual transactions, use openfinance_list_transactions). Provides prerequisite advice (use openfinance_list_credit_card_bills first to discover ids). Also includes a notable caveat about payments[] reflecting previous bill cycle.

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 behavioral context about the return format (count/items for all banks) and that it returns status for one or all connections, 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?

Two sentences front-load the core purpose and return values, then explain parameter usage. Every sentence is necessary and informative with no redundancy.

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

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

Given no output schema, description adequately covers the return structure (status, executionStatus, connector metadata, and counter for all banks). Lacks detail on the shape of items array but sufficient for an agent to use correctly.

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

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

Schema provides no description for the 'item' parameter (0% coverage). Description fully compensates by explaining that omitting it returns all banks while passing a specific item returns a single bank's status, adding essential 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?

Description clearly states it returns the current status of a bank connection, including specific fields (status, executionStatus, connector metadata). It also explains two distinct usage modes (all banks vs single bank), which distinguishes it from sibling tools like openfinance_list_connections.

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

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

Provides explicit guidance on when to omit vs pass the 'item' parameter, indicating two clear use cases. Does not explicitly mention when not to use, but the context of siblings makes it clear this is for status, not listing or modification.

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=true, destructiveHint=false, idempotentHint=true. The description adds valuable behavioral context: the distinction between `name` and `bank`, the connector-dependent nature of credit balance, and the aggregation behavior when `item` is omitted. 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 thorough but not overly verbose; every sentence adds value. It is structured logically, starting with core output, then clarifying fields, usage, and caveats. Slightly long but warranted given 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 no output schema, the description sufficiently explains return fields and behavior. It covers usage scenarios, parameter effects, and pitfalls. The reference to openfinance_list_credit_card_bills aids completeness. Lacks explicit mention of array structure but implies it via 'aggregates into results'.

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

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

With 0% schema coverage, the description compensates well by explaining the effect of the `item` parameter (omit for all banks, pass for one) and the `type` parameter is implied through the enum values mentioned (BANK, CREDIT). Could be more explicit about the filtering function of `type`.

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 bank connections, detailing specific types (BANK, CREDIT) and fields included (balance, number, type, etc.). It distinguishes between listing all accounts (omit item) and targeting a single bank (pass item), and clarifies relationships with 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 omit vs. pass the `item` parameter, and when to use an alternative tool for standardized credit bill amounts. Also explains that the credit card balance should not be treated as 'this month's bill' due to connector-dependence.

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 readOnly, idempotent, non-destructive. Description adds caching and single aggregated response context, which is valuable but not extensive.

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

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

Concise, front-loaded purpose with subsequent details. Every sentence adds value.

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

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

Given no parameters or output schema, description is complete: explains caching, language variants, relationship to other tools.

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

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

No parameters, but description adds meaning by detailing response fields (id, description, descriptionTranslated, parentId, parentDescription) and their usage.

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

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

Description clearly states it returns Pluggy's transaction category taxonomy, cached for session, and explicitly mentions the endpoint and key fields (id, description, parentId, etc.). It distinguishes itself by linking to the 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?

Indirectly guides usage by noting it's cached and provides categoryId for openfinance_update_transaction_category. However, doesn't explicitly state when to use vs. alternatives like 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 cover readOnlyHint=true, idempotentHint=true, destructiveHint=false. Description adds field details but no additional behavioral context (e.g., rate limits, prerequisites). Adds some value but minimal 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?

Single sentence front-loads purpose and lists return fields. No wasted words, efficient and to the point.

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?

Mentions return fields including add_connection_url. No output schema, so description adequately covers what is returned. Lacks mention of pagination or edge cases, but tool is simple with no inputs.

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 input schema, so baseline is 4. Description adds nothing about parameters, but 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?

Clearly states 'Returns the saved bank connections' and lists specific fields (connector_id, item_id, bank name, add_connection_url). Distinguishes from sibling list tools like openfinance_list_accounts by focusing on connections.

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

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

Implied usage for listing bank connections, but no explicit guidance on when to use or not use this tool versus alternatives among sibling tools. No mention of prerequisites or exclusions.

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 traits; the description adds significant behavioral context: derived payment_status, misleading payments array due to cycle rules, cross-bill payment matching, opt-in behavior for open_bill, connector asymmetry causing unavailability, and warning instead of failure. 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 but well-structured: starts with main output, then complex semantics, then derived fields, then open_bill details, then connector asymmetry. It front-loads the core purpose. While it contains necessary detail for a complex domain, it could be trimmed without losing essential info, so not maximally concise.

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

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

No output schema exists, so description must be self-contained. It covers all response fields (payments array fields, payment_status derivation, open_bill object structure, future_bills, total_pending_debt, warning behavior) and addresses edge cases (past_due_unconfirmed, connector asymmetry, cycle semantics). Complete for the tool's complexity.

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

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

Schema coverage is 0%, so description must compensate. It explains account_id (required), account_ids (batch), include_open_bill (opt-in, with extra scan), and implicitly page/page_size via context. However, page and page_size are not explicitly described, which is a minor gap.

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

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

The description clearly states it returns CLOSED credit card bills for a CREDIT-type account, listing specific fields like dueDate, totalAmount, payments array, and payment_status. It distinguishes from sibling tools such as openfinance_get_credit_card_bill and openfinance_list_transactions, making its unique purpose 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?

The description provides extensive guidance: when to use (for closed bills, with opt-in for open bills), when not to use (for individual transactions), and how to interpret results (payment cycle semantics, payment_status logic). It warns about connector asymmetry and clarifies that open_bill may not be available, giving explicit context for decision-making.

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=true, idempotentHint=true, destructiveHint=false. The description adds key behavior: returns a structured fallback {total:0, results:[], warning} on 403 or other upstream errors, meaning no exception thrown. This goes beyond annotations, providing valuable safety and error-handling context.

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

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

The description is a single dense paragraph that efficiently conveys the key return details and error behavior. It could benefit from bullet points or clearer separation of parameters vs returns, but it is not overly long. Every sentence adds value, though the parameter omission is a conciseness tradeoff.

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 4 optional parameters and no output schema, the description should thoroughly explain parameter roles and return structure. It only describes return fields and error handling, ignoring parameters entirely. This leaves the agent unable to correctly set parameters like 'item', 'page', 'type', or 'page_size'. The completeness is inadequate for effective tool 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 4 parameters (item, page, type, page_size) with schema_description_coverage 0% – no descriptions. The tool description does not explain any parameter's purpose, type constraints, or usage. For example, 'type' has an enum list but not described. The description is entirely about return values, leaving the agent without guidance on how to properly invoke the tool. This is a critical gap.

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

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

The description specifies the tool returns an investment portfolio for a connection, enumerates asset types (FIIs, stocks, ETFs, etc.) and fields (balance, amount, rates, dueDate, etc.). It clearly distinguishes from siblings like openfinance_list_investment_transactions (transactions) and openfinance_list_accounts (accounts). The verb 'Returns' and resource 'investment portfolio' are specific.

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

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

The description explains the tool is for retrieving investment data when the connection has the INVESTMENTS product enabled. It notes graceful error handling (returns fallback object instead of throwing). It does not explicitly state when not to use or suggest alternatives, but the sibling list provides context. The purpose is clear enough for an agent to differentiate.

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 nondestructive. Description adds value by detailing return fields (quantity, value, expenses, etc.) and bulk execution, providing behavioral 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 paragraphs, no filler. First paragraph covers purpose and fields, second covers bulk support. Could be more structured but 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?

Provides detailed return fields but lacks explanation of pagination parameters (page, page_size) and error handling. With no output schema and 4 parameters, completeness is adequate but has gaps.

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

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

Schema coverage is 0%, so description must compensate. It explains investment_id usage implicitly but does not describe page, page_size, or investment_ids parameters in detail. Missing crucial parameter 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, listing transaction types and fields. It distinguishes from sibling openfinance_list_investments by noting the investment_id prerequisite.

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

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

Explicitly advises to use after openfinance_list_investments to get investment_id. Mentions bulk support with investment_ids. Does not explicitly state when not to use or alternatives, 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 declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds behavioral details: multiple connections are queried sequentially with rate-limit spacing, and output is structured as `{ results, errors }` per connection. 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, front-loaded with the main action, no unnecessary words. Efficient and clear.

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 list tool with one parameter and no output schema, the description covers purpose, parameter usage, behavioral quirks (sequential queries, rate-limit), and return format. 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?

The only parameter `items` is described in detail: an array of connection selectors (item_id uuid, connector_id, or connector_name). This adds significant meaning beyond the schema's bare array-of-strings definition, especially given 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 it lists loan contracts per bank connection (GET /loans). The verb 'list' and resource 'loan contracts' are specific. It distinguishes from sibling list tools by focusing on loans and indicating optional filtering by connection selectors.

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

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

The description explains when to include the `items` parameter (for specific connections) and when to omit it (for all linked banks). This provides clear usage guidance. No explicit alternatives are needed given sibling tools cover different resources.

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. The description adds substantial behavioral context: auto-pagination behavior (omit page to get all up to 5000, truncated warning), error handling (returns error object instead of throwing), CREDIT pending/posted variability by connector, and details on 'rich' and 'raw' modes. 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 verbose but well-structured with clear sections (e.g., 'PAGINATION:') and logical flow. It front-loads the primary purpose, then covers details. Minor trimming could improve brevity, but it remains readable and informative.

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 covers return fields (total, results, truncated, warning, error) and explains what each detail level adds. It addresses error handling, pagination, CREDIT-specific nuances, and cross-references to sibling tools for related information. The description is complete for a complex tool with 8 parameters.

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

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

Schema description coverage is 0%, so the description fully compensates. Each parameter is explained: from/to as ISO dates, page (omit for auto-pagination, explicit for manual), page_size (max 500), detail (enum values explained with behavior), search_queries (case-insensitive substring match, OR semantics, aggregation up to 5000). The bulk support via account_ids is also covered.

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). It distinguishes between account types and explicitly contrasts with sibling tools like openfinance_list_credit_card_bills for bill-related data and openfinance_list_accounts for statement dates. The specific verb 'list transactions' and resource 'bank account' 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 provides explicit guidance on when to use this tool vs alternatives: it notes that for CREDIT accounts this is the only way to get itemized transactions, and for overall debt totals one should use openfinance_list_credit_card_bills. It also advises when to narrow date ranges, how to check connection health, and which tools to use for specific needs (e.g., openfinance_get_item_status).

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds significant value by disclosing that the tool caps scanning at 5000 transactions per account and flags truncated:true, explains behavior when 'item' is omitted (analyzes all linked banks), and details output structure (monthly evolution, top expenses, per-account breakdown). 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 serves a purpose, providing comprehensive guidance. It is front-loaded with the core value proposition. While somewhat verbose, the complexity of the tool justifies the length. Minor structural improvements (e.g., bullet points) could enhance scanability, but overall it efficiently covers all aspects.

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 7 parameters, no output schema, and complex behavior (e.g., optional item, granularity modes, truncation), the description is remarkably complete. It explains all parameter interactions, edge cases (omitting item), output structure, and best practices. There are no gaps in understanding how 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 fully compensates. It explains each parameter: 'item' accepts connector_id, connector_name, or item_id; 'from'/'to' are ISO dates; 'granularity' defaults to 'monthly' and describes the compact summary vs raw; 'detail' options (compact/rich/raw) and their effects; 'type' filters BANK or CREDIT; 'top_n' is implied for top expenses/receipts. This adds meaning far 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 explicitly states it performs 'Consolidated cash-flow analysis for a whole bank CONNECTION over a period, in ONE call.' It clearly distinguishes from sibling tools by noting it resolves accounts internally, eliminating the need to call openfinance_list_accounts first. The specific and actionable purpose is 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 when-to-use guidance, listing use cases like 'análise anual/mensal', 'fluxo de caixa', and 'maiores gastos/recebimentos'. It also warns against unnecessary calls (e.g., not needing openfinance_list_accounts) and advises when to use granularity:'raw' only for itemized rows. This effectively directs the agent away from alternatives.

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

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

Annotations already provide readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description does not need to repeat those. It adds valuable behavioral context: it checks a public status page, returns a global indicator (none/minor/major/critical), degraded components, open incidents, and flags incidents affecting connected banks via 'your_banks_affected'. This enriches transparency 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 well-structured, beginning with the main purpose, then providing usage context, and finally listing the return fields. It is moderately concise (around 70 words) and every sentence adds value. Minor redundancy (e.g., restating 'provider-side problem') 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?

Given zero parameters, no output schema, and its role as a status-checking tool, the description provides complete context. It explains when to use the tool, what it returns (global indicator, degraded components, incidents, and connected-bank impacts), and how it differs from a sibling. No important gaps remain.

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

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

The tool has zero parameters and schema coverage is 100% (trivially). With no parameters to explain, the description's lack of parameter detail is appropriate. The baseline for zero-parameter tools is 4, and the description meets that standard by not requiring any parameter clarification.

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', with a specific verb ('checks') and resource ('provider status'). It explicitly distinguishes itself from the sibling tool 'openfinance_get_item_status', which checks your own connection's status, leaving no ambiguity about its unique role.

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 when-to-use guidance: 'whenever data looks incomplete or stale even though a connection shows UPDATED'. It also explains that it differentiates between provider-side problems and connection issues, offering a concrete alternative ('use it to tell a provider-side problem apart from a connection that just needs reconnecting').

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

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

Description adds rich behavioral detail beyond annotations: returns connector id, access type, audience, linked connections/accounts, connect_url. Explains plan-based filtering (PF hides PJ) and caveat warnings. Annotations only indicate read-only, idempotent, non-destructive.

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

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

Description is comprehensive but slightly verbose (~120 words). Front-loaded with purpose, then logically flows through return fields, caveats, plan behavior, and usage instruction. Could be tightened 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?

Despite no output schema, description comprehensively details return values and side effects (plan-based filtering, caveat, connect_url). Covers all necessary context for an AI agent to decide when and how to use the 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 compensates fully: clarifies keywords[] is required (despite schema marking optional), provides example usage, explains include_accounts effect. Also documents behavior when keyword is missing.

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

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

Description clearly states verb ('searches'), resource ('bank connectors by name'), and input ('keywords[]'). Distinguishes from sibling tools like list_connections or connect by focusing on search and providing a one-click connect_url.

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

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

Explicitly instructs to call this tool 'BEFORE connecting' and notes that keywords[] is required (returns hint otherwise). Mentions handling of caveats for non-Open-Finance connectors, guiding user to prefer Open Finance for automation.

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

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

The description reveals a critical behavioral trait not captured by annotations: recategorizing creates a Category Rule for future similar transactions. It also explains the response structure and error handling (per-item errors do not fail the whole batch). This goes well beyond the annotations (readOnlyHint false, destructiveHint false) and provides rich context for safe usage.

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 appropriately sized for the complexity but slightly lengthy. It is front-loaded with the purpose and logical structure, with no wasted words. Every sentence adds value. It could be slightly more concise, but the detail is justified given the batch and rule-creation behavior.

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

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

Given the tool's complexity (batch update, automatic rule creation, per-item errors), the description covers most essential aspects. It explains return values even without an output schema and mentions error handling. It could mention idempotency or conflict handling, but overall it is sufficiently complete for an AI agent to 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%, but the description fully compensates by explaining the structure of the `items` parameter (array of objects with transaction_id and category_id), where the IDs come from, and the response shape (updated, results, errors). This adds significant meaning beyond the raw JSON schema, making parameter semantics excellent.

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

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

The description clearly states the tool corrects the category of one or more transactions, specifies the PATCH method and endpoint, and distinguishes itself by referencing sibling tools (openfinance_list_transactions, openfinance_list_categories). It explains the effect (overrides automatic categorization and teaches Pluggy), making the purpose specific and unambiguous.

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

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

The description provides explicit guidance on when to use the tool (fix miscategorized transactions, improve future categorization) and what prerequisites are needed (transaction_id and category_id from other tools). It also explains batch error handling. While it doesn't explicitly state when not to use it, the context is clear enough for an AI agent to decide.

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

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

The description adds context about including conversation data for reproduction, complementing the annotations (idempotent=true, non-destructive). No contradictions or missing critical behaviors.

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 with no waste. The first sentence delivers the purpose, the second provides guidance. 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?

The description covers the essential use case for a bug report tool, including reproduction instructions. No return value or confirmation details, but sufficient for the simple action.

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

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

With 0% schema description coverage, the description explains the 'conversation' and 'message' parameters, but the 'context' parameter remains unexplained. This partially compensates for the schema gap.

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

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

The description clearly states the tool's purpose: reporting bugs, missing features, or sending feedback. It differentiates from sibling tools like OpenFinance operations or authentication by specifying this feedback role.

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 tells to include the conversation array for reproduction, giving clear usage context. It doesn't explicitly exclude alternatives but implies the intended scenario.

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. The description adds the detail about showing platform and adapter versions, but does not provide additional behavioral traits beyond what annotations convey. It does not contradict annotations.

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

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

The description is a single sentence that is front-loaded with the verb and noun, containing no superfluous words. 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?

Given the tool has no parameters, no output schema, and is a simple info retrieval operation, the description provides complete context. No additional information is necessary.

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

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

There are zero parameters, so the baseline is 4. The schema covers 100% (empty), and the description naturally does not need to add parameter information.

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

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

The description uses a specific verb ('Show') and explicitly names the resources ('MCP platform and adapter versions'). It clearly distinguishes itself from sibling tools like authenticate, connect, 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 this tool vs alternatives. However, given its purpose is self-evident and it's a standalone query tool, the lack of guidelines is not critical but still reduces the score from a potential 4.

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 readOnly, idempotent, non-destructive, and closed-world hints. The description adds specific return content (installed MCPs, connection status, counts) that 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 a single, well-structured sentence that conveys all necessary information without unnecessary words. It is front-loaded and concise.

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

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

For a status tool with no output schema, the description provides specific expected return elements (installed MCPs, connection status, catalog tool counts). It sufficiently informs the agent of the tool's output without overpromising.

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

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

The tool has 0 parameters and schema coverage is 100% (empty schema). The description naturally has no parameter info to add, and the baseline for 0 parameters is 4.

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

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

The description clearly states the tool returns 'the current toolkit state' including specific components like installed MCPs, connection status, and catalog tool counts. It uniquely identifies the tool among siblings that perform specific 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 status checks but provides no explicit direction on when to use versus alternatives. No 'when-not' or exclusion criteria are given.

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