EQI MCP

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

The description discloses behavior beyond annotations: it explains that the config-based method yields a non-expiring connection, while token-based is session-only. Annotations indicate idempotentHint=true, which matches the description's implication that calling with no args gets a link (no side effects). 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 two sentences, front-loaded with purpose and audience, and efficiently conveys multiple usage modes. It could be slightly more concise but is well-structured.

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

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

Given one optional parameter, no output schema, and annotations covering idempotency and non-destructiveness, the description provides complete context for using the tool correctly. It covers all behavioral aspects needed for an agent to select and invoke it.

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 optional string parameter 'token' with no description. The description adds meaning by explaining that passing a token performs session-only login, and that calling with no args returns a login link. This compensates for the 0% schema description 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 what the tool does: handles authentication for IDE agents like Cursor, providing options for permanent or session-only login. It distinguishes itself from sibling tools, none of which are authentication-related.

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 three distinct usage scenarios: for permanent connection (add to config), for session-only login (pass token), and to get the login link (no args). While it doesn't explicitly state when not to use it, the guidance is clear and actionable.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds behavioral details about the return values (authenticated:true vs. connect_url) and conditions, enhancing 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 with no wasted words. The key purpose is front-loaded, and the explanation of output states is concise yet complete.

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 values and their meanings based on connection state. No gaps remain for a parameterless tool.

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

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

No parameters exist, and schema coverage is 100%. The description doesn't need to add parameter semantics, but it compensates by explaining the tool's output, which is the sole focus.

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, using a specific verb and resource. It distinguishes itself from sibling tools like authenticate by focusing on status retrieval rather than initiating 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 the output in two states (all providers connected vs. missing credentials), providing clear context. While it doesn't explicitly state when to use this tool over alternatives, the context implies use for checking connection 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?

Beyond annotations (readOnlyHint=false, etc.), the description adds rich behavioral context: invoke works without installation, returns connect/checkout links for credentials/insufficient wallet, and notes that write operations require owner/admin. No contradiction with annotations exists.

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

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

The description is well-structured, starting with the tool's identity and then detailing the core flow. It front-loads critical information and uses sentence breaks for readability. However, it is somewhat verbose and could be trimmed for conciseness without losing essential details.

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 parameters, no output schema), the description covers the main usage patterns, edge cases (connect/checkout), and permissions. It lacks details on return values and parameter constraints, but the comprehensive explanation of actions and workflows largely compensates. A bit more on outputs would improve completeness.

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

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

Schema coverage is 0%, so the description must compensate. It explains the action enum and indirectly covers parameters like mcp_id, tool_id, arguments by describing the search→describe→invoke workflow. However, it does not explicitly define each parameter's meaning, format, or defaults (e.g., limit, immediate, tier_slug). The explanation is adequate for basic usage but incomplete.

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

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

The description clearly identifies the tool as the official mcp.ai marketplace for discovering and running MCPs. It distinguishes from sibling tools by stating it is the primary tool to use before external registries. It enumerates specific actions and their roles, establishing a clear verb-resource relationship.

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: 'use THIS tool FIRST' for user capability requests. It explains the core flow (search→describe→invoke) and differentiates between invoke (one-off, no installation) and install (permanent addition). It also covers prerequisites like workspace owner/admin for write actions and fallback actions like report_bug and request_mcp.

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?

Matches destructiveHint and adds detail: data no longer available, returns add_connection_url. 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 concise sentences, no unnecessary words, front-loaded with key action and consequences.

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?

Describes effect and return value, but lacks parameter detail. With no output schema, could benefit from clarifying 'item' and if any side effects exist.

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

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

Single 'item' parameter with no schema description and no explanation in the description. Agent cannot know what value to provide.

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

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

Clear verb 'revokes' and resources 'consent' and 'connection data'. Distinct from siblings like connect and 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?

States when to use (to disconnect a bank) and mentions reconnection URL, but lacks explicit 'when not to use' or 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 indicate non-read-only, non-destructive, non-idempotent. The description adds details: wait up to 60s, returns status/executionStatus/lastUpdatedAt/synced, handles errors like LOGIN_ERROR, and specifies timed_out behavior. 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 150 words, front-loaded with the key action. It is comprehensive but could be slightly more concise. However, every sentence adds value, so it remains efficient.

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

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

