Atacadão MCP

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

The description discloses that calling with no arguments returns a login link, and calling with token authenticates for the session. It mentions non-expiring vs session behavior. Annotations indicate idempotentHint=true and destructiveHint=false, which are consistent. The description adds value beyond annotations by explaining the two modes.

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 of three sentences. It front-loads the purpose and covers both usage modes efficiently without redundant information.

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

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

Given the simple authentication scenario and no output schema, the description provides all necessary information: purpose, two authentication methods, best practice, and how to call the tool. No additional details are 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?

With schema coverage at 0%, the description fully explains the optional 'token' parameter: providing it means the user has pasted a JWT for session login, while omitting it returns the login link. This adds complete meaning beyond the schema's minimal definition.

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

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

The description clearly states the tool's purpose: authentication for IDE agents (Cursor, etc.). It specifies the resource (access token) and actions (log in, copy token, add to config or paste). It distinguishes from siblings by focusing on a specific use case not covered by other tools.

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

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

The description provides clear guidance on when to use each option: permanent token via config for persistent connection, or session-only by pasting token. It recommends the config approach as 'best'. However, it does not explicitly state when not to use this tool or compare to alternatives like 'connect'.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. The description adds value by detailing the two possible return states (authenticated:true with empty pending[], or connect_url for toolkit and per-install URLs). This goes beyond annotations and provides useful behavioral insight.

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. First sentence states main purpose, second provides specific behavioral details. Front-loaded and efficient.

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

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

For a zero-parameter tool with no output schema, the description explains the two possible return outcomes comprehensively. It covers both success and missing credentials scenarios, making it complete for its simplicity.

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% (empty schema). The description correctly implies no input is needed. Baseline 4 is appropriate as there is no need for additional param information.

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

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

The description clearly states the tool returns connection status and URLs, with specific scenarios for when all providers are connected vs when credentials are missing. This is a specific verb+resource combination that distinguishes it from siblings like 'authenticate' which presumably initiates 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 checking connection status but does not explicitly state when to use vs alternatives. No mention of when not to use or comparisons with siblings like 'authenticate' or 'marketplace'.

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

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

The description discloses key behaviors: invoke runs MCPs even if not installed, works one-off without bloating toolkit, returns connect/checkout links when needed, and that install is for permanent addition. No contradiction with annotations (readOnlyHint=false, etc.).

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 information-dense and well-structured, starting with the core flow and then detailing invoke/install nuances. It uses bold for emphasis and clearly separates concepts. Some redundancy exists, but given the complexity, it's efficiently packed.

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 (15 params, no output schema), the description covers the primary workflow, auth/payment handling, permissions, and distinctions between actions. It also mentions search/describe flags, report_bug, and request_mcp. The agent should be able to use the tool correctly with this description.

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 and 15 parameters, the description compensates by explaining the role of key parameters in context (action, query, mcp_id, tool_id, arguments) and how they relate to the workflow. However, not every action's parameter set is fully detailed.

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

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

The description explicitly states the tool is 'THE official mcp.ai marketplace' and defines its core purpose: discovering and running MCPs. It distinguishes itself from sibling tools by instructing to use this tool first before external registries and by contrasting invoke vs install.

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 a clear core flow (search → describe → invoke) and gives explicit when-to-use guidance for install vs invoke, as well as handling auth/payment scenarios. It also mentions when to use list_tools and other actions, and notes that writes require workspace owner/admin.

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 destructiveHint=true. The description adds detail: revoking consent, deleting data, making data unavailable, and returning a reconnect 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?

Three short, front-loaded sentences with no wasted words. Clearly communicates the action, effect, and return value.

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

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

Covers the primary effect and return value, but lacks details on error conditions, required permissions, or what happens if the connection doesn't exist. No output schema exists to fill gaps.

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

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

