Sicredi MCP

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

Annotations indicate idempotentHint=true and destructiveHint=false. The description adds behavioral context: the token provides either permanent or session-only access, and the flow to obtain it. 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, well-structured paragraph with all sentences adding value. It front-loads the context and efficiently conveys two authentication methods.

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 the authentication flow, the description covers obtaining token, two usage options, and config setup. It could mention security sensitivity, but overall complete for an authentication 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 single parameter 'token' has no schema description, but the description explains it as a JWT from browser login, optional (calling with no args returns link). This adds crucial 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 tool name 'authenticate' and description clearly indicate the purpose: logging in, obtaining an access token, and configuring it. It distinguishes from sibling tools like 'connect' or 'report_bug' which serve different functions.

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 two usage modes: permanent setup via config or session-only login by passing token. It does not explicitly state when not to use, 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 declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. Description adds behavioral context: returns authenticated:true and empty pending[] when all providers connected, and connect_url when credentials missing. This adds value beyond annotations.

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

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

Two sentences, no wasted words. Front-loaded with the main purpose, then explains conditional behavior. Highly concise and structured.

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

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

Given no parameters and simple schema, description covers key return fields (authenticated, pending, connect_url). No output schema exists but description sufficiently explains the response shape. Slightly missing explicit non-destructive guarantee, though annotations cover 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?

Input schema has zero parameters, so description cannot add parameter semantics. Baseline for 0 params is 4, and description appropriately focuses on return 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?

Description clearly states the tool returns connection status and URLs, distinguishing between all providers connected (authenticated:true, empty pending[]) and missing credentials (returns connect_url). It specifies the resource and outcome, differentiating from sibling tools like authenticate or openfinance_list_connections.

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

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

Description implies usage for checking connection status but does not explicitly state when to use versus siblings like authenticate or openfinance_provider_status. No exclusions or alternatives are 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?

The description adds extensive behavioral context beyond annotations: it explains one-off invoke, necessary permissions for writes, connect/checkout links, and installation states. No contradiction with annotations (readOnlyHint=false, openWorldHint=true).

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

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

The description is long but well-structured, beginning with a clear definition and then detailing actions and flows. While dense, every sentence adds value; slight length is justified by 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?

The description thoroughly covers the core functionality, auth, billing, installation states, and edge cases (e.g., returning links for missing credentials/wallet). Despite no output schema, the description explains what invoke returns, ensuring 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?

With 0% schema coverage, the description explains core parameters (action, query, mcp_id, tool_id, arguments) and their roles in the flow. However, it does not cover all 13 parameters (e.g., limit, immediate, tier_slug, conversation) explicitly, leaving some ambiguity.

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 is 'THE official mcp.ai marketplace' and the primary tool for discovering and running MCPs. It distinguishes from siblings like authenticate or openfinance_* tools by positioning itself as the first point of call for MCP-related actions.

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 usage guidance: 'use THIS tool FIRST' before external registries, and detailed when-to-use instructions for invoke vs install, search/describe flows, and alternatives like list_tools, subscribe, etc.

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 value beyond the destructiveHint annotation by detailing that connection data is deleted and becomes unavailable, and that a reconnection URL is returned. It provides useful behavioral context but could mention authorization requirements 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?

The description is three concise sentences, front-loading the core action in the first sentence. Each sentence adds distinct, relevant information (action, consequence, return value) with no extraneous text.

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 tool with destructive annotations, the description covers the main action, data impact, and return value. It is missing explicit guidance on the parameter's source (e.g., from list_connections), but overall is sufficiently complete for an agent to use correctly.

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

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

Schema description coverage is 0%, so the description must clarify the parameter. It indicates 'item' identifies a specific bank, but does not specify format or that it should be a connection ID from list_connections. This adds basic meaning but is not comprehensive.

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: revoking consent and deleting connection data for a specific bank. It uses strong verbs (revokes, deletes) and explicitly specifies the resource and outcome, distinguishing it from sibling tools like openfinance_list_connections or openfinance_get_item_status.

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

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

The description implies usage for disconnecting a bank but does not explicitly state when to use this tool versus alternatives (e.g., listing connections or checking status). No exclusions or alternative tools are mentioned, leaving the agent to infer 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?

