Necton MCP

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

The description explains the behavior beyond annotations: idempotent, session vs permanent, and how to get the token. No contradiction with annotations. It adds value by explaining the browser 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?

The description is slightly verbose but well-structured, front-loading the purpose and then detailing usage. All sentences add value, though it could be tightened slightly.

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 authentication tool with one parameter and no output schema, the description is complete. It explains the two modes and the source of the token. Missing explicit return value description, but the 'get the link' implies the output.

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

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

Despite 0% schema coverage, the description explains the 'token' parameter well: it's a JWT from browser login. It also explains the no-arg case for getting the link. Compensates adequately for lacking 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 the tool's purpose: authenticating for IDE agents. It specifies the verb 'authenticate' and the resource 'user authentication'. It differentiates from siblings by being the only authentication tool.

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

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

Provides explicit guidance on when to use, including two clear scenarios: permanent via config or session-only via token. Tells the agent exactly how to invoke it with or without arguments.

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; description adds behavioral context about returned data depending on connection state, which goes beyond annotations.

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

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

Two sentences with front-loaded main purpose and concise details; 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?

For a simple status check tool with no parameters, the description covers both possible outcomes and is complete enough.

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

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

No parameters exist and schema coverage is 100%; description is not required to explain parameters, baseline 4 is appropriate.

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

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

The description clearly states the tool returns connection status and URLs, and distinguishes it from siblings like 'authenticate' or 'openfinance_list_connections' by focusing on overall 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 context on when to use (checking connection status) and describes different states, but does not explicitly mention alternatives or when not to use.

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

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

The description discloses critical behaviors not captured by annotations: invoke works without installation, returns connect/checkout links on auth/payment issues, and install/writes require owner/admin. It also explains the different installed statuses flagged by search/describe. 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 about 200 words in a single dense paragraph. While front-loaded with purpose, it lacks structured formatting (e.g., bullets or sections) and could be more concise. It is adequate but not optimally scannable.

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 the complexity (13 parameters, 10 actions, no output schema), the description covers the main workflow, edge cases (auth, payment), and different usage scenarios. It is comprehensive enough for an agent to understand the tool's role and usage, though parameter details are lacking.

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 schema coverage at 0%, the description does not detail all 13 parameters (e.g., limit, message, immediate, tier_slug, conversation, etc.). However, it explains the core parameters (action, query, mcp_id, tool_id, arguments) through the workflow description. This provides partial compensation but leaves many parameters undocumented, barely meeting baseline.

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 as 'THE official mcp.ai marketplace' and its dual role as catalog and runner of MCPs/tools. It specifies the core flow (search->describe->invoke) and distinguishes itself from sibling tools like the openfinance series, which are separate domain-specific tools.

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

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

The description explicitly instructs to use this tool FIRST for any capability need, before external registries. It provides clear when-to-use guidance for each action (invoke vs install, use install only for permanent addition, prefer invoke for one-off use) and mentions prerequisites like workspace owner/admin for write actions.

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 clarity by stating that bank data will no longer be available and that an add_connection_url is returned for reconnection. This adds value 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 concise (three sentences) with no redundancy. It front-loads the action and consequence, and each sentence serves a clear purpose: action, effect, and return 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 one-parameter destructive tool with no output schema, the description covers the effect and return value adequately. It does not specify the input format, but overall it is complete enough for an agent to understand the tool's purpose and outcome.

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 one parameter 'item' (string, required) with no description. The description only says 'for a specific bank', which gives a hint but does not specify what format or type of identifier is expected. Schema coverage is 0%, and the description insufficiently 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?

The description uses specific verbs ('revokes', 'deletes') and clearly identifies the resource ('bank connection'). It distinguishes from sibling tools like openfinance_get_item_status or openfinance_list_connections by describing a destructive action with clear consequences.

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) but does not explicitly compare with alternatives or give guidance on when not to use it. It lacks explicit usage context relative to other 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?

Describes the polling behavior up to ~60s, return fields like status, executionStatus, lastUpdatedAt, synced, needs_action, timed_out. Annotations are minimal but description fully covers behavioral traits without contradiction.

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

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