The single parameter 'item' is a string with no description in schema (0% coverage). The description mentions 'for a specific bank' but does not explain what the parameter represents or its format, leaving 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 the tool revokes Open Finance consent, deletes connection data, and returns a reconnection URL. It distinguishes itself from sibling tools like 'connect' and 'openfinance_list_connections' by focusing on disconnection.

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 intent is clear from the name and description, but no explicit guidelines on when to use versus alternatives (e.g., when to disconnect vs. force sync) are provided. It relies on context from sibling tool names.

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

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

The description discloses behavioral traits beyond annotations, such as polling up to ~60s, returning specific fields like needs_action and timed_out, and the effect of wait: false. This adds significant context to the minimal annotation set.

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 moderately long but well-structured, starting with the main action and then detailing parameters, return values, and special cases. Every sentence adds value, though slightly verbose.

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

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

Given no output schema, the description fully explains the return format and error states, covering main use cases and edge cases. The tool's complexity is well 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?

With 0% schema description coverage, the description fully explains both parameters: items as an array of selectors (item_id, connector_id, connector_name) or omit to sync all, and wait as boolean for fire-and-forget. This adds all needed 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 forces a bank to re-sync connections and waits for completion. It distinguishes from sibling read tools like openfinance_list_transactions by explicitly targeting stale data scenarios.

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 when to use it (stale balances/transactions) and provides alternatives like openfinance_get_item_status for timeout cases. It also mentions fire-and-forget mode via wait: false, though it does not explicitly list 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?

The description goes beyond annotations by detailing error handling for CREDIT accounts (BALANCE_FETCH_ERROR with warning), degradation to last-synced balance when upstream is unavailable or connector is not Open Finance, and the response shape. No contradictions with annotations exist.

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 concisely cover the core function, error modes, and response shape. Information is front-loaded with the primary action, and no unnecessary words are present.

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 main function, error scenarios, and response structure adequately for a single-parameter tool. It lacks mention of authentication prerequisites or connection requirements, but given sibling tools like authenticate and connect, this is acceptable.

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

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

With 0% schema description coverage, the description compensates by specifying that account_ids should be an array of 1-50 items. This adds critical constraints not present in the schema.

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

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

The description clearly states the tool returns real-time balance per account id via GET /accounts/:id/balance. It specifies the input parameter and differentiates the tool from others by its specific purpose, though it does not explicitly distinguish from sibling tools.

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

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

The description implies usage for retrieving balances but does not provide explicit guidance on when to use this tool versus alternatives (e.g., openfinance_list_accounts). The context of error handling is given, but no when-not-to-use advice is included.

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 critical behavioral context beyond annotations by describing the provider_incident block that signals unreliable credit limits/balances, and the batch response shape {results, errors}. Annotations already declare readOnly and idempotent hints.

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

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

Every sentence adds value: purpose, usage, and a warning flag. No unnecessary words, efficient structure.

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 with no output schema, the description covers input constraints and important runtime behavior (provider_incident). Could hint at idempotency but annotations already cover that. Overall 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?

With 0% schema description coverage, the description compensates by specifying the parameter is an array of strings with size constraint 1-50 and explaining the batch behavior, adding meaning beyond the bare schema.

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

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

The description clearly states it returns full account objects including extended creditData per id (GET /accounts/:id), and distinguishes from sibling tools like openfinance_list_accounts by specifying batch detail retrieval.

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

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

Provides explicit usage instruction to pass account_ids as an array (1-50). While it doesn't explicitly exclude alternative tools, the context implies when detailed account data is needed.

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

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

Annotations (readOnlyHint=true, destructiveHint=false, idempotentHint=true) are complemented by behavioral details: batch shape { results, errors }, Pluggy not returning paid/status field, and clarification that payments[] reflect previous bill's payment. 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 lengthy but well-structured and front-loaded. Every sentence adds value, though some redundancy (e.g., repeating 'openfinance_list_transactions') could be trimmed.

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

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

Given no output schema and complex semantics (bill-payment timing, status inference, batch errors), the description covers all necessary context. It preempts common misinterpretations and integrates seamlessly with sibling tools.

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

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