Given no output schema, the description fully describes return structure (results, errors, fields). It covers when to use, parameter details, error states, and alternative tools. No gaps for a tool of this 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 has 0% description coverage. The description fully explains both params: items accepts selectors (item_id, connector_id, connector_name) or omitted for all banks; wait controls synchronous vs fire-and-forget behavior. This adds critical meaning beyond the schema.

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

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

The description clearly states the tool forces a bank to re-sync connections and waits for completion. It specifies the action (PATCH /items/:id then polls), distinguishes from siblings like openfinance_get_item_status, and covers both single and bulk sync.

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

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

The description explicitly advises using this when balances are stale, explains it pulls fresh data without disconnecting, provides alternative (openfinance_get_item_status) for timed-out results, and gives a fire-and-forget option with wait:false.

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

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

Description adds important behavioral context beyond annotations: credit accounts may return a BALANCE_FETCH_ERROR with a warning instead of throwing, and the response shape is detailed. Annotations already indicate read-only and idempotent, which is consistent.

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

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

Three sentences cover purpose, parameter usage, error behavior, and response shape. No wasted words; front-loaded with the most critical information.

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

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

For a simple single-parameter tool, the description covers all necessary context: what it does, how to call it, error handling details, and response format. No output schema exists, so the response shape description fills that gap.

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

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

With 0% schema description coverage, the description compensates by stating the parameter is an array of account IDs and has a size constraint of 1-50, adding meaning beyond the schema's bare type 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?

Description clearly states the tool returns real-time balance per account ID, includes the endpoint, and specifies the array parameter. The purpose is unambiguous and 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?

Provides usage guidance for the parameter (array of 1-50 items) but no explicit guidance on when to use this tool versus sibling tools like openfinance_get_accounts_detail or openfinance_list_accounts for balances.

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 valuable context: extended creditData, batch shape {results, errors}, and the endpoint. No contradictions.

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

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

Three sentences cover purpose, parameter usage, and return format. Every sentence adds value with zero redundancy. Highly 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?

Covers purpose, parameter, and return shape adequately given no output schema. Could mention error handling or rate limit implications, but for a batch read tool it 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?

Schema description coverage is 0%, but description adds meaning: 'Pass account_ids as an array (1–50)' clarifies array type and size constraint, plus the return shape implies the parameter's role. Compensates for schema's lack of documentation.

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

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

Clearly states it returns full account objects with extended creditData per id, distinguishing it from openfinance_list_accounts which likely returns a list without details. Mentions the HTTP endpoint GET /accounts/:id.

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

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