The description is dense but well-structured, covering purpose, usage, parameters, and return values. Slightly long but every sentence serves a purpose. A bit more conciseness could be achieved, but it remains 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?

With no output schema, the description fully explains the return object with all relevant fields and edge cases (needs_action, timed_out). Covers usage patterns and behavior comprehensively.

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

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

Despite 0% schema coverage, the description thoroughly explains both parameters: wait (boolean for sync mode) and items (array of selectors, can be omitted to sync all). Adds 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 the tool forces re-sync of connections and waits for completion, distinguishing it from sibling tools like openfinance_get_item_status. It specifies the action (force sync), the resource (connections), and the synchronous nature.

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

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

Explicitly tells when to use the tool (stale balance/transactions) and when not to (no need to disconnect/reconnect). Provides alternative configurations like wait: false for fire-and-forget, and mentions sibling tool for re-checking if timed out.

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 real-time nature and structured error handling for credit accounts, going beyond annotations.

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

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

Three concise sentences: purpose, input constraints, behavior, response. No fluff, front-loaded with key information.

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

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

For a single-param tool with no output schema, description covers input, error handling, and response format. Agent has enough 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 has 0% coverage, but description explains the 'account_ids' parameter (array, 1-50 items) and response shape, adding 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 the tool returns real-time balance for account IDs, specifying the endpoint and input format. Distinguishes from siblings like list/detail 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 input constraints (array of 1-50 IDs) and behavior for credit accounts (warning instead of error). Lacks explicit alternatives but context from siblings implies differentiation.

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

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

Annotations already indicate read-only and idempotent behavior. The description adds value by disclosing the batch response shape (`{ results, errors }`), array size limit (1-50), and that it includes extended creditData, which goes beyond annotation hints.

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 only two sentences, with no filler. It front-loads the purpose and follows with usage details, making it efficient and easy to parse.

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

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

Given the tool's simplicity (one parameter, no output schema), the description covers the main aspects: return shape, parameter format, and included data. It lacks details on error handling or validation, but for a batch get, it is reasonably complete.

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

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

The input schema only names the parameter without description. The description adds that `account_ids` is an array of strings with a size constraint (1–50) and implies it corresponds to specific account IDs. Schema coverage is 0%, so the description compensates well.

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

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

The description clearly states the tool returns full account objects including extended creditData per ID, with a batch shape. It differentiates from sibling tools like openfinance_list_accounts by specifying per-ID detail and batch processing.

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

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

The description implies use for detailed account retrieval by ID but does not explicitly state when to choose this over openfinance_list_accounts or other siblings. No exclusion 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.

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

Beyond annotations (readOnlyHint:true, idempotentHint:true, destructiveHint:false), the description adds critical behavioral traits: the batch response shape `{ results, errors }`, the absence of a paid/status field due to Pluggy limitations, the fact that `payments[]` reflects payments from the previous bill cycle, and the workaround using openfinance_list_credit_card_bills to derive payment_status. These are valuable context not captured by annotations.

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

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

The description is long but every sentence adds value, with front-loaded purpose and logical progression: what it returns, what it doesn't, when to use alternatives, how to use it, and caveats. No redundant or vague statements.

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 simple input schema (one parameter) and lack of output schema, the description provides full context: return fields, batch shape, relationship to sibling tools, important behavioral caveats (paid status, payment cycle interpretation), and a troubleshooting pathway for payment status. It covers all necessary information for correct usage.

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

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

The parameter `bill_ids` is defined in the schema only as a required array of strings. The description adds meaning by explaining how to obtain valid IDs (via openfinance_list_credit_card_bills) and the batch nature. While this compensates for the 0% schema description coverage, the description could be slightly more precise about ID format or examples, so it is not a full 5.

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, enumerates fields (financeCharges, payments with subfields), and explicitly distinguishes itself from the sibling tool openfinance_list_transactions by stating it does NOT return individual transactions. This provides a specific verb and resource.

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

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

The description explicitly provides when-to-use guidance (e.g., 'use openfinance_list_credit_card_bills first to discover ids') and when-not-to-use alternatives (e.g., 'to get itemized credit card transactions ... use openfinance_list_transactions'). It also includes contextual notes about batch shape and the limitation of the paid/status field.

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 mark it as read-only and idempotent. The description adds specific information about the returned statuses, executionStatus, and connector metadata, providing useful behavioral context beyond the annotations.

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

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