Schema has one parameter (bill_ids) with 0% description coverage. The description fully compensates by explaining bill_ids is an array, how to obtain IDs via list_credit_card_bills, and the batch response 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 explicitly states it returns bill-level detail for one or more credit card bills by id, listing returned fields (financeCharges, payments[]). It clearly distinguishes from the sibling tool openfinance_list_transactions that provides itemized transactions.

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

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

Provides explicit instructions: use openfinance_list_credit_card_bills first to discover ids, do not reconstruct bill total from transactions, and use openfinance_list_transactions for itemized details. Also explains the meaning of payments[] and status caveats.

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, idempotentHint, and destructiveHint as false, so the description's behavioral disclosure is supplementary. It adds useful context about the output contents (status, executionStatus, connector metadata) and the dual-mode behavior, which goes beyond annotations.

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

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

The description is one sentence that efficiently conveys the purpose, output, and two usage modes. Every word is necessary and well-structured, with no redundancy.

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

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

Given the tool's simplicity (one optional parameter, no output schema), the description is fully complete. It covers what the tool returns, the two modes, and the effect of the parameter, leaving no gaps for an AI 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?

Despite 0% schema description coverage, the description fully explains the single parameter 'item' and its role: passing it returns a single bank's status, omitting it returns all banks' statuses. This is a perfect compensation for the lack of schema descriptions.

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

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

The description clearly states the tool returns the current status of a bank connection with specific statuses like UPDATED, UPDATING, LOGIN_ERROR, plus executionStatus and connector metadata. It distinguishes between two use cases: getting all banks' statuses or a single bank's status, which 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 provides usage guidelines: omitting the item parameter gets all banks' statuses, while passing item gets a single bank's status. This is clear and context-aware, though it does not explicitly mention when not to use the tool or alternatives, which would warrant a 5.

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

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

Annotations already indicate read-only and idempotent behavior; description adds that it is a batch operation accepting 1-50 IDs and returns a '{ results, errors }' shape, which is useful 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 well-structured sentences: first lists output fields, second gives usage and input details. Information is front-loaded, but slightly verbose with field enumeration.

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

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

For a single-parameter detail retrieval tool with no output schema, the description lists many return fields, batch behavior, and links to a related tool. It is fairly complete, but lacks examples or error handling details.

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

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

Schema coverage is 0%, but description notes that loan_ids is an array of 1-50 items and implies they come from openfinance_list_loans. However, it does not explain the format or source of loan IDs beyond that.

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 'Returns full loan contract detail by id' and lists many specific fields, distinguishing it from sibling openfinance_list_loans by suggesting a follow-up use case.

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

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

Explicitly says 'Use after openfinance_list_loans to deep-dive on a specific contract', providing clear context of when to use this tool, but does not mention when to avoid 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 indicate read-only and non-destructive. The description adds critical context: credit balance meaning is connector-dependent, presence of provider_incident block affecting data reliability, and the distinction between account name and bank brand. 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 long but well-structured, starting with core functionality then layering nuances. Each paragraph serves a clear purpose. Slightly verbose 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?

Given the complexity (no output schema, multiple edge cases), the description covers response fields, credit balance caveats, provider incidents, and cross-references related tools. Sufficient for an agent to understand usage and limitations.

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 fully explains both parameters: item controls scope (all banks vs single), type filters by account category. Also documents response fields like bank, connector_id, and creditData, adding meaning beyond the minimal schema.

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

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

The description clearly states it returns bank and credit card accounts with detailed fields. It distinguishes from sibling tools by referencing openfinance_list_credit_card_bills for standardized billing, making the purpose specific and well-defined.

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

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

Explicit guidance on when to omit or pass the item parameter for aggregated vs single-bank queries. Also advises against treating credit balance as the month's bill and references the appropriate tool for standardized 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?

Adds meaningful behavioral context beyond annotations: cached per session, describes output fields (id, description, etc.), and notes the relationship to update tool. No contradictions with readOnlyHint, idempotentHint, destructiveHint.

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

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