Provides parameter constraints (array size 1-50) and return shape, but does not explicitly state when to use this tool versus alternatives like openfinance_list_accounts or other detail tools. Adequate but lacks explicit usage 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 indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds significant behavioral context: the absence of a paid/status field, the meaning of payments[] (previous bill's payment), and the batch shape { results, errors }. This goes beyond annotations, providing critical domain-specific nuance.

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

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

The description is well-structured, starting with the core purpose and then adding important details. While it is comprehensive and every sentence is valuable, it is slightly verbose for a simple tool with one parameter. Still, given the domain complexity, it strikes a good balance.

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 shape ({ results, errors }) and the fields included. It also clarifies edge cases (payments[] behavior, non-return of status). The tool has only one parameter, and all necessary context is provided, making it complete for an AI 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?

The schema has 0% description coverage for the sole parameter bill_ids. The description fully compensates by explaining that it must be passed as an array and that IDs are discovered via openfinance_list_credit_card_bills, adding essential semantic meaning beyond the raw schema.

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

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

The description clearly states the tool returns bill-level detail for credit card bills by ID. It specifies the exact fields (financeCharges, payments with subfields) and explicitly mentions what it does NOT return (individual transactions). It distinguishes itself from sibling tools like openfinance_list_transactions and openfinance_list_credit_card_bills, making the purpose unambiguous.

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

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

The description provides explicit guidance: when to use (to get bill detail), when not to (use openfinance_list_transactions for itemized transactions), and prerequisites (use openfinance_list_credit_card_bills to discover IDs). It also warns about the semantics of payments[] and paid status, preventing misuse.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering safety. Description adds value by detailing return fields and the all-or-single behavior. 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, no fluff. First sentence states purpose and possible values; second explains parameter usage. 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?

No output schema exists, but description gives return shapes ({ count, items } for all, status fields for single). Could clarify that 'item' refers to a bank connection ID, but overall adequate for a simple read tool with one optional parameter.

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

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

The schema has zero coverage for the 'item' parameter. The description fully compensates by explaining that omitting it returns all banks and passing it returns a single bank, with example response structures.

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

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

The description clearly states it returns the status of a bank connection with specific fields (UPDATED, UPDATING, etc.) and explains two usage modes (all banks vs single bank). It distinguishes from sibling tools like openfinance_list_connections by focusing on status and execution details.

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

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

Provides explicit guidance on when to omit or pass the 'item' parameter, but does not mention when to prefer an alternative sibling tool (e.g., openfinance_list_connections) or when not to use this tool.

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

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

Beyond annotations (readOnlyHint, idempotentHint, destructiveHint), the description reveals behavior such as aggregation across connections when `item` is omitted, and the connector-dependent meaning of credit card `balance`.

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 somewhat lengthy; however, every sentence adds value. It is front-loaded with the core purpose and structured to guide usage. Could be slightly more concise but justified by 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, including nuances like `bank` vs `name`, and credit card `balance` interpretation. It also references the sibling tool for advanced bill reporting, covering both usage scenarios.

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 both parameters: `item` (omit vs pass) and `type` (filter by enum). It also adds meaning to return fields like `bank` vs `name`.

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, distinguishing BANK and CREDIT types and listing specific fields. It differentiates from sibling tools like openfinance_list_credit_card_bills by explaining when to use each.

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 provides when to omit `item` (list all linked banks) vs pass `item` (single bank). Also warns against misinterpreting `balance` for credit cards and directs to the appropriate tool for standardized bill amounts.

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, and not destructive. The description adds behavioral details: caching for the session, single aggregated response, no batch ids. This provides extra 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 two sentences, front-loading the purpose and key behavior (caching), then detailing the fields. Every sentence is essential, 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?

For a parameterless tool with annotations and no output schema, the description covers purpose, caching, output structure, and links to a sibling tool. It could mention error conditions or authentication, but overall it is sufficiently comprehensive.

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 schema coverage is 100%. The description adds value by explaining the output fields (id, description, descriptionTranslated, parentId, parentDescription), helping the agent understand the return value shape.

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 Pluggy's transaction category taxonomy, specifying the endpoint (GET /categories) and that it's cached. It distinguishes itself from sibling tools by focusing on categories, which no other tool covers.

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 when needing category information for updating transactions (via id for openfinance_update_transaction_category) and mentions language preferences. However, it does not explicitly state when not to use it or provide alternatives among siblings.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is clear. The description adds value by specifying the return fields and the significance of add_connection_url, providing context beyond the structured 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, efficient sentence that lists what the tool returns. No unnecessary words or repetition. Highly 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?

Given no output schema and no parameters, the description provides the key return fields. It does not mention whether results are paginated or if there is a limit, but for a simple list tool, it is adequate. Siblings indicate this is one of many list tools, but the description covers the essential information.

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

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

There are no parameters (0 params), so baseline is 4. The description adds no parameter info because none exist. Schema coverage is 100% (empty schema). The description does not need to compensate.

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 saved bank connections and lists specific fields (connector_id, item_id, bank name, add_connection_url). Verb 'Returns' and resource are specific, distinguishing it from sibling tools dealing with accounts or transactions.

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

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

No explicit when-to-use or when-not-to-use guidance is given. The purpose is clear from the name and description, but it does not differentiate from similar tools like openfinance_list_accounts or mention prerequisites. Guidance is implied rather than stated.

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

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

Beyond annotations (readOnlyHint, idempotentHint, destructiveHint false), the description adds extensive behavioral context: no native paid/status field, detailed payment_logic with cross-bill matching, derived payment_status, open_bill limitations, connector asymmetry, and that results are bill-level summaries. 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?

Despite length, every sentence adds value given the complex Brazilian Open Finance semantics. Front-loaded with core return fields, then important caveats, optional parameters, and cross-references. No wasted words.

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

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

Extremely complete given complexity and no output schema. Explains derived fields, payment logic, open_bill semantics, connector asymmetry, failure mode (returns warning), and links to transaction tool. Covers all aspects an AI agent needs.

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 adds meaning for include_open_bill (default false, opt-in, extra scan) and mentions account_ids for bulk. Page and page_size are not explicitly described, but pagination is standard for listing endpoints.

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 key fields. It distinguishes from siblings like openfinance_get_credit_card_bill (singular) and openfinance_list_transactions (itemized purchases per bill).

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 this tool vs. alternatives: to see itemized purchases, use openfinance_list_transactions. Provides important semantic caveats about payment_status interpretation and open_bill opt-in. Also mentions bulk support with account_ids.

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 and idempotentHint. The description adds valuable behavioral context: it returns a structured fallback object instead of throwing errors, which is beyond what annotations cover. 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 paragraph, moderately dense with information. It front-loads the purpose and lists many details but avoids excessive verbosity. Some redundancy could be trimmed, but overall efficient.

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

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

Given the tool has 4 optional parameters and no output schema, the description covers the key behavioral aspects (error handling, return structure) and lists many returned fields. Lacks parameter details but otherwise complete for its 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?

Input schema has 4 parameters with 0% description coverage. The description does not explain any parameter's purpose, type, or constraints (beyond the enum list for 'type'). It lists returned fields but does not compensate for missing parameter documentation.

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

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

The description starts with a specific verb 'Returns' and resource 'investment portfolio', listing detailed investment types (FIIs, stocks, ETFs, etc.). It clearly differentiates from siblings like 'openfinance_list_accounts' by specifying the portfolio scope.

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

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

The description implies usage for connections with INVESTMENTS product enabled and mentions fallback on errors, but does not explicitly state when to use this tool versus alternatives or exclude usage cases. No when-not or alternative tools mentioned.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint (all safe). The description adds behavioral details: specific transaction types, fields returned (including expenses), and bulk execution support. 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 that efficiently convey the tool's output, key fields, and usage tip. No extraneous content; front-loaded with critical information.

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

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

Given missing output schema, the description adequately explains the return fields and transaction types. However, it omits pagination details and does not mention ordering. Still, it covers the most important aspects for an investment transactions 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% (no param descriptions). The description explains the required investment_id and the bulk investment_ids parameter, but does not mention page or page_size. This adds partial meaning but leaves pagination parameters undocumented.

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 returns movement history for an investment position, listing transaction types (BUY, SELL, etc.) and detailed fields. It distinguishes from siblings like openfinance_list_investments (list positions) and openfinance_list_transactions (general transactions) by focusing on investment-specific movements.

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 guides to use after openfinance_list_investments to get the investment_id, and mentions bulk support via investment_ids. Provides clear context but does not explicitly list when not to use or compare with alternatives beyond the one tip.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false, so the description is not required to repeat that. It adds valuable behavioral details: multiple connections are queried sequentially with rate-limit spacing, and returns { results, errors } per connection. This goes 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 three sentences with no wasted words. It front-loads the main purpose and structure, then dives into parameter details and return format. Every sentence 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 no output schema, the description explains the return format per connection. It mentions rate-limit spacing but does not discuss pagination or sorting, which may be expected for a list operation. However, the tool is simple (one optional parameter), so the description 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 description coverage is 0%, so the description fully compensates. It explains that items is an array of connection selectors (item_id uuid, connector_id, or connector_name) and what each entry represents, adding meaning beyond the raw schema.

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

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

The description clearly states it lists loan contracts per bank connection and provides the HTTP path (GET /loans). It distinguishes from sibling list tools by specifying the resource (loans) and the flexible input types (item_id, connector_id, connector_name).

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

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

The description explicitly explains when to pass items (to fetch specific connections) and when to omit (to list all linked banks), and notes sequential querying with rate-limit spacing. It does not explicitly mention alternatives or when not to use this tool, but the resource specificity makes it clear.

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

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

Annotations declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. Description adds critical behavioral details: returns warning/error on upstream errors, search_queries aggregates up to 5000 transactions, page size limit 500, and how to handle CREDIT card data gaps. No contradictions with annotations.

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

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

Description is long but packed with necessary information. Front-loaded with main purpose. Could benefit from clearer sectioning, but every sentence adds value. No fluff.

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

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

Given complexity (7 params, no output schema), description is highly complete. Covers return format (total, results, warning, error), pagination limits, search behavior, CREDIT card specific nuances, error handling, and references to sibling tools for further actions (force sync, reconnection). Effectively replaces 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 has 7 parameters with 0% coverage, but description compensates fully. Explains from/to as ISO date filters, page_size max 500, search_queries as case-insensitive substring match with OR semantics, account_id/account_ids for batch. Provides behavior of search_queries (aggregates 5000 items). Significantly adds 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?

Clearly states it returns transactions for BANK or CREDIT accounts. For CREDIT accounts, it is the only way to get itemized transactions and links to bills via creditCardMetadata.billId. Differentiates from sibling tool openfinance_list_credit_card_bills. Verb 'list transactions' is specific and resource is clear.

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

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

Provides explicit guidance on when to use this versus openfinance_list_credit_card_bills (e.g., for standardized open-bill totals). Explains CREDIT PENDING vs POSTED behavior per bank, error handling (returns warning/error instead of throwing), troubleshooting for zero results (check connection health), and recommendation to narrow from/to if truncated. Also covers bulk support with account_ids.

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

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

Annotations already indicate readOnlyHint=true and idempotent. The description adds valuable behavioral context: the tool resolves accounts internally, caps scans at 5000 transactions per account, and flags truncation. It also details the compact vs raw output format. 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 lengthy but well-structured, starting with the core purpose and then providing parameter details, output summary, and usage examples. Every sentence adds necessary context. While not extremely concise, it avoids fluff and earns its length.

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

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

Given 6 parameters, no output schema, and many sibling tools, the description is remarkably complete. It explains the output structure (compact vs raw, fields like total entradas, saídas, por_mes, top_despesas, by_account), the truncation behavior, and filtering options. It thoroughly covers expectations without needing to reference an 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 coverage is 0%, so the description must compensate. It explains item accepts connector_id, connector_name, or item_id; omitting it targets all banks. It clarifies from/to are ISO dates, granularity defaults to monthly and affects output, type filters BANK/CREDIT. top_n is implied by mentioning 'largest N each' in the output. The description covers all parameters sufficiently.

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 a bank connection in one call, resolving internal accounts and avoiding need for openfinance_list_accounts. It specifies use cases like 'análise anual/mensal', 'fluxo de caixa', which distinguishes it from sibling tools like 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?

The description provides explicit guidance on when to use the tool (for cash-flow analysis, annual/monthly overview) and contrasts with needing to call openfinance_list_accounts. It explains how to target one bank (using item) or all banks, and when to set granularity to 'raw'. However, it does not explicitly state when to use alternative tools like openfinance_list_transactions for detailed itemized data.

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

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

Beyond annotations (readOnlyHint, idempotentHint), the description details that it checks a public status page and returns global indicator, degraded components, incidents, and flags connected banks. All consistent with read-only, non-destructive behavior.

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

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

The description is detailed but still concise for the information conveyed. Every sentence adds value, though it could be slightly more compact. Structure is logical and front-loaded with purpose.

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

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

Despite no output schema, the description fully explains what the tool returns: global indicator, degraded components, open incidents, and affected banks. This is complete for a zero-parameter status-check tool.

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

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

No parameters exist, so baseline is 4. Description adds no parameter info, which is appropriate given zero parameters.

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

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

The description clearly states it checks the LIVE operational status of the Open Finance provider, distinguishing it from the sibling 'openfinance_get_item_status' which checks the connection's health. It uses specific verbs ('checks', 'reveals') and identifies the resource ('provider's public status page').

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 when to use: 'whenever data looks incomplete or stale even though a connection shows UPDATED' and contrasts with 'openfinance_get_item_status'. Provides a clear decision criterion for the agent.

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

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