Two sentences, front-loaded with purpose, no unnecessary words. Every sentence is informative and earns its place.

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

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

With no output schema, the description adequately describes return values (statuses, executionStatus, connector metadata for single; `{ count, items }` for list). Complete enough for an agent to understand inputs and outputs.

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 one parameter with 0% coverage, but the description fully explains its meaning (optional bank identifier) and how omitting it changes behavior. This adds essential semantic value.

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

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

The description clearly states the tool returns the current status of a bank connection, listing specific status values and explaining the dual behavior (single vs all banks). It distinguishes itself among siblings by focusing on status 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?

Explicitly tells when to omit or pass the `item` parameter to get all or single bank status. No mention of when not to use this tool vs. alternatives like `openfinance_list_connections`, but the context is clear.

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

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

Annotations already indicate readOnly, idempotent, non-destructive. The description adds critical behavioral details: the 'bank' field vs 'name', the aggregation behavior when omitting 'item', and the connector-dependent meaning of 'balance' for CREDIT accounts, which goes beyond annotations.

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

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

The description is somewhat long but well-structured, with the main purpose front-loaded, followed by usage guidance and caveats. Each sentence adds value, and the length is justified given the complexity of the tool's 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 has no output schema and only 2 params, the description covers response fields, behavioral nuances, and references a relevant sibling tool. It is fully sufficient for an agent to understand when and 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?

With 0% schema description coverage, the description fully explains 'item' (optional, aggregates if omitted) and 'type' (BANK/CREDIT). The enum for 'type' is clear, and the description adds meaning to 'item' beyond the schema's type-only definition.

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) and lists fields. It distinguishes from siblings by focusing on accounts and providing distinct usage patterns.

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 guides when to omit 'item' (all banks) vs. pass it (single bank). It also warns about the connector-dependent meaning of credit card balance and directs to another tool for standardized bill amounts, providing clear context for 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 provide readOnlyHint, idempotentHint, and destructiveHint. The description adds value by detailing caching behavior (adapter session), structure of entries (id, description, parentId, etc.), and that there are no batch ids. No contradictions with annotations.

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

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

The description is concise (two sentences) and front-loaded with the main purpose. It includes necessary details about the output structure without being verbose. Slightly less concise due to listing field names, but still 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 no input parameters and no output schema, the description provides ample context: it explains caching, the single aggregated response, and the fields in each entry. This fully informs an AI agent of what to expect and how to use the output with sibling 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?

The input schema is empty (0 parameters). With zero parameters, the baseline is 4. The description does not add parameter information because there are none, so no additional value needed.

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

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

The description clearly states the tool returns Pluggy's transaction category taxonomy, cached for the session. It explicitly maps to GET /categories and distinguishes itself from sibling tools by focusing on categories, with a specific reference to how its output is used by openfinance_update_transaction_category.

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 indicates this tool is used to retrieve categories for updating transactions (referencing openfinance_update_transaction_category). It mentions caching and that it's a single aggregated response. While it doesn't explicitly exclude other uses, it provides clear context for its typical use case.

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 value by specifying the returned fields (connector_id, item_id, bank name, add_connection_url) and stating it applies to 'this install,' which is useful behavior 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 front-loads the core action and result. Every part is necessary and no words are wasted.

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

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

With no input parameters and no output schema, the description adequately covers the return data and purpose. However, it lacks details about potential edge cases (e.g., empty list, pagination), but given the simplicity of the tool, this is acceptable.

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

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

There are no parameters, and schema coverage is 100% (empty). The description does not need to add parameter information, so a baseline of 4 is appropriate.

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

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

The description uses a specific verb ('Returns') and clearly identifies the resource ('saved bank connections'), listing key fields. It differentiates from sibling list tools like openfinance_list_accounts or openfinance_list_transactions 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?

The description explains what the tool does but does not explicitly state when to use it versus alternatives, nor does it include exclusions or prerequisites. Context from sibling names helps, but the description alone lacks direct guidance.

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

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