With minimal annotations (no readOnly, idempotent, or destructive hints), the description fully discloses blocking behavior (polls up to 60s), return fields including status, executionStatus, lastUpdatedAt, synced, needs_action, and timed_out, and the immediate-return option with wait:false.

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: main action first, then usage, parameters, return format, and edge cases. While dense with information, it could be slightly trimmed without losing clarity.

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

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

Given the complexity (polling, multiple outcomes), no output schema, and sparse annotations, the description covers purpose, usage, parameters, return structure, error conditions (needs_action, timed_out), and references a sibling tool for follow-up. It is 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?

Input schema has 0% description coverage for its two parameters. The description compensates completely: explains items accepts selectors (item_id, connector_id, or connector_name) and omitting syncs all, and clarifies wait:false for fire-and-forget.

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 forces a bank re-sync and waits for completion. It specifies the HTTP method and polling behavior, distinguishes from siblings like openfinance_get_item_status, and explains the all-banks option when items are omitted.

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

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

Provides explicit when-to-use guidance: 'Use this when a balance or transaction list looks stale'. It contrasts with disconnect/reconnect approach, offers fire-and-forget via wait:false, and directs users to re-check with openfinance_get_item_status on timeout.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. The description adds value by detailing error behavior (BALANCE_FETCH_ERROR with warning) and response shape, providing context beyond annotations.

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

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

The description is concise with four sentences, each adding new information. It is front-loaded with the main action and contains no redundant or unnecessary words.

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

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

Given the simple tool with one parameter and no output schema, the description covers purpose, parameter usage, error behavior, and response structure. It is complete for the tool's 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?

The only parameter, account_ids, is described as an array of strings with a length constraint of 1-50. Since the schema has no description for parameters, the description compensates well by explaining the format and constraint.

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

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

The description clearly states 'Returns real-time balance payload per account id' with a specific verb and resource. It does not explicitly differentiate from sibling tools but the purpose is 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 usage guidance on passing account_ids as an array (1-50) and mentions error handling for CREDIT accounts. However, it does not specify when to use this tool over alternatives or 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 already declare readOnlyHint and idempotentHint, so the agent knows it's safe. The description adds that it returns extended creditData and a batch shape with results and errors, providing helpful behavioral context beyond annotations.

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

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

The description is very concise with two sentences, no wasted words, and front-loaded with the key purpose. It efficiently delivers necessary 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, the description mentions the batch shape {results, errors} and that account objects include extended creditData. This provides adequate context for a read-only detail tool, though a bit more detail on the full account object 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?

Schema coverage is 0%, meaning no param descriptions in schema. The description compensates by specifying `account_ids` is an array with size 1–50, adding meaning beyond the raw schema type.

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

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

The description clearly states the tool returns full account objects with extended creditData, specifies the HTTP method and endpoint, and mentions batch shape. It distinguishes from sibling openfinance_list_accounts by indicating it returns detailed data per 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?

The description tells the agent to pass `account_ids` as an array (1–50) and implies use when detailed account data is needed. It does not explicitly state when not to use or compare to alternatives, but the usage 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?

Adds behavioral context beyond annotations: batch shape {results, errors}, Pluggy not returning paid/status field, explanation that payments[] may refer to previous bill. No contradiction with annotations (readOnlyHint=true, destructiveHint=false).

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 informative but somewhat lengthy. Front-loaded with main purpose, all sentences add value. Minor redundancy possible but acceptable for clarity.

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

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

No output schema, but description covers return shape, field listing, limitations, and cross-references. Comprehensive for a read-only lookup tool.

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

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

Schema has 1 param (bill_ids array) with 0% description coverage. Description explains it's an array and how to discover ids via sister tool, adding meaning beyond schema but could include example format.

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

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

Description states 'Returns bill-level detail for one or more credit card bills by id' with specific fields (financeCharges, payments[]). It clearly distinguishes from sibling openfinance_list_transactions by stating what it does NOT do.

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 recommends using openfinance_list_credit_card_bills first to discover ids, advises against using for individual transactions, and warns about interpreting payments[] in Brazilian Open Finance 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, destructiveHint=false. The description adds behavioral detail: it returns status, executionStatus, connector metadata, and the shape of the response when omitting `item` (`{ count, items }`). This goes beyond annotations without contradicting them.

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, both concise and informative. No unnecessary words, and all content 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?