Annotations already declare readOnlyHint=true, idempotent, not destructive. Description adds critical context: honors user's plan (PF plan hides PJ banks), never dumps whole catalog, and provides a connect_url. 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?

Single compact paragraph with actionable guidance, no fluff. Critical info front-loaded: purpose, required params, usage timing.

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

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

Despite no output schema, description fully details return fields and behavior. With only two simple params and clear usage context, nothing critical is missing.

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

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

Schema provides no descriptions (0% coverage). Description explains keywords[] must be an array of strings and include_accounts controls whether account details are returned. Adds essential meaning missing from schema.

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

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

The description specifies a clear action (search bank connectors by name keywords) and lists exact outputs (connector id, access type, audience, linked connections, connect_url). It distinguishes from siblings by emphasizing pre-connection use and hint about not dumping full catalog.

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 'Call this BEFORE connecting' and that 'keywords[] is REQUIRED — without it returns a hint'. Provides timing context but does not explicitly list when not to use among siblings.

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

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

Annotations are minimal (readOnlyHint false, etc.), but the description goes far beyond by disclosing that the tool overrides Pluggy's automatic categorization and teaches Pluggy by creating a Category Rule, affecting future similar transactions. Also mentions per-item errors do not fail the whole batch.

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 but dense with useful information. It is relatively concise given the complexity, though a bulleted or structured format could improve readability. No irrelevant details.

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 mutation with side effects, no output schema), the description covers purpose, parameter sources, behavioral implications, response format, and error handling. It is complete and leaves no critical gaps.

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

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