Three concise sentences with no redundant information. First sentence states purpose, second lists output fields, third clarifies batch behavior. Efficient and front-loaded.

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

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

Covers all essential aspects: caching, output structure, and relation to other tools. Even without output schema, the description sufficiently documents the return type, making it complete for a zero-parameter read-only 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 in schema, so description cannot add parameter info. However, it provides valuable semantic details about the returned fields (including translation) and the cache behavior, which compensates for the lack of output schema.

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

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

States clearly that it returns the cached transaction category taxonomy from Pluggy. Distinguishes from sibling tools like openfinance_list_transactions by specifying the focus on categories. Includes cross-reference to openfinance_update_transaction_category.

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

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

Indicates it is cached and gives a single aggregated response, implying it is suitable for reading categories without real-time needs. No explicit when-not-to-use or alternatives, but the context is clear enough with annotations.

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, idempotentHint true, and destructiveHint false. The description adds value by revealing that it returns an add_connection_url for linking additional banks, 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?

Single sentence that front-loads the purpose and includes key details with 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?

For a tool with no parameters and no output schema, the description provides sufficient detail about what is returned, making it complete for its simplicity.

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 no parameters, the schema coverage is 100%. The description adds meaning by listing the returned fields, which compensates for the lack of an output schema.

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

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

The description clearly states it returns saved bank connections with specific fields (connector_id, item_id, bank name, add_connection_url), distinguishing it from sibling tools like openfinance_list_accounts or connect.

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

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

The description implies use when you need to retrieve existing connections. It does not explicitly mention when not to use, but the context is clear given no parameters and the simple listing purpose.

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 extensively discloses behaviors beyond annotations: payment attribution logic, derived payment_status, open_bill derivation, connector asymmetry with fallback reasons, and reliability warnings. This adds rich context that annotations (readOnlyHint, idempotentHint) do not cover, and no contradiction is present.

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 excessively long (nearly 2000 words) and includes very detailed explanations that could be shortened or better structured. While the first sentence front-loads the core purpose, the dense subsequent paragraphs make it hard to quickly parse key points. Conciseness is sacrificed for completeness.

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, no output schema, and low schema coverage, the description is remarkably complete. It explains the return structure (fields like payments[], payment_status, open_bill), edge cases (connector asymmetry, payment attribution, reliability warnings), and opt-in behavior. This fully compensates for the lack of 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 description coverage is 0%, and the description only explains one parameter (include_open_bill) in detail. Other parameters (page, page_size, account_ids) are not described, leaving the agent to rely solely on schema names and types. The description adds value for include_open_bill but not for the rest.

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

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

The description clearly states the tool returns closed credit card bills for a credit-type account, listing specific fields. It distinguishes itself from sibling tools like openfinance_list_transactions by noting it provides bill-level summaries, not individual transactions, and from openfinance_get_credit_card_bill by being a list operation.

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 (to get closed bills), when not to (e.g., not for individual transactions), and alternatives (use openfinance_list_transactions for itemized purchases). It also includes warnings about not assuming payment status and cross-referencing account echo in multi-bank scenarios.

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

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

Annotations indicate readOnlyHint=true, destroyingHint=false. Description adds useful behavioral detail: it returns a specific structure ({total, results, warning}) instead of throwing exceptions on 403 or upstream errors, which is critical for agent understanding.

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 single paragraph, front-loaded with key purpose and asset types. It lists fields concisely. Could be slightly more structured (e.g., mention parameters), but no wasted sentences.

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 (multiple asset types, fields, error cases) and no output schema, description covers main returns but lacks detail on pagination, parameter usage, and full return structure. Adequate but leaves 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 has 4 parameters with 0% description coverage. Description fails to explain any parameter (item, page, type, page_size) or their syntax/usage. Since schema coverage is very low, description should compensate but does not, leaving agents guessing.

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

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