The description adds significant behavioral context beyond annotations, including the absence of a paid/status field, payment cycle logic, derived payment_status, open bill derivation details, connector asymmetry for open bill availability, and that the tool returns a warning instead of failing. Annotations already declare readOnlyHint, so no contradiction.

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

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

The description is well-structured with paragraphs and important notes highlighted. It is front-loaded with the core return value. However, it is verbose and could be slightly more concise while retaining all necessary details. Each sentence contributes value, but length is a minor drawback.

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 the tool, the lack of output schema, and 0% schema description coverage, the description is remarkably complete. It covers derived fields, edge cases in payment status, open bill availability, connector asymmetry, and fallback behavior. It also explains how to use the output and when to expect warnings.

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%, meaning parameters are not explained in the schema. The description explains include_open_bill and account_ids (bulk support), but does not describe page, page_size, or the required account_id explicitly. Account_id is implied as the credit account, and pagination parameters are common. Some added value, but not fully compensating for low 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 returns CLOSED credit card bills for a CREDIT-type account, with specific fields listed. It distinguishes from sibling tools like openfinance_get_credit_card_bill and openfinance_list_transactions, explaining that this tool provides bill-level summaries and not itemized transactions.

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

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

Explicit guidance is provided: when to use include_open_bill, when to use openfinance_list_transactions for itemized purchases, and a warning about connector asymmetry. It also clarifies that the tool returns a warning if the product is not enabled, and the open bill opt-in is a performance consideration.

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 and destructiveHint=false. The description adds behavioral context: it returns a structured response with warning instead of throwing on 403, and lists the fields included. This adds value 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 informative sentence that front-loads the purpose and lists fields efficiently. No wasted words, but slightly dense. Could be split for readability.

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

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

With no output schema, the description compensates with field details and error handling. However, it omits pagination behavior despite having page and page_size parameters, leaving a gap in completeness for a listing 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 description coverage is 0% and the description does not explain any of the 4 parameters (item, page, type, page_size). The description only details return fields, leaving parameter meaning entirely to the schema names and enum values.

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

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

The description clearly states it returns the investment portfolio for a connection, listing specific asset types and fields. The verb 'Returns' is appropriate and the resource is well-defined (investment portfolio). It distinguishes from sibling tools like openfinance_list_accounts by focusing on investments.

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

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

The description implies usage for retrieving investment data but does not explicitly contrast with other list tools. It mentions error handling when the feature isn't enabled, but no direct when-not or alternative tool guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. Description adds detail on response fields (expenses, rates) but no additional behavioral traits. 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 short paragraphs, front-loaded with purpose, then details. No redundant information.

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

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

Given no output schema and 0% schema parameter description, the description provides good output field details but lacks pagination parameter documentation. Adequate but not fully 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?

Explains investment_id and investment_ids (bulk) but does not mention page or page_size. Schema coverage is 0%, so description partially compensates but leaves 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?

Clearly states it returns movement history for a specific investment position, listing transaction types (BUY/SELL/TAX/etc.). Distinguishes from sibling openfinance_list_investments which lists investments.

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

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

Explicitly says 'Use after openfinance_list_investments to get the investment_id' and mentions bulk support. No when-not guidance, but adequate for the tool's simplicity.

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 valuable context: sequential queries with rate-limit spacing, return structure { 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?

Four sentences, front-loaded with purpose. Each sentence adds unique value: action, parameter details, omission behavior, return format. 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?

Tool is simple (1 optional param, no output schema). Description covers param semantics, sequential execution, error handling hints, and batch behavior. Fully sufficient given context signals.

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). Descriptions fully compensate by explaining items as 'array of connection selectors (item_id, connector_id, or connector_name)' and behavior when omitted. Adds 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?

The description explicitly states 'Lists loan contracts per bank connection (GET /loans)', providing a specific verb and resource. It distinguishes from sibling tools by detailing the items parameter for per-connection filtering and the option to list all 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?

Clear instructions on using the items parameter (array of selectors, rate-limit spacing) and omitting it for all banks. No explicit guidance on when not to use this tool vs. alternatives like list_accounts or list_transactions, leaving some ambiguity.

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, destructiveHint=false. Description adds critical behavioral details: PENDING vs POSTED variance by connector, bulk support, error handling with warning/error, and aggregate behavior for search_queries.

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?