Schema description coverage is 0%, but the description fully explains both parameters: transaction_id comes from openfinance_list_transactions, category_id from openfinance_list_categories. It also describes the response shape `{ updated, results, errors }` with field details, compensating fully 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 corrects the category of one or more transactions via PATCH /transactions/:id. It distinguishes from sibling tools like listing or getting transactions by focusing on updating categorization.

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 usage: pass items array with transaction_id from openfinance_list_transactions and category_id from openfinance_list_categories. It explains when to use (fix miscategorized transactions) and side effects (creates Category Rule for future transactions). No explicit 'when not to use' but context is sufficient.

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

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

Annotations indicate the tool is idempotent, adding behavioral safety. The description adds minimal extra context (need for conversation), but does not elaborate on side effects or response 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 two concise sentences with no redundant information, front-loading the purpose and then the key usage hint.

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 core purpose and a key usage detail but lacks information about the return value or what happens after reporting. Given no output schema, it could be more complete.

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

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

With 0% schema description coverage, the description partially compensates by explaining the 'conversation' parameter and implying 'message' is the report content. However, 'context' is unmentioned, and parameter meanings could be clearer.

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 a bug, missing feature, or sending feedback. This distinguishes it from sibling tools which are mostly finance-related.

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 advises including the conversation array for reproduction, providing clear usage context. However, it does not specify when not to use or alternative tools, though none are directly comparable.

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, covering the safety profile. The description adds specific context about what version information is shown (platform and adapter), which aligns with annotations and provides value.

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

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