Description clearly states verb 'Returns' and specific resource 'investment portfolio for a connection', listing concrete asset types (FIIs, stocks, ETFs, etc.) and fields returned. This distinguishes it from siblings like 'openfinance_list_investment_transactions' and 'openfinance_list_accounts'.

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 fetching overall portfolio but does not explicitly state when to prefer this over similar tools (e.g., 'openfinance_list_investment_transactions' for transactions). It mentions error handling but lacks guidance on prerequisites or when not to use.

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

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

Annotations already confirm read-only, idempotent, non-destructive behavior. The description adds valuable detail on the returned fields (e.g., expenses breakdown, agreedRate) and bulk support, surpassing annotation context without contradiction.

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

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

Two concise sentences with immediate purpose statement, plus a clear bulk support note. Every sentence adds value without redundancy.

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

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

Given moderate complexity and no output schema, the description provides a thorough list of returned fields and usage context. However, it lacks details on pagination behavior and error scenarios, which 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 main parameter investment_id and introduces investment_ids for bulk usage, but does not describe page or page_size, missing a chance to clarify pagination semantics.

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

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

The description clearly states the tool returns movement history for a specific investment position, enumerating transaction types (BUY, SELL, TAX, etc.) and distinguishing it from sibling tools like openfinance_list_investments and openfinance_list_transactions.

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

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

Explicitly recommends using after openfinance_list_investments to obtain the investment_id, providing a clear usage sequence. Though it does not explicitly state when not to use it, the context effectively guides 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?

Adds behavioral context beyond annotations: indicates sequential querying with rate-limit spacing for multiple connections, and returns { results, errors } per connection. No contradiction with annotations (readOnlyHint=true, idempotentHint=true, destructiveHint=false). Could be improved with more details on rate limits or response structure, but 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?

Three sentences, each serving a purpose: purpose, parameter usage, and return structure. Front-loaded with main action. No unnecessary words.

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

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

Provides enough context for a list operation: explains parameter behavior, sequential querying, and return format. Lacks details on pagination, ordering, or specific rate limits, but is adequate given the tool's simplicity and the presence of annotations indicating read-only 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 single parameter items is explained in detail: it accepts an array of connection selectors (item_id uuid, connector_id, or connector_name), and omitting it queries all connections. This fully 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?

Clearly states it lists loan contracts per bank connection via GET /loans. Distinguishes between fetching for specific connections (using items) versus all connections. Differentiates from sibling tools like openfinance_list_accounts, which list accounts instead.

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?

Describes exactly when to use: to retrieve loan contracts. Explains how to use the items parameter (array of selectors) and the effect of omitting it (lists across all linked banks). Mentions sequential querying with rate-limit spacing. Does not explicitly exclude alternatives, but the purpose 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?

Beyond the readOnlyHint annotation, the description discloses numerous behavioral details: credit card billId is a per-connector hint with sparse/inconsistent population; CREDIT PENDING/POSTED behavior varies by connector; search_queries aggregates up to 5000 transactions before filtering; pagination auto-paginates up to a 5000 ceiling; error handling returns a specific structure instead of throwing; detail parameter behaviors and token implications; account echo block for identification; provider incident handling. These go far beyond what annotations provide.

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

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

The description is very long but front-loaded with the core purpose and key distinctions. Each section (credit card handling, pagination, detail parameter, error handling, bulk support) is well-organized. While not concise, the length is justified by the tool's complexity and the lack of schema descriptions. It could be slightly tightened, but overall it 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 the tool's complexity, zero schema descriptions, no output schema, and eight parameters, the description is remarkably complete. It covers all parameters, behavioral nuances, edge cases (sparse billId, connector variation, provider incidents), cross-references to sibling tools (list_accounts, list_credit_card_bills, get_item_status), and error handling. Nothing essential is missing for correct invocation and interpretation.

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 parameters. It details that from/to are ISO YYYY-MM-DD dates, page can be omitted for auto-pagination, detail has three levels (compact, rich, raw) with specific fields and trade-offs, page_size max 500, account_ids for bulk, and search_queries for case-insensitive substring matching with OR semantics. This adds significant meaning beyond the minimal 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 transactions for bank accounts (BANK or CREDIT). It distinguishes itself from siblings like openfinance_list_credit_card_bills by noting it is the only way for itemized credit card transactions and warns against summing transactions for bill totals. This provides a specific verb-resource-scope combination and differentiates from related tools.

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

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