Despite no output schema, the description covers the return format for both use cases. For a simple status tool, this is complete and sufficient for an agent to understand what to expect.

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` with no description (0% schema description coverage). The description fully compensates by explaining the parameter's role: pass `item` for a single bank, omit for all banks. This 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 clearly states the tool returns the current status of a bank connection with specific examples (UPDATED, UPDATING, LOGIN_ERROR). It distinguishes between two use cases: omitting `item` for all banks or passing `item` for a single bank. This clearly differentiates it from sibling tools like openfinance_list_connections.

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

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

The description explicitly explains when to omit or pass the `item` parameter, providing clear usage context. It does not explicitly mention when not to use this tool or alternatives, but the context is sufficient for an agent to decide.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false. The description adds behavioral detail beyond annotations: explains aggregation behavior when item is omitted, clarifies the 'name' field vs. 'bank' field, and describes connector-dependent balance semantics. No contradictions.

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

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

The description is relatively long but every sentence adds value. It front-loads the core purpose and then provides detailed usage notes. Could be slightly more structured (e.g., bullet points), but it avoids fluff and is well-organized for an AI agent.

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

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

Given the complexity (2 optional parameters, no output schema, many sibling tools), the description is highly complete. It covers both use cases (with and without item), warns about data pitfalls, references an alternative tool, and explains key fields. No output schema, but return fields are sufficiently described.

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

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

Schema has 0% description coverage, so the description must compensate. It clearly explains the 'item' parameter (optional, for targeting a specific bank) and implicitly describes the 'type' parameter by listing BANK and CREDIT types. However, it does not explicitly state that 'type' filters results by account type, which would be clearer. Overall, adds significant meaning beyond schema.

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

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

The description clearly states the tool returns accounts for bank connections, listing specific data fields (balance, type, subtype, etc.) and distinguishing between BANK and CREDIT types. It differentiates from siblings like openfinance_list_credit_card_bills by explicitly noting when to use that alternative.

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 item (to list across all banks) vs. pass item (to target a single bank). Also warns about connector-dependent meaning of creditData.balance and directs users to openfinance_list_credit_card_bills for standardized amounts, giving clear when-to-use and when-not-to-use advice.

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

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

Annotations already declare readOnly, idempotent, and non-destructive. Description adds caching behavior and explains response structure, 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?

Three sentences, front-loaded with purpose, then details on output. Every sentence is informative without redundancy.

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

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

Given zero parameters, rich annotations, and complete output description, no gaps remain. User knows exactly what to expect.

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 to describe; baseline score applies. Description adds no param info but none is 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?

Description clearly states the tool returns Pluggy's transaction category taxonomy, mentions the endpoint, and explains the structure. It is distinct from sibling list tools by focusing on categories.

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 guidance on using the categoryId with another tool and notes language preference. Lacks explicit when-not advice 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 already provide readOnlyHint, idempotentHint, and destructiveHint, so the description adds minor context by mentioning the add_connection_url. It does not add significant 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?

Single sentence, front-loaded with the purpose, no redundant information. Every word adds value.

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

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

The description is complete for a simple list tool with no parameters and no output schema. It explains what is returned, though it could mention that it returns all connections for the install.

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 add parameter info. Per evaluation rules, baseline is 4.

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

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

The description clearly states the tool returns saved bank connections and lists the specific fields (connector_id, item_id, bank name, add_connection_url). It uses the verb 'Returns' and distinguishes from sibling tools like connect and disconnect.

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 this tool is for retrieving existing connections, but it does not explicitly state when to use it versus alternatives like connect or disconnect, nor does it mention 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 already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. Description adds extensive behavioral context: complex payment assignment logic across bills, derived payment_status semantics, open_bill derivation method, connector asymmetry, and warning about not assuming payment status. 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 overly verbose, spanning multiple dense paragraphs without clear structure (e.g., bullet points). While informative, it could be more concise and better organized to improve readability for an AI agent.

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

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

Despite no output schema, the description thoroughly covers return fields (payments[], payment_status, open_bill), derived logic, edge cases (connector asymmetry, payment matching), and includes warning about CREDIT_CARDS product. All aspects needed for correct tool invocation are addressed.

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 5 parameters with 0% description coverage in schema. Description explains include_open_bill (default false, derived approach), account_id (required), account_ids (bulk support). However, page and page_size are not explained, leaving their role ambiguous. The description partially compensates for schema gaps but not fully.

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 CREDIT-type accounts, lists specific fields, and distinguishes from sibling tools like openfinance_list_transactions for itemized purchases. The verb 'returns' and resource 'credit card bills' are specific.

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

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

Explicitly states when to use this tool vs alternatives (e.g., for itemized purchases use openfinance_list_transactions). Provides clear guidance on using include_open_bill parameter, handling payment_status, and connector asymmetry. Includes what to avoid (assuming payment from payments[]).

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is clear. The description adds value by disclosing that it returns a non-throwing fallback on errors (403 or upstream), and lists key fields like balance, rates, and ISIN. 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 that packs significant detail, but it lacks structure (e.g., separating purpose, parameters, returns). It is not extremely verbose, but could be organized better for quick scanning.

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 return structure (fields like balance, rates, ISIN) and error handling, but misses pagination details (page and page_size behavior) and whether item is required. Given 4 parameters and no output schema, more completeness would help.

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 the schema provides no explanations. The description does not explain individual parameters (item, page, type, page_size) beyond the enum for type. Users must guess their meanings, especially for requiredness and defaults.

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 investment portfolios, listing specific asset types (FIIs, stocks, ETFs, etc.). It distinguishes from sibling tools like openfinance_list_accounts and openfinance_list_transactions 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 explains when to use it (for investment portfolios) and mentions graceful fallback when INVESTMENTS isn't enabled. However, it does not explicitly state when to avoid this tool or compare to alternatives, though the context from sibling names helps.

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, idempotentHint, and destructiveHint. The description adds value by detailing the specific fields returned (quantity, value, expenses breakdown), which is beyond annotations. No contradictions or missing 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?

The description is concise, with two short paragraphs: one explaining functionality and return fields, another for usage order and bulk support. No unnecessary sentences, though the information could be slightly more structured (e.g., missing pagination mention).

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 (4 params, no output schema), the description covers the main purpose, required fields, and return structure well. However, it omits pagination behavior (page, page_size) and does not mention that the tool is read-only (though annotations cover that). This gap reduces completeness.

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

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

With 0% schema description coverage, the description must compensate. It explains investment_id and investment_ids (for bulk) but completely ignores page and page_size parameters, leaving their purpose and format undocumented. Only partial parameter guidance is provided.

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

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

The description clearly states it returns the movement history for a specific investment position, listing transaction types (BUY, SELL, etc.). It is specific about the resource and action, but does not explicitly differentiate from sibling tools like openfinance_list_transactions, which may cover other account types. However, the context of 'investment' and reference to openfinance_list_investments provides implicit differentiation.

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 to use this tool after openfinance_list_investments to obtain investment_id. It also mentions bulk support via investment_ids, giving clear context on when to use it. No explicit when-not-to-use or alternatives are stated, but the sequential guidance is sufficient.

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

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

Beyond annotations indicating read-only and idempotent behavior, the description reveals sequential querying, rate-limit spacing, and the response format { results, errors } per connection. 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?

Three sentences front-load purpose, then detail parameter usage and behavior. Every sentence adds value with no redundancy or 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 the single parameter and no output schema, the description covers input semantics, runtime behavior (sequential, rate-limited), and output format. No gaps are apparent for a loan-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?

The schema only defines items as an array of strings. The description adds critical meaning: items are connection selectors (item_id uuid, connector_id, or connector_name) and omission lists all banks. This compensates for 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 the tool lists loan contracts per bank connection via a GET /loans endpoint. It is distinct from sibling tools like openfinance_list_accounts by focusing on loans and specifying the per-connection 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 explains when to pass items (for specific connections) and when to omit it (for all connections). It mentions sequential querying with rate-limit spacing, but does not explicitly address when to use alternatives, though 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?

The description adds significant behavioral context beyond annotations: auto-pagination behavior (omit page for all transactions, up to 5000 ceiling), CREDIT pending/posted variance by bank, error handling (returns warning/error instead of throwing), and note about connection health for CREDIT accounts. Annotations already indicate read-only and idempotent, which the description reinforces 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 lengthy but every sentence provides essential information given the tool's complexity. It is front-loaded with the main purpose and then systematically covers behavior, parameters, and edge cases. While it could be slightly more structured (e.g., bullet points), it remains clear and effective without superfluous content.

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 8 parameters, varying bank behavior, pagination mechanics, error handling, and integration with sibling tools, the description is exceptionally complete. It addresses all likely agent needs: how to retrieve all transactions, handle truncation, interpret CREDIT account data, and respond to edge cases like zero results. No gaps remain.

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

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

With 0% schema description coverage, the description fully compensates by explaining all 8 parameters: from/to as ISO dates, page and page_size for pagination, detail enum with meanings of compact/rich/raw, search_queries as case-insensitive substring match with OR semantics, account_ids for bulk, and account_id as required. Each parameter's purpose and behavior is clarified.

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 transactions for bank accounts of type BANK or CREDIT. It explicitly distinguishes from sibling tools like openfinance_list_credit_card_bills and openfinance_list_accounts by explaining when each is appropriate, e.g., 'For CREDIT accounts, this is the ONLY way to get itemized transactions' and 'To get a standardized open-bill total... use openfinance_list_credit_card_bills.'

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

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

The description provides explicit guidance on when to use this tool vs alternatives, including specific scenarios like using openfinance_list_credit_card_bills for total debt, narrowing date range if truncated, and checking connection health if total is 0 for CREDIT accounts. It also explains when to use different detail levels (compact, rich, raw) and pagination strategies.

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 readOnly, idempotent, non-destructive. The description adds important behavior: it resolves accounts internally, scans at 5000/account with a truncation flag, returns a compact summary by default (listing specific metrics), and warns about heavier payload for 'raw' granularity. 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 dense and informative but slightly long. It is front-loaded with the core purpose, and each sentence adds value. A more structured format (e.g., bullet points) could improve readability, but it is not overly verbose for the tool's complexity.

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

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

Given 7 parameters (none required) and no output schema, the description comprehensively explains the return structure (compact vs raw, including specific fields like total entradas, saídas, top despesas, etc.), the truncation behavior, and filtering options. It covers all scenarios needed for correct invocation.

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

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

Despite 0% schema coverage, the description explains all parameters: 'item' as connector_id/name/item_id, 'from'/'to' as ISO dates, 'type' filters, 'granularity' and 'detail' options with their effects. The 'top_n' parameter is implied by the mention of 'largest N' but not explicitly linked, which is a minor gap.

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

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

The description clearly states it provides consolidated cash-flow analysis per bank connection in one call, contrasting with sibling tools that require multiple steps. It uses specific verbs like 'resolve accounts internally' and 'fans out transactions', and lists concrete use cases like 'fluxo de caixa' and 'maiores gastos/recebimentos'.

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 this tool (for a whole connection analysis) and when not (do not call openfinance_list_accounts first). Provides guidance on parameter usage: omitting 'item' analyzes all banks, setting granularity to 'raw' for itemized rows, and using 'detail' for enriched data. This directly helps the agent decide between alternatives.

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

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

Annotations already indicate read-only, idempotent, non-destructive. Description adds context: checks a public status page, returns global indicator, degraded components, open incidents, and flags affected 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?

Single paragraph, front-loaded with purpose, then usage context, then return fields. Every sentence 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?

Despite no output schema, description details return fields. For a parameterless tool, this is fully complete. It sets clear expectations for the agent.

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

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

No parameters, schema coverage 100%. Description does not need to add parameter info. It clearly explains the tool's input (none) and output, making it complete.

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

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

The description clearly states the tool checks the provider's live operational status, distinct from connection status. It uses specific verb 'checks' and resource 'LIVE operational status of the Open Finance provider', and explicitly distinguishes from sibling tool openfinance_get_item_status.

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

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

Provides explicit when to use: when data looks incomplete/stale despite connection showing UPDATED. Also explains benefits: reveals upstream outage or known incident, helps differentiate provider-side 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?

Annotations already indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description adds value by detailing the caveat for non-Open-Finance connectors, the keyword requirement, and the plan-based filtering. This goes beyond annotations without contradicting them.

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

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

The description is a single paragraph that packs substantial information but is somewhat dense. It front-loads the main action and consequences (returns per match, caveat, plan handling). Could benefit from breaking into sentences or bullet points for easier parsing.

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

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

Given no output schema, the description adequately explains return values (connector id, access, audience, connect_url, caveat) and edge cases (no keywords returns a hint, never dumps catalog). However, it doesn't cover potential errors or rate limits, and the keyword requirement mismatch with schema slightly undermines 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?

With 0% schema description coverage, the description compensates by explaining keywords as an array of strings (with examples) and include_accounts as a boolean to include accounts. However, it contradicts the schema by stating keywords is required when the schema lists no required parameters, slightly reducing clarity.

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

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

The description clearly states that the tool searches bank connectors by name, listing specific return fields (connector id, access, audience, etc.). It distinguishes itself from sibling tools like 'connect' and 'openfinance_list_connections' by focusing on initial search and providing a pre-selected connect_url.

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

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

The description instructs to call this BEFORE connecting and explains that it honors the user's plan (PF vs PJ). It also states that keywords[] is required, though it doesn't explicitly mention when not to use it or provide alternatives. The context is clear but could include 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 declare readOnlyHint=false and destructiveHint=false. Description adds critical behavioral details: overrides automatic categorization, creates a Category Rule for future similar transactions, and batch error handling (per-item errors do not fail the whole batch). 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?

Description is slightly lengthy but every sentence adds value. Well-structured: purpose, parameter mapping, side effect, response shape. Could be slightly more concise but not wasteful.

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

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

No output schema provided, but description includes the batch response shape. Explains side effect (rule creation). All aspect of the tool are covered given 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?

Schema has 0% coverage for parameter descriptions. Description compensates fully: explains items array structure, source of transaction_id and category_id from other tools, and meaning of each field.

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 'Corrects the category of one or more transactions' with specific verb and resource. Distinguishes from sibling tools like openfinance_list_transactions and openfinance_list_categories by explaining they are sources for IDs.

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

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

Explicitly tells when to use (fix miscategorized transactions and improve future categorization). Explains how to obtain required IDs from other tools. No explicit 'when not to use' but context is clear given no alternative update tool exists.

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, which describe safety. The description adds instruction to include conversation array for reproduction, but does not elaborate on side effects or ticket creation. No contradiction.

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

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

Two concise sentences: first sentence states purpose, second sentence provides a key usage instruction. 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?

No output schema, but the tool is simple. The description covers the purpose and one critical input detail (conversation). However, it omits explanation of the context parameter and any response expectations. Adequate for a basic feedback tool but not 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?

Schema has 0% description coverage, so the description must compensate. It only mentions the conversation parameter ('include the conversation array') but does not explain context or message beyond requiring it. The conversation param is noted as a string with default '[]', but no format guidance is given.

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: report a bug, missing feature, or feedback. It distinguishes itself from the sibling tools, which are mostly Open Finance operations or authentication.

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

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

The description implies usage for reporting issues or feedback but does not explicitly state when not to use it or mention alternatives. The context of sibling tools suggests no other feedback channel exists, but guidance is implicit.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds marginal value by specifying that it shows platform and adapter versions, but does not disclose any additional behavioral traits beyond what annotations cover.

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

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

The description is a single sentence with no wasted 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?

Given the tool's extreme simplicity (no parameters, no output schema, rich annotations), the description completely covers what the tool does. No additional context is needed.

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

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

The tool has zero parameters, so the description does not need to add parameter meaning. Baseline score of 4 applies as schema coverage is irrelevant.

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 using specific verb 'Show' and identifies resources 'MCP platform and adapter versions'. It is unambiguous and distinguishes itself from siblings as the only version reporting 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?

No explicit when-to-use or alternatives are given, but the tool's purpose is self-explanatory (show version). The lack of guidelines is acceptable due to triviality, but a minor improvement would note that it is safe to call at any time.

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 context on the returned data (installed MCPs, connection status, tool counts), which is sufficient.

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

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

One sentence, zero waste, 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?

Given zero parameters and no output schema, the description fully covers the tool's behavior for an informational 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 4. Description does not need to add parameter info.

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 toolkit state including installed MCPs, connection status, and catalog tool counts. It is specific and distinguishes from all siblings.

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 or when-not guidance, but as a status tool, usage is implied. No alternatives mentioned.

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