Long but each sentence adds unique value. Could be slightly more compact, but no redundancy. Front-loaded with core purpose and usage guidance.

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

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

Given 7 parameters, no output schema, and complex behavior (connector variance, bulk, error handling), the description fully equips the agent to use the tool correctly. No missing guidance.

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 description compensates thoroughly: explains from/to as ISO YYYY-MM-DD, page_size max 500, search_queries as case-insensitive substring OR match, aggregate up to 5000, and bulk via account_ids.

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 transactions for bank/credit accounts. Differentiates from sibling tools like openfinance_list_credit_card_bills by explaining that credit card transactions are itemized and linked to bills via creditCardMetadata.billId.

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 context: when to use for credit cards vs bank accounts, alternative for standardized totals (openfinance_list_credit_card_bills), date filter format, pagination limits, keyword filter behavior, and troubleshooting when total is 0.

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 annotations already indicate read-only and idempotent behavior. The description adds rich behavioral details: internal account resolution and fan-out, compact vs. raw output, default monthly aggregation, truncation with a flag, filtering by account type, and the specific fields returned (e.g., top_despesas, por_mes). No contradictions.

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

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

The description is a single dense paragraph but well-organized: starts with core purpose, then explains workflow, parameter details, use cases, and edge cases. While every sentence earns its place, it could be slightly more structured (e.g., bullet-like formatting) for easier scanning by 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?

The description is highly complete given the complexity: no output schema, but it details the return structure (entradas, saídas, por_mes, top_despesas, by_account, etc.) and truncation behavior. It also covers optional parameters and default behaviors, making this tool fully understandable without 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?

The description thoroughly explains all 6 parameters despite 0% schema coverage: ISO date format for from/to, accepted values for item (connector_id, connector_name, item_id), enum options for type and granularity, and the purpose of top_n (controls largest N in top lists). It also clarifies default behavior for granularity and the effect of omitting item.

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 performs consolidated cash-flow analysis for bank connections in one call, and explicitly distinguishes it from sibling tools like openfinance_list_accounts by noting it resolves accounts internally. It provides specific use-case phrases (e.g., 'fluxo de caixa', 'maiores gastos/recebimentos') and contrasts with openfinance_list_transactions via the granularity parameter.

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: 'Use this for 'análise anual/mensal', 'fluxo de caixa', etc.' It also explains when not to use it (if itemized rows are needed, set granularity to raw) and provides alternatives like omitting the item parameter to analyze all linked banks. The truncation behavior at 5000 transactions per account is also noted.

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, so safety is clear. The description adds valuable behavioral context: it returns a global indicator, degraded components, open incidents, and flags incidents affecting connected banks. No contradiction with annotations.

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

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

The description is a single paragraph of about 4-5 sentences, front-loaded with purpose. Every sentence adds value, but it could be slightly more concise by combining some clauses. Still, it is well-structured and not overly long.

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 input parameters and no output schema, the description covers what the tool does, when to use it, and what it returns. It is complete for this simple status-check tool, including the useful detail about the 'your_banks_affected' field.

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 baseline is 4 per the rubric. The description does not need to add parameter information; it focuses on the return value and usage context, which is appropriate.

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

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

The description clearly states it checks the LIVE operational status of the Open Finance provider, distinguishing it from the sibling tool openfinance_get_item_status which checks connection status. The verb 'checks' and resource 'provider status' are specific and unambiguous.

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

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

The description explicitly tells when to use this tool: when data looks incomplete or stale even after a connection shows UPDATED. It contrasts with the sibling tool and explains the diagnostic value—telling provider-side problems apart from connection issues.

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

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

Disclosure beyond annotations: keywords required behavior (returns hint if omitted), never dumps whole catalog, plan filtering, and includes connect_url. Annotations already indicate readOnly/idempotent, so description adds context without contradiction.

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

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

Two sentences convey action, usage, output, and constraints. Information-dense but could be slightly more concise; still well-structured and front-loaded.

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

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