The description provides extensive guidance on when to use this tool versus alternatives. It explicitly explains that for CREDIT accounts, this is the only way to get itemized transactions, and directs users to openfinance_list_credit_card_bills for open-bill totals. It also clarifies pagination behavior (omit page for auto-pagination vs explicit page) and when to narrow date ranges. This is explicit usage direction with exclusions and 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?

Beyond the annotations (readOnlyHint=true, idempotentHint=true, destructiveHint=false), the description adds significant context: scan caps at 5000 transactions per account with a truncated flag, a provider_incident block indicating incomplete data when the Open Finance provider has an incident, and that it resolves accounts internally.

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 front-loaded with the core purpose. Every sentence adds value, though some details (e.g., Portuguese terms like 'entradas, saídas') could be streamlined. Still, it is well-structured and informative.

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

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

Without an output schema, the description covers return values comprehensively: compact summary fields (total entradas, saídas, saldo_liquido, por_mes, top_despesas, top_recebimentos, by_account), raw granularity behavior, and provider_incident. This completeness is high given the tool's complexity (7 parameters, multiple modes).

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 description coverage, the description thoroughly explains each parameter: 'item' can be connector_id, connector_name, or item_id; 'from'/'to' are ISO dates; 'granularity' defaults to 'monthly' and describes output; 'detail' enriches rows; 'type' filters BANK or CREDIT accounts. It adds meaning far beyond the enum types.

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 performs consolidated cash-flow analysis for a whole bank connection in one call, resolving accounts internally. It specifies the verb 'analyze' and resource 'connection transactions', and distinguishes from sibling tools like openfinance_list_transactions which require prior account list.

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 (e.g., for annual/monthly analysis, cash flow, large expenses) and when to set granularity to 'raw' for itemized rows. It also explains that you can omit 'item' to analyze all linked banks, and notes that you do not need to call openfinance_list_accounts first.

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, but the description adds richer behavioral context: it returns global indicator, degraded components, open incidents, and flags incidents affecting connected banks. No contradiction with annotations.

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

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

The description is four sentences, each serving a purpose: stating the action, explaining when to use, detailing return info, and specifying output fields. It is informative but could be slightly more concise without losing clarity.

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

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

Given no output schema, the description comprehensively covers return values (global indicator, degraded components, open incidents, your_banks_affected) and provides complete context for when to use the tool. No gaps.

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

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

There are zero parameters, so the description need not add parameter information. The baseline for no parameters is 4; the description appropriately does not mention 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 explicitly states it checks the LIVE operational status of the Open Finance provider, distinguishing it from the connection-level tool openfinance_get_item_status. The verb 'checks' and specific resource 'provider status' make the purpose clear, and it differentiates well from 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?

The description provides explicit guidance on when to use this tool: 'whenever data looks incomplete or stale even though a connection shows UPDATED'. It also clarifies that it reveals upstream outages versus connection issues, helping the agent decide between this and other tools.

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

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

Annotations already indicate readOnly, idempotent, non-destructive. The description adds key behavior: returns caveat warnings for credential connectors, honors user's plan (PF hides PJ banks), and returns connect_url. 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?

Well-structured with front-loaded purpose, then behavioral notes. Slightly verbose but every sentence adds value. Could tighten some phrases while retaining 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 fully details return values (connector id, access, audience, connections, connect_url) and caveat behavior. Context of plan filtering and usage workflow is complete.

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

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

Schema has 0% description coverage. The description fully explains both parameters: keywords (array of strings with examples) and include_accounts (triggers account detail return). Also clarifies keywords is REQUIRED despite schema marking optional.

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

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

The description clearly states it searches bank connectors by name, returning specific fields like connector id, access type, audience, and connect_url. It distinguishes from sibling tools like 'connect' and 'marketplace' by specifying it is a pre-connection lookup.

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

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