A single sentence of 8 words perfectly describes the tool's function. No extraneous information; every word is necessary 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?

Given the tool has no parameters, no output schema, and annotations fully describe safety, the description is complete. It adequately informs the agent of the tool's purpose and behavior.

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

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

The tool has no parameters, and the schema coverage is 100% (trivially). Baseline for 0 parameters is 4. The description does not need to add parameter details, as none exist.

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

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

The description clearly states the tool shows current MCP platform and adapter versions. It uses a specific verb ('Show') and identifies distinct resources. No sibling tool provides similar functionality, so differentiation is inherent.

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?

While no explicit when-to-use or when-not-to-use guidance is provided, the tool is unique among siblings (no other version-related tools), making its usage context clear: call it to retrieve version information. The description implies this without 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 declare readOnlyHint and idempotentHint. The description adds valuable context about the output contents (MCPs, status, catalog tool counts), which compensates for the missing output schema. 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?

A single 15-word sentence that wastes no words. It directly states the action and the three key pieces of information returned. Optimal conciseness.

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

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

Given the tool's simplicity (no parameters, no output schema) and presence of annotations, the description covers the main output items. However, it could be slightly more specific about the format or mention if other data (like version) is included.

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 zero parameters and 100% schema coverage, the description does not need to explain parameters. 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 resource ('toolkit state'), listing three concrete components (installed MCPs, connection status, catalog tool counts). This clearly distinguishes it from sibling tools, which perform actions or retrieve external data.

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 usage guidelines are given, but the tool is self-explanatory and unique among siblings. The description implies it should be used to inspect toolkit state, yet lacks when-not-to-use or alternatives.

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