No output schema exists, but description covers return fields (id, access, audience, connections, accounts, connect_url) and plan filtering. Lacks error handling details but is adequate for a search tool.

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

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

With 0% schema description coverage, description fully explains both parameters: keywords (array of strings, required behavior) and include_accounts (boolean effect). Also clarifies required behavior despite schema marking optional.

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?

Specifies exact verb ('Searches') and resource ('bank connectors'), differentiates from sibling tools like 'openfinance_list_connections' by focusing on catalog search. Provides example usage and output fields.

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

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

Explicitly states when to use ('BEFORE connecting'), what it returns (one-click link), and that keywords are required. Also notes plan-based filtering (PF hides PJ banks), guiding appropriate usage.

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

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

Beyond annotations (readOnlyHint=false, destructiveHint=false), the description discloses that recategorizing creates a persistent Category Rule, explains batch error handling ('per-item errors do not fail the whole batch'), and describes the return shape. This adds significant behavioral context.

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

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

Every sentence adds value. The description is well-organized: purpose, parameter explanation, side effect, and return shape. No redundancy, and it is front-loaded with the core 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?

Given no output schema, the description thoroughly covers return shape and batch behavior. It explains parameter sources and side effects. Minor omissions include input validation details, but overall complete for a mutation tool.

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

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

Schema coverage is 0%, but the description explains the structure of the single parameter `items` (array of objects with transaction_id and category_id) and where to obtain the IDs. It does not document ID formats or validation constraints, but the explanation compensates well.

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

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

The description clearly states the action: 'Corrects the category of one or more transactions' with the HTTP method and path. It distinguishes from sibling tools like openfinance_list_transactions and openfinance_list_categories by focusing on updating rather than retrieving.

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: 'fix miscategorized transactions' and provides the source of IDs from sibling tools. It explains the side effect of creating a Category Rule, but does not explicitly state when not to use it.

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

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

Annotations indicate idempotentHint true and destructiveHint false, but the description adds no behavioral context beyond asking for conversation. No disclosure of what happens upon submission or side effects.

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

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

Two concise sentences, front-loaded with the core action. No extraneous information, though it could be slightly more detailed.

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 lack of output schema and parameter descriptions, the description is incomplete. An agent would miss details about parameter semantics and the return type.

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

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

Schema coverage is 0%, and the description only clarifies the 'conversation' parameter. The 'context' and 'message' parameters remain unexplained, leaving ambiguity about their use.

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

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

The description clearly specifies the tool's purpose: reporting bugs, missing features, or sending feedback. It distinguishes itself from sibling tools which are primarily for banking 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?

No explicit when to use or alternatives provided. It only mentions including the conversation array, but lacks guidance on when this tool is appropriate versus other actions.

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 no additional behavioral context beyond what annotations provide, meriting a baseline score.

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, concise sentence that conveys the tool's purpose with no 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 read-only tool with no parameters, the description is complete enough. However, it lacks mention of the return format, which could be helpful.

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 the description does not need to add parameter meaning. Baseline score of 4 is appropriate.

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

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

The description clearly states the tool's purpose with a specific verb ('Show') and resource ('MCP platform and adapter versions'). It is distinct from sibling tools, none of which provide version information.

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 clearly implies when to use (to check versions) but does not explicitly mention when not to or provide alternatives. Given the tool's simplicity, this is adequate.

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

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

Annotations already signal readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds specific context about what the tool returns (installed MCPs, connection status, catalog exposure count), providing behavioral details 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, front-loaded sentence that immediately conveys the tool's purpose and scope. Every word adds value with no redundancy.

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

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

Given no output schema, the description fully explains the return value: installed MCPs, connection status, and catalog tool counts. This is complete for a zero-parameter read-only info tool.

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

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

The input schema has no parameters, so the description does not need to add parameter semantics. Baseline 4 applies as there is nothing to compensate for.

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 exactly what is returned (installed MCPs, connection status, catalog tools count). This distinguishes it from sibling tools like show_version, which returns version info, and operational tools.

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

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

The description does not explicitly state when or when not to use this tool versus alternatives. However, the purpose is clear and the sibling list implies differentiation. For a simple info tool with no parameters, implicit usage is acceptable but not explicit.

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