Explicitly advises to call 'BEFORE connecting' and notes that keywords are required (provides hint otherwise). Implicitly guides when to use versus alternatives (prefer Open Finance connectors). Lacks explicit 'when not to use' but sufficient 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?

Beyond minimal annotations (readOnlyHint false, destructiveHint false), the description discloses key behaviors: it overrides automatic categorization, teaches Pluggy by creating a category rule, and explains batch error handling. This is rich, actionable transparency.

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

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

The description is concise and well-structured: starts with the main action, then parameter format, then side effects, then return shape. Every sentence adds value without redundancy.

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

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

Despite no output schema, the description includes the return shape (`{ updated, results, errors }`) and covers input, behavior, side effects, and error handling, making it fully complete for the tool's complexity.

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

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

Schema description coverage is 0%, but the description fully compensates by detailing the 'items' array structure, field sources (transaction_id from openfinance_list_transactions, category_id from openfinance_list_categories), and the effect of each parameter, providing complete semantic 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 corrects transaction categories (verb+resource) and distinguishes from siblings by referencing where to obtain required IDs (openfinance_list_transactions, openfinance_list_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?

Explicitly states the purpose ('fix miscategorized transactions') and explains the side effect of creating a category rule, guiding the agent on when to use. Lacks explicit when-not-to-use but provides strong contextual guidance.

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

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

Annotations declare idempotentHint=true and destructiveHint=false. The description adds that the tool reports bugs but does not clarify the idempotency behavior or what happens after submission. It does not contradict annotations, but also does not significantly enhance behavioral understanding beyond 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 concise sentence that front-loads the purpose. No wasted words, and every part is necessary.

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

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

Given the lack of output schema and incomplete parameter descriptions, the description provides the core idea but leaves out details on how to effectively use all parameters. It is minimally complete for a straightforward feedback tool.

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

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

With 0% schema description coverage, the description must compensate. It hints that the 'conversation' parameter should contain recent messages, but does not explain 'message' or 'context' parameters. This provides only partial guidance for the 3 parameters.

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

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

The description clearly states the tool is for reporting bugs, missing features, or sending feedback. The verb 'report' and resource 'bug/feedback' are specific, and the tool is clearly distinct from sibling tools that focus on financial operations.

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

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

The description provides clear context: include the conversation array with recent messages for reproduction. However, it does not explicitly state when not to use the tool or mention alternatives, but the usage is self-explanatory for a feedback 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds that it outputs platform and adapter versions, which goes beyond the annotations by specifying the content.

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 perfectly concise and front-loaded.

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

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

Given the tool has zero parameters and no output schema, the description provides sufficient context. It could optionally detail the output structure, but the current description is adequate for a simple version query.

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 (schema coverage 100%), so there is nothing to explain. The description correctly omits parameter details, and the baseline for 0 params is 4.

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

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

The description clearly states the tool shows current MCP platform and adapter versions, which is a specific verb-resource pair. It distinguishes itself from sibling tools that perform operations on financial data 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 usage is self-evident: call when version info is needed. No explicit when-not or alternatives are given, but the simplicity and lack of parameters make such guidance unnecessary.

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, destructiveHint=false, idempotentHint=true. Description adds specifics about what data is returned (installed MCPs, connection status, tool counts), providing useful 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?

Single sentence, no fluff. Clearly communicates the output value. 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?

Given zero parameters and low complexity, the description fully explains the tool's return value. No output schema needed as description is sufficient.

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 parameter semantics are fully covered by the schema (100% coverage). Baseline 4 for 0 parameters 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?

Description specifically states 'returns the current toolkit state: installed MCPs, their connection status, and how many catalog tools each exposes.' This clearly distinguishes it from sibling tools which are mostly about financial 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?

No explicit when-to-use or when-not-to-use guidance is provided. The purpose implies usage for inspecting toolkit state, but lacks alternatives or exclusions.

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