Pagar.me

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

Adds context beyond annotations: explains that calling with no args returns a login link, and that adding to config provides non-expiring access. No contradictions with annotations (idempotentHint=true is consistent with safe operations).

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 concise paragraph front-loaded with purpose. Efficiently covers both use cases. Slight verbosity in the 'best' phrasing, but well-structured.

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

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

For a simple tool with one optional parameter and no output schema, the description is complete. Explains both authentication paths. Missing explicit output info, but not critical.

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

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

Schema coverage is 0%, but the description compensates by explaining the token parameter: it's the JWT from browser login, optional, and for session-only login. Adds useful semantics beyond the schema.

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

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

The description clearly states the tool's purpose: authentication to MCP.AI for IDE agents. It distinguishes the two login methods (permanent config vs session token) and is distinct from sibling Pagar.me tools.

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

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

Provides explicit guidance on when to use each method: adding a permanent token to config vs pasting a token for session-only. Also gives a best practice recommendation. Does not explicitly exclude alternatives, but siblings are unrelated.

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 the tool as read-only, idempotent, and non-destructive. The description adds value by detailing the response structure (authenticated, pending, connect_url) 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 two sentences, front-loads the main purpose, and contains no wasted words. It efficiently communicates the tool's behavior.

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

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

Given no parameters, comprehensive annotations, and no output schema, the description sufficiently explains what the tool returns for all states, making it complete for an agent to use.

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 schema coverage is 100%. The description does not need to explain parameters, and it appropriately focuses on the response.

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 details on two scenarios. However, it does not explicitly differentiate from siblings like 'authenticate', which could be confused for a similar purpose.

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 the tool is used to check connection status, but offers no explicit when-to-use or when-not-to-use guidance compared to siblings like 'authenticate' or 'toolkit_info'.

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 works even when MCP not installed, returns connect/checkout links as needed, and install makes permanent. However, it does not clarify idempotency for actions like search or list_tools, and some write actions could be destructive without explicit mention.

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 and dense, packing extensive information into a single paragraph. While it front-loads the core flow, it could be more structured with bullet points or sections for readability. Every sentence adds value, but conciseness suffers.

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 (13 parameters, multiple actions, no output schema), the description covers the essential workflow, error handling, permissions, and key distinctions. It lacks details on return values (but no output schema provided) and rate limits, but overall it is sufficiently complete 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?

With 0% schema description coverage, the description explains most parameters: action values are detailed (search, describe, invoke, etc.), and core parameters like mcp_id, tool_id, arguments are described in context. However, some parameters like 'immediate', 'tier_slug', and 'conversation' lack explanation, leaving gaps.

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

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

The description clearly states that marketplace is the official mcp.ai catalog and provides a comprehensive overview of its actions (search, describe, invoke, install, etc.). It distinguishes itself from sibling tools by explaining it handles MCP management, while siblings like pagarme_* are specific payment 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 gives explicit guidance: 'when the user wants a capability... use THIS tool FIRST' and contrasts invoke (one-off) vs install (permanent). It also notes that write actions require workspace owner/admin, helping the agent decide when to use this tool versus 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?

The description adds valuable behavioral details beyond annotations: it notes irreversibility ('Irreversível') and bulk execution support. This aligns with the destructiveHint=true annotation and readOnlyHint=false, with 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 exceptionally concise: two sentences with no extraneous text. The first sentence delivers the primary purpose, and the second adds bulk capability. Information is front-loaded and every word earns its place.

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

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

Given the tool's complexity (destructive, bulk support, no output schema), the description covers key aspects: action, required fields, irreversibility, and bulk execution. It could mention expected outcomes or error handling, but overall it is sufficiently complete for an experienced user.

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 description coverage at 0%, the description must compensate. It clarifies that customer_id and card_id are required, and introduces bulk parameters (customer_ids, card_ids). However, it does not explain the 'account' parameter or the exact format/usage of arrays, 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 the verb 'Remove', the resource 'cartão salvo do cliente', the API version 'V5', and the required parameters. It effectively distinguishes this tool from sibling tools like pagarme_cards_get, pagarme_cards_list, and pagarme_cards_write_create by being the deletion 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 explicitly lists required parameters (customer_id, card_id) and mentions bulk support via customer_ids and card_ids arrays. While it does not explicitly state when not to use this tool or mention alternatives, the context makes it clear that this is for deletion, and the irreversibility warning provides guidance on appropriate 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 indicate read-only and idempotent behavior. The description adds bulk support but introduces conflicting actions (list vs. get) and does not clarify behavior 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 brief and uses bullet points, but the bracket notation and flattening comment are slightly confusing. It is concise but sacrifices 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 lack of output schema and 5 parameters, the description covers the main use cases but omits details about the 'account' parameter and the distinction between list and get operations.

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

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

The description explains that customer_id is required and that card_id and card_ids are for specific get and bulk operations. However, the 'account' parameter is left unexplained, and the schema has 0% coverage, so the description partially compensates 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 identifies the resource as saved cards of a customer and the actions as list and get. However, the presence of a sibling tool 'pagarme_cards_list' creates ambiguity about differentiation, and the flattening notation adds confusion.

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 states that customer_id is required and mentions bulk support, but it does not explicitly compare this tool to alternatives like pagarme_cards_list or pagarme_cards_delete, leaving usage context weak.

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, destructiveHint, and idempotentHint. The description adds bulk support behavior but does not cover other traits like pagination or rate limits.

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 concise and front-loaded with the main purpose. Minor clutter from mentioning 'get' action in a list tool.

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

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

No output schema exists, and the description fails to describe return values, pagination, or limits. This leaves significant gaps for an agent using the tool.

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

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

With 0% schema description coverage, the description partially compensates by explaining customer_id and bulk parameters. However, it omits the 'account' parameter and does not provide per-parameter details.

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

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

The description clearly states it lists saved cards of a customer, distinguishing between list and get actions, and explicitly flattens to list. It differentiates from the sibling pagarme_cards_get 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?

The description mentions that actions require customer_id and supports bulk execution, but does not explicitly state when to use this tool instead of alternatives like pagarme_cards_get.

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 value beyond annotations by detailing actions (create tokenizes, renew uses card_id) and bulk support. 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?

Relatively concise with bullet points and front-loaded purpose. Could be more structured 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?

Covers main use cases and bulk mode but lacks explanation of return value, error handling, and idempotency. With no output schema, description should provide more clarity on outputs.

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

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

Schema coverage is 0%, so description must compensate. It explains customer_id, data (with sub-fields), card_id, and bulk arrays, but omits account parameter. Partially helpful.

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

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

Description clearly states it creates/renews cards for a customer, distinguishes between create and renew actions, and lists required fields. Differentiates from sibling pagarme_cards_write_renew.

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 create vs renew, mentions requirement of customer_id, and notes bulk support. Does not explicitly state when not to use or alternatives beyond the renew sibling.

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

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

Annotations are all false, so description must add behavioral insights. It mentions the API version (V5), secret key requirement, and actions (tokenize for create, renewal with card_id). Lacks details on side effects, error behavior, or idempotency. Adds value but not comprehensive.

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 somewhat concise but messy: mixed Portuguese/English, bullet points, and an extra tag '[Flattened action: renew]'. Information is present but could be better organized. First sentence sets purpose adequately.

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 (two actions, bulk support, 6 parameters, no output schema), the description covers actions and key parameters but omits output details, error handling, and precise data type for 'data'. Account parameter is unexplained. Adequate but has gaps.

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

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

Schema description coverage is 0%, so description is crucial. It explains customer_id as required, card_id for renew, and bulk arrays (customer_ids, card_ids). For 'create' action, it lists fields (number, holder_name, etc.) but suggests 'data' is an object, conflicting with schema type 'string'. Does not explain 'account' parameter.

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 states the tool is for creating/renewing cards in Pagar.me V5, specifying actions 'create' and 'renew'. It distinguishes from siblings like pagarme_cards_write_create by including both actions, but the 'Flattened action: renew' tag introduces ambiguity. Overall, the verb+resource is clear.

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

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

Provides some context: requires customer_id, mentions bulk support with customer_ids and card_ids. However, it does not explicitly state when to use this tool vs the sibling pagarme_cards_write_create or exclude scenarios. The dual action (create/renew) could confuse about which tool handles creation.

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 'Irreversível' (irreversible), which aligns with the destructiveHint annotation. It also mentions partial refund capability via amount. However, no additional behavioral traits (e.g., auth needs, rate limits, effects on related data) are disclosed 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 extremely concise: two sentences that front-load the essential action (cancel/refund), required param, and optional features (partial refund, bulk). No wasted words, and the bulk support is logically placed.

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 4-parameter tool with no output schema, the description covers the main purpose, required param, optional param use (amount for partial), and irreversibility. However, it does not explain the 'account' parameter or the exact structure of 'data', leaving some contextual 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?

With 0% schema coverage, the description partially compensates by explaining charge_id (required), data with amount for partial refund, and charge_ids for batch. But 'account' parameter is unexplaind, and 'data' format (likely JSON) is not specified, leaving gaps.

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

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

The description clearly states it cancels/refunds a charge ('Cancela/estorna uma cobrança'), specifies the API version (Pagar.me V5), and mentions key operations like partial refund and batch execution. This distinguishes it from sibling tools like capture or confirm.

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 mentions required parameter (charge_id) and optional data for partial refund, and notes bulk support. However, it does not explicitly contrast with alternative tools or provide when-not-to-use guidance, though the context of charge cancellation is clear.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds the term 'flattened action: get' without explanation and mentions parameters for other actions, but does not clarify behavioral nuances for the get action specifically.

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 short but poorly structured. It attempts to cover multiple actions in a single block, leading to ambiguity. The note about 'flattened action' is unclear and the list of actions is not formatted for easy 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?

For a read-only get operation with no output schema, the description should detail how to use charge_id and what to expect in return. Instead, it includes irrelevant parameters and fails to provide sufficient context 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?

Schema description coverage is 0% and the description provides no explanation of parameters like data, page, size, account, charge_id, or charge_ids in the context of a 'get' action. The agent has no guidance on how to use these 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 lists multiple actions (list, summary, get, get_many) but then states 'Flattened action: get', creating confusion about the actual tool purpose. The name suggests a single get operation, and sibling tools exist for the other actions, making the description misleading.

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

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

No explicit guidance on when to use this tool versus sibling tools like pagarme_charges_list or pagarme_charges_get_many. The description lists alternative actions but does not direct the agent to the appropriate tool for each.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds minimal behavioral context beyond confirming it's a read operation. No contradictions.

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

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

The description is verbose, listing multiple actions before focusing on get_many. The critical information is buried at the end after a long list of unrelated operations. The format is not front-loaded or concise.

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

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

Given 6 parameters, 0% schema coverage, no output schema, and the complexity of a 'flattened action', the description is incomplete. It fails to explain parameter usage, required fields, or output format, leaving the agent underinformed.

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 needed to explain parameters. It only mentions 'charge_ids' for get_many, ignoring other schema properties (data, page, size, account, charge_id) that might be irrelevant or misapplied. The 'flattened action' note adds confusion about which parameters apply.

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 states 'get_many: vários por charge_ids (lote)' and the tool name includes 'get_many', clearly indicating batch retrieval of charges by IDs. However, the description also lists other actions (list, summary, get) which could cause confusion about which action this tool truly performs.

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?

Usage is implied: use this tool when needing multiple specific charges by IDs. But there is no explicit guidance on when to use alternatives like pagarme_charges_get or pagarme_charges_list, nor any 'when not to use' statements.

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; description adds pagination/filter details but no additional behavioral traits like rate limits or security. No contradiction, but minimal added 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?

Includes full list of unrelated actions (summary, get, get_many) before stating flattened action, causing clutter. Could be more direct about the list-only scope.

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?

Missing explanations for several parameters and no output format description. For a 6-param tool with no output schema, the description leaves gaps in understanding behavior and response.

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?

Partially explains 'data' (filters) and 'page'/'size', but does not describe 'account', 'charge_id', or 'charge_ids' which may be irrelevant or confusing given the flattened list action. Schema has 0% 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?

Description clearly states 'list' action for charges with pagination and filters, distinguishing it from sibling get/summary tools. Verb and resource are specific, and the flattened action indicator clarifies this tool's exact purpose.

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

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

No explicit guidance on when to use list versus other charge tools (e.g., get, summary). The description implies usage for paginated listing but lacks direct comparison or exclusion criteria.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description, however, mentions multiple actions (including list and get) that may not all produce a summary, making it misleading. No contradiction with annotations, but transparency is poor.

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 and poorly structured. It redundantly lists actions, includes a flattened action note, and lacks clear organization. Essential information is buried, making it inefficient for an agent to parse.

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

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

Given the absence of an output schema and the complexity of multiple possible actions, the description is highly incomplete. It fails to explain return values, authentication needs, rate limits, or how the tool behaves relative to siblings. An agent cannot reliably use this tool based on the description alone.

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 explain parameters but does so inadequately. It mentions filters like 'status, payment_method, customer_id' under 'data' but does not map them to the schema's 'data' string parameter or clarify format. Other parameters (page, size, charge_id) are listed without explanation.

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 lists multiple actions (list, summary, get, get_many) but then declares '[Flattened action: summary]', causing confusion about the tool's actual purpose. It fails to provide a clear verb+resource distinction from sibling tools like pagarme_charges_list and pagarme_charges_get.

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

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

No guidance is provided on when to use this summary tool versus the numerous sibling charge tools (e.g., pagarme_charges_list, pagarme_charges_get_many). The description hints at filters but does not specify usage context or exclusions.

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

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

Annotations already declare destructiveHint=false and readOnlyHint=false. The description adds that the tool is non-destructive (redundant) and only works with sk_ accounts, plus mentions bulk support and that actions require charge_id. It does not detail side effects, error behavior, or return values, but the added context is modestly 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?

The description uses clear structure with a bullet list for actions and mentions bulk support. It front-loads the purpose and constraints (sk_ accounts, non-destructive). The 'Flattened action: capture' is slightly cryptic, but overall it is reasonably concise and well-organized.

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

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

Given the lack of output schema and the tool's complexity (multi-action, bulk support), the description covers main actions and data hints but leaves gaps: no explanation of return values, error handling, or the behavior of bulk vs single execution. The sibling tools suggest this tool might be redundant, but the description does not clarify its unique role.

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

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

The schema has 0% parameter descriptions, so the description must compensate. It explains that charge_id is required and data is optional with specific formats for some actions (e.g., capture: amount; update_due_date: due_at). However, it does not explain the 'account' parameter or the format of data for all actions, leaving gaps. The charge_ids parameter is mentioned for bulk support. Overall, partial but 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 tool operates charges in Pagar.me V5 for sk_ accounts and lists multiple possible actions (capture, retry, etc.). However, the existence of sibling tools for each action (e.g., pagarme_charges_write_confirm) creates ambiguity about whether this tool is a combined super-tool or specifically for capture. The 'Flattened action: capture' hint partially resolves this but is not fully clear.

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

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

The description provides no explicit guidance on when to use this tool vs its siblings. It mentions bulk support but does not compare with the separate write tools for each action. The 'Flattened action: capture' suggests it might be for capture specifically, but this is not stated outright, leaving an agent without clear decision criteria.

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 non-readOnly and non-destructive. The description reinforces 'não-destrutivas' and adds bulk support via charge_ids, which is helpful. However, it does not disclose idempotency (hint false), rate limits, or side effects. The Portuguese language may also reduce transparency. Overall, adds some value but is not comprehensive.

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 concise but contains redundancy (listing multiple actions when the tool is likely single-purpose) and mixes languages (Portuguese/English). The structured list of actions could be shortened. Still, it is not overly long.

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

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

Given the lack of output schema and the presence of multiple sibling tools, the description is incomplete. It does not explain return values, error handling, or the required format for the 'data' parameter. The bulk support mention is useful, but overall the agent would need additional documentation to use this tool correctly.

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

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

The input schema has 0% description coverage on parameters. The description only mentions 'data opcional' for some actions but does not specify its format (e.g., JSON structure for 'amount' or 'due_at'). No explanation for 'account' or the relationship between 'charge_id' and 'charge_ids'. This is a major 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 states it operates charges in Pagar.me V5 and lists multiple actions, but the tool name 'confirm' and the '[Flattened action: confirm]' line indicate it is specifically for the confirm action. The inclusion of other actions (capture, retry, etc.) creates ambiguity, as sibling tools exist for those actions. This harms clarity despite specifying the resource.

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

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

The description mentions it's for non-destructive operations on 'sk_' accounts, but does not explicitly guide when to use this tool versus siblings like pagarme_charges_write_capture. The list of actions could mislead the agent into thinking this tool handles multiple operations, whereas it is likely only for confirm. No 'when not to use' guidance is given.

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 non-destructive and read-write behavior. The description adds the account prefix constraint ('só contas sk_') and bulk support, which are helpful. However, it does not disclose rate limits, error handling, or idempotency. Adequate but not comprehensive.

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 sized but includes a redundant list of actions not relevant to this specific tool, which adds clutter. The key information (retry focus, bulk support) is present but could be more front-loaded and concise.

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

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

The tool has 4 parameters and no output schema, yet the description fails to explain the return value or common errors. It does not verify that the tool only performs retry, leaving contextual gaps. Missing critical information for agent decision-making.

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 but only minimally. It mentions 'data' as optional for some actions but does not describe its format or the meaning of 'account' or 'charge_ids'. The agent is left guessing about parameter usage.

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

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

The description lists multiple actions (capture, retry, confirm, etc.) but the tool is specifically for 'retry' as indicated by the flattened action. This creates ambiguity and fails to clearly distinguish from sibling tools like pagarme_charges_write_capture. The verb 'operar' is vague.

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 retry via '[Flattened action: retry]' and mentions bulk support and account prefix constraint, but does not explicitly tell the agent when to use this tool over alternatives. It lacks when-not-to-use guidance and does not reference sibling 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?

The description notes it is non-destructive (aligning with annotations), applies only to 'contas sk_' (account prefix restriction), and supports bulk execution via charge_ids. These details add value beyond the annotations, though more specifics on the update_card behavior (e.g., what exactly changes) would improve 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 organized with a bullet list, but it includes actions unrelated to this tool, which adds unnecessary length and potential confusion. It could be more concise by focusing solely on the update_card action.

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

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

Given the lack of output schema and 4 parameters, the description covers account restrictions, non-destructiveness, and bulk support. However, it omits crucial details about the data parameter for update_card and does not address potential edge cases or prerequisites. It is adequate but not thorough.

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 provides minimal parameter explanation. For update_card, it only says 'altera cartão (data)' without specifying the structure of the data parameter. This leaves the agent without sufficient guidance on how to construct the input.

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 states 'Operar cobranças no Pagar.me V5' and lists update_card as one of the actions, but it also includes other actions like capture, retry, etc., which are served by separate sibling tools. The final line 'Flattened action: update_card' clarifies that this specific tool is for update_card, so the purpose is generally clear but somewhat muddied by extraneous 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?

No explicit guidance on when to use this tool versus its siblings (e.g., pagarme_charges_write_capture). The description lists multiple actions that have dedicated sibling tools, which could mislead an agent into thinking this tool can perform those actions, when it should only be used for updating the card.

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

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

Description adds context beyond annotations: it specifies Pagar.me V5, 'só contas sk_' (only sk_ accounts), and 'não-destrutivas' (non-destructive). This aligns with destructiveHint=false and readOnlyHint=false. However, it does not detail the specific effects of update_due_date (e.g., what happens to the charge, whether it can be reversed).

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 for a tool that only does update_due_date, listing extraneous actions. It could be significantly shortened to focus on the relevant action. The structure is cluttered with irrelevant details.

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

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

Given no output schema, the description should explain return behavior or outcomes, which it does not. It mentions bulk support (charge_ids) but fails to detail the 'data' parameter format or any success/failure indicators. Incomplete for a write operation.

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%. The description mentions 'data: { due_at }' for update_due_date, but the 'data' parameter is not explained in the context of the schema. Other parameters (account, charge_ids) are not described at all, leaving the agent without meaning to interpret the input fields.

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 states 'Operar cobranças no Pagar.me V5' and specifically mentions 'update_due_date' as a flattened action, so the core purpose is somewhat clear. However, it lists several other actions (capture, retry, confirm, etc.) that are likely covered by sibling tools, causing confusion and diluting the specific purpose of this 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 guidance on when to use this tool versus alternatives like pagarme_charges_write_capture or pagarme_charges_write_update_card. The description only indicates required parameters (charge_id) but does not provide context for selection.

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

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

Annotations indicate non-destructive, and description confirms 'não-destrutivas' and adds account-scope ('só contas sk_') and bulk support. No contradictions. Adds value beyond annotations by specifying action details and account prefix.

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?

Front-loaded with key scope and constraints. The multi-action list adds minor length but provides useful context. Mostly concise with no filler.

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 should mention return values but doesn't. It covers essential aspects: action, required fields, bulk support, non-destructiveness. Adequate but lacks error handling or response 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 has 0% description coverage. Description partially compensates by explaining 'data' for the payment method update and implying charge_id is required, but 'account' parameter remains unexplained. Insufficient to fully compensate for missing 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 operates charges on Pagar.me V5 for the specific action 'update_payment_method'. It distinguishes from siblings by listing multiple actions but then explicitly marking the flattened action, avoiding confusion with sibling tools like pagarme_charges_write_capture.

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 context: only for accounts starting with 'sk_', non-destructive, requires charge_id, and supports bulk via charge_ids. However, it lacks explicit when-not-to-use or alternatives, relying on sibling tool names for differentiation.

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

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

Annotations declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. Description adds bulk support for customer_ids and address_ids, which is useful 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?

Poorly structured: starts with Portuguese, lists actions with inconsistent formatting, then an unclear flattening note, and bulk support last. Not front-loaded or cleanly organized.

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

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

With 8 undocumented parameters, no output schema, and many siblings, the description is insufficient. It does not explain return values, parameter formats, or when each sub-action applies.

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

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

Schema coverage is 0%, so description must compensate. It vaguely associates some parameters with actions (e.g., page, size for list) but leaves many parameters (data, account, address_id, etc.) unexplained, failing to add sufficient 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 lists multiple actions (list, get, list_addresses, get_address) but then says 'Flattened action: get', creating confusion about the actual tool purpose. The name suggests a single get operation, but the description implies multiple capabilities.

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

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

No guidance on when to use this tool versus siblings like pagarme_customers_list or pagarme_customers_get_address. The description mentions other actions but does not provide selection criteria or exclusions.

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

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

While annotations indicate read-only and idempotent, the description adds bulk support but also includes misleading action listings. The internal contradiction undermines transparency about the tool's actual behavior.

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

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

The description is somewhat cluttered with a redundant action list and a note about bulk support. It could be more concise by focusing solely on get_address and its parameters.

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 8 parameters and no output schema, the description is incomplete. It does not explain what the tool returns, edge cases, or how to handle missing IDs. The bulk support hint is useful but insufficient.

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 must explain parameters. It mentions customer_id, address_id, customer_ids, address_ids as relevant but ignores data, page, size, account, which appear to be leftover from other actions. No full parameter context 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 lists multiple actions (list, get, list_addresses, get_address) but states 'Flattened action: get_address', which contradicts the tool's actual purpose. This confuses whether the tool performs one action or multiple, reducing clarity.

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

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

No explicit guidance on when to use this tool versus siblings like pagarme_customers_list_addresses. The description mentions required parameters for get_address but does not differentiate usage contexts.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, covering safety. The description adds that it is a list action with pagination and bulk support, but does not elaborate on behavior beyond that.

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 long and poorly structured, mixing multiple actions and using Portuguese and English. The first sentence is generic and unnecessary. It could be condensed to just the list action details.

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

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

Given 8 parameters, no required fields, and no output schema, the description is incomplete. It does not explain return format, how parameters like 'data' or 'account' affect results, or how to use bulk parameters 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 description must compensate. It only mentions some parameters (page, size, data) for the list action, but ignores others (account, customer_ids, address_ids) or mixes them with other actions. The bulk support statement is vague and potentially misleading for the list purpose.

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 'list: lista clientes (page, size; data: name, email, document, code)', indicating the primary purpose of listing customers with pagination. However, the inclusion of other actions (get, list_addresses, get_address) adds noise but does not obscure the main purpose.

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

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

No explicit guidance on when to use this tool over sibling tools like pagarme_customers_get or pagarme_customers_list_addresses. The description only lists actions without contextual usage 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 indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds minimal behavioral context beyond confirming it is a list operation. It does not disclose rate limits, authentication needs, or any other behavioral traits 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 not concise; it includes information about other actions not relevant to this tool (list, get, get_address) and a confusing '[Flattened action: list_addresses]' line. For a tool focused on listing addresses, extraneous content should be removed.

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 8 parameters, no output schema, and zero schema descriptions, the description is severely incomplete. It fails to explain key parameters like 'account' or 'data', and does not describe the response format, making it difficult for an agent to invoke 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 compensate. It explains that customer_id is required for list_addresses and mentions bulk support for customer_ids and address_ids, but many parameters (data, account, page, size, address_id) are left unexplained. This is insufficient for a schema with 8 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 mentions 'list_addresses' as one action and states it requires customer_id, but also includes extraneous information about other actions (list, get, get_address), which dilutes the clarity. The tool name is clear, but the description could be more focused.

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

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

The description does not provide explicit guidance on when to use this tool versus alternatives like pagarme_customers_get_address. It mentions that list_addresses requires customer_id and supports bulk operations, but lacks when-not or comparative 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?

The description discloses that the tool uses sk_ keys and requires specific parameters for each action (e.g., customer_id, address_id). It covers the destructive delete_address action, which annotations mark as non-destructive (false). While annotations indicate destructiveHint=false, the description correctly notes it removes addresses, adding 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?

The description is structured with bullet points and front-loaded with the main purpose. It is detailed but could be slightly more concise (e.g., 'só sk_' may be unnecessary). Overall, it efficiently conveys a lot of 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 tool's complexity (6 parameters, multiple actions, no output schema), the description covers actions, parameter requirements, and bulk support. Missing details include the 'account' parameter and return behavior, but the description is largely complete for an AI agent to use the tool correctly.

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

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

With 0% schema coverage, the description must compensate. It explains the role of customer_id, address_id, customer_ids, and address_ids, but fails to describe the 'account' parameter and the format of the 'data' parameter (only says it contains fields like name, email, etc., but not that it's a JSON string). This is a gap.

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

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

The description clearly states the tool's purpose: to create, update, and delete customers and addresses in Pagar.me V5. It lists specific actions (create, update, create_address, update_address, delete_address) and mentions bulk support, distinguishing it from sibling read-only 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 guidelines for each action, e.g., 'update requires customer_id' and 'create_address requires customer_id'. It also mentions bulk support. However, it does not explicitly state when to use this combined tool versus separate sibling tools like pagarme_customers_write_create_address, leaving some ambiguity.

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

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

Annotations declare destructiveHint=false, but the description includes delete_address, which is destructive. This is a direct contradiction. Also, no mention of required permissions or side effects for update/delete operations.

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 concise but contains redundant listing of actions and a confusing 'flattened action' note. Could be streamlined by focusing on the specific action of the tool.

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 multi-action tool with bulk support, the description lacks guidance on action selection and bulk execution details. No output schema, so return format is unknown. Incomplete for an agent to use reliably.

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

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

Schema coverage is 0%, so description must compensate. It partially explains customer_id and data for create_address but ignores account, address_ids, customer_ids. No details on format or constraints for data parameter.

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 lists multiple actions (create, update, create_address, update_address, delete_address) but states a flattened action of create_address, creating confusion about the tool's exact purpose. It does not clearly distinguish from sibling tools like pagarme_customers_write_create or pagarme_customers_write_delete_address.

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 clear guidance on when to use this tool versus separate sibling tools for individual operations. The description lists actions but does not explain selection criteria for the flattened action. No examples or context for bulk usage.

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

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

The description states required fields for deletion (customer_id, address_id) and bulk support, but it contradicts the annotation destructiveHint=false since deleting an address is destructive. This inconsistency reduces 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 includes unnecessary details (full action list) for a tool focused on deletion. The 'Flattened action' note helps, but the structure could be more streamlined.

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 required fields and bulk support but lacks details on error handling, idempotency, or what happens if the address does not exist. Given no output schema, more context would be beneficial.

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 adds significant meaning by explaining which parameters are required for the delete action (customer_id, address_id) and how arrays (customer_ids, address_ids) support bulk operations, though it doesn't describe every parameter.

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 indicates the tool is for deleting an address ('Flattened action: delete_address'), but the initial listing of multiple actions (create/update) is confusing and suggests multiple purposes beyond deletion.

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

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

No explicit guidance on when to use this tool versus alternatives like create or update address tools. The mention of bulk support is helpful but does not provide usage boundaries.

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

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

Description includes 'delete_address' which is a destructive action, but annotations set destructiveHint to false. This is a direct contradiction. No additional behavioral context beyond action requirements.

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 structured by action and relatively concise, but includes unnecessary elements like '[Flattened action: update]' and mixed languages. Could be more focused.

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. No information about return values, error handling, or success criteria. For a multi-action tool with no output schema, completeness is poor.

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 parameter coverage is 0%. Description provides some context for 'customer_id', 'address_id', and bulk 'customer_ids', 'address_ids', but does not explain 'data' format or 'account'. Insufficient compensation for missing 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?

Description lists multiple actions (create, update, create_address, update_address, delete_address) but the tool name suggests only 'update'. The 'Flattened action: update' note is confusing. While it specifies verb+resource, it does not clearly distinguish from sibling tools like pagarme_customers_write_create or pagarme_customers_write_update_address.

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

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

No guidance on when to use this combined tool versus individual sibling tools. No when-to-use, when-not-to-use, or prerequisites. The description lacks context for action selection.

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

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

Mentions bulk support and batched execution, adding behavioral context beyond annotations. However, annotations already indicate read-only=false and destructive=false, yet delete_address is included, creating a contradiction. Description does not address authentication details beyond 'só sk_.'

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?

Relatively concise but mixes Portuguese and English, reducing clarity. Action list is clear, but structure could be improved (e.g., separate sections).

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?

Complex tool with 6 parameters and multiple actions. Description lacks explanation of output, error handling, or format of the 'data' parameter. No output schema, so more 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?

Schema coverage is 0% and description partially compensates by explaining which IDs are required per action. However, the 'data' parameter (a string) is not explained, nor is 'account.' The description does not fully cover semantics of all 6 parameters.

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

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

The description clearly states it handles creating/updating customers and addresses in Pagar.me V5, listing specific actions. It distinguishes itself from sibling tools (e.g., separate tools for create, update, delete).

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?

Implicitly guides which IDs are needed per action, but lacks explicit when-to-use vs alternatives like the separate write tools (e.g., pagarme_customers_write_create). No exclusion criteria or prerequisites mentioned.

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

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

Annotations already mark destructiveHint=true; description adds 'Irreversível' and bulk support, providing extra context beyond annotations 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 front-load key info (action, required parameter, irreversibility, bulk support) with no redundant 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 low complexity and no output schema, the description sufficiently covers purpose, required parameter, and bulk variant, though lacks details on response or errors.

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 adds meaning by noting invoice_id is required and invoice_ids enables bulk execution, compensating for the schema gap.

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

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

The description clearly states the tool cancels an invoice in Pagar.me V5, distinguishing it from sibling tools like get, list, and write which are for other 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?

It indicates the required invoice_id and mentions irreversible action, but does not explicitly state when to avoid use or provide alternatives. Sibling context implies usage boundaries.

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, covering basic safety. The description adds context about bulk support and parameter usage for list/get actions. However, it does not fully explain behavior (e.g., what 'data' parameter expects, how bulk invocation works). 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 relatively short and includes both Portuguese and English. It contains the unnecessary phrase '[Flattened action: get]' which adds confusion. The structure is acceptable but could be more streamlined and clear.

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

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

Given the tool's complexity (multiple operations, 6 parameters, no output schema), the description lacks completeness. It does not specify return values, error conditions, or how to effectively use bulk support. The tool's dual nature (list and get) is not fully 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?

Schema description coverage is 0%, so the description must explain parameters. It partially covers 'page', 'size', and 'data' for list, and 'invoice_id' for get, but many parameters (account, invoice_ids) are not explained. The 'data' parameter is described as containing fields but is typed as string, causing confusion.

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 states it deals with 'Faturas (invoices) de assinatura no Pagar.me V5' and lists actions (list, get). However, the tool name is 'get' but it also includes list functionality, and there is a sibling tool 'pagarme_invoices_list' which should handle listing. This ambiguity reduces clarity on what this specific tool does versus its 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 guidance is provided on when to use this tool versus alternative siblings like pagarme_invoices_list, pagarme_invoices_cancel, or pagarme_invoices_write. The description lists actions but does not indicate preferred use cases or when not to use the 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 read-only and idempotent hints. The description adds bulk support context but includes a 'get' action that may mislead about behavior. No mention of rate limits or authorization.

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 short but includes redundant 'Ações:' and flattened action annotation. It front-loads the main purpose but could be cleaner without the get action 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?

With 6 parameters and no output schema, the description is very incomplete. It lacks usage details for parameters, response format, and the meaning of 'bulk support' beyond mentioning invoice_ids.

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%. The description only vaguely explains the 'data' parameter fields (subscription_id, etc.) but does not describe page, size, account, invoice_id, or invoice_ids parameters in detail.

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 states it lists subscription invoices, but also includes 'get' as an action, which is confusing because the tool is named 'list' and a separate 'pagarme_invoices_get' tool exists. The purpose is partially clear but muddled.

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

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

No explicit guidance on when to use this tool vs alternatives like pagarme_invoices_get. No exclusion or context for when to use invoice_id vs invoice_ids parameters.

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 show readOnlyHint=false, matching the write operation. The description adds that it changes status and supports bulk, but does not disclose potential side effects, prerequisites, or behavior for different status transitions.

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 extremely concise with two sentences, front-loading the core purpose and required parameters, then adding bulk support. 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?

For a simple status change tool with no output schema, the description covers the basics but lacks details on possible status values, restrictions, and behavior across different contexts. More context 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 description compensates partially by explaining 'status' with examples and mentioning 'invoice_ids' for bulk. However, 'account' parameter remains unexplained, and the distinction between 'invoice_id' and 'invoice_ids' could be clearer.

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

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

The description clearly states it alters the status of an invoice in Pagar.me V5, specifying the required parameters (invoice_id, status) and providing examples. It also distinguishes itself from siblings like 'pagarme_invoices_cancel' by supporting multiple statuses and bulk 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 explains when to use the tool (to change invoice status) and mentions required parameters, but lacks explicit guidance on when not to use it or comparisons with alternatives like 'pagarme_invoices_cancel'.

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 that it's a legacy API, mentions version differences in payload, and that filters are via 'data' JSON. However, it does not detail the balance response or behavior for the balance action specifically.

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

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

The description is verbose (9 lines) and includes a list of actions unrelated to balance. It is not front-loaded for the balance action, and the 'Bulk support' line adds confusion. Every sentence does not earn its place.

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

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

Given the complexity (multiple actions, legacy API, 4 params with no schema descriptions, no output schema), the description is incomplete. It lacks details on what the balance returns, how to specify the account, and the role of transaction_ids. The agent would struggle to use this tool correctly.

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

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

Schema has 0% description coverage. The description mentions 'data' for filters and 'account' for balance, but does not explain all four parameters clearly. The use of 'transaction_id' and 'transaction_ids' for a balance tool is confusing and not justified.

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 lists multiple actions (list_transactions, balance, etc.) despite the tool name 'balance', making the specific purpose unclear. The 'Flattened action: balance' line suggests balance is the intended action, but the inclusion of other actions and 'Bulk support: accepts transaction_ids for batched execution' muddles the purpose.

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

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

The description gives context about when the tool is active (legacy API with ak_ key) but does not compare it with sibling tools like pagarme_recipients_balance or other legacy tools. It lacks explicit guidance on when to use this tool versus 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 mark it as read-only and idempotent. The description adds valuable behavioral details: bulk support via transaction_ids, differences between API versions in the payload, and that list filters are passed via data JSON.

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 uses bullets and clear structure, but it includes multiple actions beyond the core 'get_transaction', making it longer than necessary. The flattened action notation is somewhat cryptic.

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 (multiple parameters, no output schema, legacy version variability), the description misses explaining the 'account' parameter and does not describe the return format. It also conflates multiple actions, reducing 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 transaction_id (required for get_transaction), transaction_ids (bulk), and that data is used for list filters. However, the 'account' parameter is not mentioned, leaving a 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 lists multiple actions (list, get, balance) but the tool name and flattened action indicate 'get_transaction'. This conflates multiple endpoints, creating ambiguity about the tool's primary purpose.

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?

Clearly states this tool is for legacy accounts using ak_ keys (not migrated to V5). This provides context for when to use it, though no explicit contrast with sibling legacy list tools is given.

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, destructiveHint=false, and idempotentHint=true. The description adds that it is a legacy API and supports bulk operations via transaction_ids. No contradictions, but the description does not add significant behavioral detail 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 includes a bullet list of multiple legacy actions, which is extraneous for a tool specifically named list_customers. It could be more concise by focusing only on the relevant action and avoiding 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 complexity (4 parameters, no output schema, legacy context), the description explains the legacy scope and filters but does not describe the output format or the purpose of the 'account' and 'transaction_id' parameters, leaving the agent insufficiently informed 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?

Schema description coverage is 0% so the description must explain parameters. It explains that 'data' is a JSON string for filter options like count, page, status, and that 'transaction_ids' supports bulk execution. However, 'account' and 'transaction_id' are not explained, leaving gaps.

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

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

The description clearly states the tool is for listing customers from the legacy Pagar.me API V1-V4, and notes it requires an ak_... key. It lists the endpoint among others but does not explicitly differentiate from the sibling tool pagarme_customers_list, though the legacy context implies a distinction.

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 specifies that this tool is active when using an ak_... key, meaning for non-migrated accounts. It lists the legacy endpoints and mentions filter parameters. However, it does not explicitly state when not to use it versus the modern API 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 read-only, idempotent, and non-destructive behavior. The description adds context about legacy API versioning, raw field differences across V1-V4, and bulk support via transaction_ids, which aids the agent in understanding variability.

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

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

The description is verbose and includes extraneous information about unrelated actions (list_transactions, balance, etc.) that are not relevant to this specific tool. A more focused description would improve usability.

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 legacy context and filtering mechanism but omits details about the response format, pagination behavior, and error handling. Given the lack of an output schema, these gaps reduce completeness for an 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?

The explanation that the 'data' parameter accepts filters (count, page, status) and 'transaction_ids' enables bulk execution is helpful. However, the roles of 'account' and 'transaction_id' for the list_payables action are not addressed, leaving ambiguity despite 0% schema coverage.

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

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

The description identifies the tool as listing payables via the legacy Pagar.me API (V1-V4) and specifies it activates for accounts using ak_ keys. However, it does not clearly differentiate from sibling tool pagarme_payables_list, which likely serves the same purpose for V5 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?

The description provides a condition for use (legacy API with ak_ keys) but lacks explicit guidance on when not to use this tool or alternatives (e.g., pagarme_payables_list for V5). The list of multiple actions dilutes focus.

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. The description adds that it is a legacy API call, supports bulk via transaction_ids, and filters via data JSON, providing useful 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 verbose and lists many irrelevant actions for this specific tool. The 'Flattened action' note helps but the clutter reduces conciseness and focus.

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 legacy context, filter mechanism, bulk support, and field differences. Missing explanation of 'account' parameter and response format, so not fully complete for a tool without output schema.

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

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

Schema coverage is 0%, but the description explains that filters go in the 'data' parameter and mentions 'transaction_ids' for bulk. It does not explain 'account' or 'transaction_id', so coverage is incomplete.

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

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

The description lists many actions including 'list_plans', but the tool name specifically indicates listing plans. The purpose is somewhat clear but cluttered with other actions, reducing clarity.

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

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

Provides explicit context: 'Ativa quando a conexão usa uma chave ak_… (contas ainda não migradas pra V5).' This guides when to use this legacy tool versus possibly newer 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 readOnlyHint=true and idempotentHint=true. The description adds that this is a legacy legacy API, explains filter passing via 'data' JSON, and mentions bulk support with transaction_ids, providing useful 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 verbose with a bullet list of many actions that are not directly relevant to the tool's flattened action. This reduces conciseness and could distract the AI agent.

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

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

The description covers the legacy context, filter mechanism, and bulk support. However, it lacks any information about the output format or return values, which is needed since there is no 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?

With 0% schema coverage, the description must explain parameters. It describes 'data' as containing filters (count, page, status) and mentions 'transaction_id' and 'transaction_ids'. However, 'account' is not explained, leaving one parameter without 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 explicitly states 'Flattened action: list_recipients' and mentions it's for the legacy Pagar.me API, making the tool's purpose clear. However, the preceding bullet list of other actions (list_transactions, etc.) could confuse an AI agent about the tool's specific function.

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 condition for use ('Ativa quando a conexão usa uma chave ak_…') implying it's for legacy accounts not migrated to V5. It does not explicitly contrast with sibling tools like pagarme_recipients_list, leaving the alternative unclear.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the tool is safe. The description adds valuable behavioral details beyond annotations, such as bulk support via transaction_ids and filter parameters via data JSON. No contradictions with annotations are 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 moderately structured but includes an extensive list of actions that are not all relevant to this specific tool. It could be more concise by focusing solely on list_subscriptions behavior and parameters, reducing extraneous 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 tool's complexity (4 params, no output schema, no nested objects), the description covers the legacy context, filtering via data, and bulk support. However, it fails to explain the 'account' parameter, describe the output format, or explicitly differentiate from sibling subscription tools, leaving some 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?

With 0% schema coverage, the description must explain parameters. It partially explains 'data' as a JSON for list filters and 'transaction_ids' for bulk support. However, 'account' and 'transaction_id' are not explained within the context of list_subscriptions, leaving gaps. The description compensates somewhat 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 identifies the tool as for reading the legacy Pagar.me API V1-V4 and lists list_subscriptions as one of its actions. It specifies the legacy context and the 'Flattened action' note ties it to list_subscriptions, making the purpose clear. However, the inclusion of many other actions in the same description may cause confusion about what this specific tool does.

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 mentions that the tool activates when using an ak_... key (legacy accounts not migrated to V5), providing a context for when to use it. However, it does not explicitly compare it to sibling tools like pagarme_subscriptions_list or state when not to use it, so guidance is implied but not explicit.

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. Description adds useful context: legacy nature, bulk support via transaction_ids, filter capabilities via data parameter, and raw field differences across versions. No contradictions with annotations.

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

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

Description is somewhat lengthy and mixes Portuguese/English. It front-loads key context but includes a bullet list of actions that could be streamlined. Some redundancy (e.g., mentioning legacy version multiple times).

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 (legacy API, multiple actions, 4 params, no output schema), description covers usage trigger, bulk support, and filter behavior. However, it omits details on return format, error scenarios, and account parameter semantics, leaving gaps for an agent to fully invoke the tool correctly.

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

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

Schema coverage is 0%, so description compensates partially: explains 'data' (filters), 'transaction_id' (required for get), and 'transaction_ids' (bulk support). However, 'account' parameter is not explained, and no details on value formats or constraints are 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?

Description clearly states it is for listing transactions from legacy Pagar.me API V1-V4, activated when using ak_ keys. It differentiates from sibling legacy list tools by specifying the 'transactions' model, though it also lists other actions which slightly dilutes focus.

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 explains when to use (ak_ key, legacy accounts) and mentions alternate actions available within the same tool, but does not explicitly guide when to prefer this tool over other legacy list tools or modern API tools. Lacks explicit 'when not to use' instructions.

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

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

Description adds value beyond annotations by detailing filter support via the 'data' parameter, bulk execution with 'transaction_ids', and legacy version field differences, though annotations already indicate it is read-only and idempotent.

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 long and cluttered, listing many actions irrelevant to 'list_transfers', which dilutes the key message and violates conciseness.

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

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

Despite providing legacy context and filter details, the description does not explain the 'account' parameter or output format, leaving gaps for a 4-parameter tool with no 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?

With 0% schema coverage, the description partially explains 'data' (filters) and 'transaction_ids' (bulk), but leaves 'account' and 'transaction_id' unexplained, failing to fully compensate for missing 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 tool name and the 'Flattened action: list_transfers' note indicate listing transfers, but the description lists many unrelated actions (e.g., list_transactions, balance) causing confusion about the tool's actual 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?

It specifies use for legacy ak_ keys (accounts not migrated to V5), providing context but does not explicitly mention alternative V5 tools like 'pagarme_transfers_list' as a modern replacement.

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

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

Annotations already declare readOnlyHint and idempotentHint. The description adds that the tool returns specific fields (id, label, version), but does not disclose any additional behavioral traits such as handling of the optional 'account' parameter.

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 core functionality and return fields. 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?

Given the simple tool and no output schema, the description covers the return fields but lacks documentation of the optional parameter and any default behavior. Adequate but with a notable gap.

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

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

The only parameter 'account' has 0% schema description coverage and is not explained in the description. The agent cannot infer its purpose or allowed values, so the description fails to add meaning beyond the schema.

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

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

The description clearly states it lists Pagar.me accounts (keys) connected to the install, specifying the returned fields (id, label, version). It distinguishes from sibling tools which focus on specific resources like cards, charges, or customers.

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

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

No explicit guidance on when to use this tool vs alternatives. The purpose is clear for listing accounts, but there is no mention of exclusions or alternative tools for account-related operations.

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

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

Annotations already indicate read-only and idempotent behavior. The description adds minimal context and includes contradictory parameter hints (e.g., page, size) that are not relevant to a get operation.

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 short but includes irrelevant details about list and get_many actions, making it confusing. The 'Flattened action: get' note is insufficient to clarify the actual scope.

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 6 unannotated parameters and no output schema, the description fails to provide essential context. It does not explain required parameters, return values, or how to use the tool effectively.

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

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

Schema description coverage is 0%, and the description does not explain any of the 6 parameters. It mentions 'order_id' in an action list but does not specify which parameters are relevant for this tool, and includes parameters like 'page' and 'order_ids' that belong to sibling tools.

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 lists multiple actions (list, get, get_many) but indicates 'Flattened action: get', causing confusion about what this tool actually does. It does not clearly differentiate from sibling tools pagarme_orders_list and pagarme_orders_get_many.

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

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

No guidance on when to use this tool versus alternatives. The description includes details about other actions without clarifying that they are separate tools, which could mislead an agent.

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

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

Annotations (readOnlyHint=true, idempotentHint=true, destructiveHint=false) already cover safety profile. Description adds return shape (results, errors) and batch nature. No contradictions, but does not fully exploit beyond annotations.

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

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

Description is relatively short but includes irrelevant details about list and get actions for this tool. The flattened action note helps. Some redundancy, but overall efficient.

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

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

Despite 6 parameters and no output schema, description only covers batch retrieval by order_ids. Parameters like page, size appear irrelevant for get_many but are present in schema, causing confusion. Lacks guidance on required vs optional fields and error handling. Incomplete for a multi-parameter 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 6 parameters (data, page, size, account, order_id, order_ids) with 0% description coverage. Description only weakly references order_ids. No explanation of other parameters, making selection and invocation ambiguous. Does not compensate for lack of schema description.

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 retrieves multiple orders by order_ids in batch, returning { results, errors }. Distinguishes from list (paginated/filtered) and get (single order). Verb 'get many' and resource 'orders' 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?

Implicitly clarifies use case: use when you have multiple order IDs to fetch in batch. Lists three actions (list, get, get_many) and flatmap note confirms active action is get_many. No explicit exclusions or when-not, but context is clear enough.

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

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

Annotations already indicate readOnlyHint=true, so no contradiction. The description adds that list is paginated and mentions filter parameters, but lists parameters (code, status, etc.) not present in the input schema, and fails to explain schema parameters like account and data. This inconsistency reduces 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 short but includes extraneous actions (get, get_many) that dilute the focus on the 'list' action. It is front-loaded with the domain but not optimally concise for the specific tool.

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 (combined actions, 6 parameters with no schema descriptions, no output schema), the description is incomplete. It omits details on required vs optional parameters, default pagination, and how the get/get_many actions relate to sibling tools. Additional context is 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?

With 0% schema description coverage, the description must compensate. It lists filter parameters for list (page, size, code, status, customer_id, created_since, created_until) but these are partially mismatched with the schema (code, status etc. are missing; account and data are unexplained). It adds some meaning but leaves many parameters without adequate context.

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 states 'list: lista paginada' with specific filter parameters, indicating a paginated list action. However, it also describes get and get_many actions, which are separate sibling tools (pagarme_orders_get, pagarme_orders_get_many), causing confusion about this tool's specific purpose.

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

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

The description does not differentiate when to use this 'list' tool vs the sibling get and get_many tools. It implies this tool can perform all three actions, but the flattened action is 'list', and get/get_many have dedicated tools, creating ambiguity. No guidance on when not to use this tool.

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

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

The description discloses that the tool works only with accounts starting with 'sk_', and notes bulk support. However, it does not explain the side effects of closing/reopening, idempotency, or error handling. Annotations indicate destructiveHint=false, but closing could be considered destructive; the description does not clarify the safety of operations.

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 organized with action bullets and notes about flattened action and bulk support. However, it is somewhat verbose and includes redundant lines (e.g., 'Ações:' and then listing them). The structure is adequate but could be more concise.

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

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

Given the multi-action nature, 5 parameters, no output schema, and bulk support, the description misses important context: no return value explanation, no error handling details, no required fields (though implied), and no explanation of the 'account' parameter. The constraint 'só contas sk_' is mentioned but not elaborated.

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 partially compensates by explaining parameters: 'data' is a JSON for create, 'closed' for close action, 'order_id' for update/close, and 'order_ids' for bulk. However, it does not describe the 'account' parameter, leaving a 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 states it handles create, update, and close actions, which is clear in listing the actions. However, the tool name suggests only close, and there are separate sibling tools for create and update, which may confuse an agent about which tool to use. The 'Flattened action: close' line adds ambiguity.

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 action-specific requirements but lacks explicit guidance on when to use this tool versus siblings like pagarme_orders_write_create or pagarme_orders_write_update. It does not mention alternatives or prerequisites (other than 'só contas sk_') and does not clarify when to use the bulk feature instead of individual operations.

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?

Disclosures include parameter requirements per action and bulk support, but no side effects, idempotency, or safety information beyond annotations. Annotations already imply non-read-only and non-destructive, so description adds moderate value.

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

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

Bullet-point structure aids readability, but contains redundancy (e.g., listing sibling tools inline) and uses Portuguese, which may limit understanding. Could be more streamlined.

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 basic actions and parameter roles, but lacks information on return values, error handling, authentication details, and rate limits. For a write tool with no output schema, this is insufficient.

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; description fills gaps by linking 'data' to order JSON, 'closed' to close action, 'order_id' to update/close, and 'order_ids' to bulk. However, 'account' parameter is only implicitly mentioned and structure of 'data' is not 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?

Description clearly states create/update/close actions with specific requirements, but ambiguity arises due to existence of sibling tools specifically for update and close (pagarme_orders_write_update, pagarme_orders_write_close), which may confuse the agent about when to use this tool.

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

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

Provides constraints like 'só contas sk_' and parameter needs per action, but lacks explicit guidance on choosing this tool over sibling tools or distinguishing between actions. No when-to-use or when-not-to-use directives.

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

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

Description adds behavioral info beyond annotations: mentions bulk support via order_ids, account restriction (sk_ only), and the flattened action hint. However, it does not disclose side effects, authentication needs, or error behavior. Annotations already indicate write operation.

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 concise but could be tighter. The bullet list of actions is clear, but the flattened action note adds ambiguity. Some redundancy exists between the summary and the list.

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 5 parameters, no output schema, and a dual-action description that is actually single action, the tool definition is incomplete. Missing info on 'account' parameter, return values, error handling, and idempotency (though annotated false). The flatten note contradicts the initial actions.

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 the purpose of 4 out of 5 parameters: data (create/update JSON), closed (boolean for close), order_id (for update/close), and order_ids (bulk). The 'account' parameter is not explained, but overall the description adds significant 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 states the tool creates/updates/closes orders, which is a specific verb+resource. However, it includes actions (create, close) that have dedicated sibling tools, potentially causing confusion. The '[Flattened action: update]' note attempts to clarify, but the initial listing may mislead.

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

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

No explicit guidance on when to use this tool versus the separate pagarme_orders_write_create and pagarme_orders_write_close tools. The mention 'só contas sk_' provides a constraint but does not help differentiate from siblings.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. The description adds the behavioral trait of bulk support via payable_ids, but does not disclose response format or other side effects. 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 brief but contains some redundancy (e.g., 'Ações:' and 'Flattened action: get'), and could be more streamlined. Acceptable but not 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?

The tool has 6 parameters and no output schema. The description omits return value details and does not differentiate from the sibling list tool, leaving gaps for the agent to infer.

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 clarify parameters. It mentions 'page, size' for list and 'payable_id' for get, and bulk 'payable_ids', but does not explain 'data', 'account', or provide full parameter semantics. Incomplete.

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

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

The description clearly states the tool handles payables via 'list' and 'get' actions, with a flattened focus on 'get'. However, it does not differentiate from the sibling tool 'pagarme_payables_list', which likely handles listing, causing potential confusion.

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

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

No guidance is provided on when to use this tool versus alternatives like 'pagarme_payables_list'. The description lacks explicit when-to-use, when-not-to-use, or exclusion criteria.

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

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

Annotations already declare readOnly, idempotent, non-destructive. The description adds bulk execution via payable_ids, which is useful. However, it fails to explain pagination limits or if additional filtering is possible.

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 reasonably short but includes redundant elements like the duplicated action listing. It could be more focused on listing alone.

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 6 parameters, no output schema, and 0% schema coverage, the description is incomplete. It fails to explain all parameters, return format, or error cases. The agent would lack key information 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?

With 0% schema description coverage, the description partially compensates by explaining page, size, payable_id, payable_ids. But 'data' and 'account' are left unexplained. The schema has 6 parameters, and description covers roughly half.

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 states 'lista recebíveis' (list payables) which is a clear verb+resource. However, it also includes a 'get' action, slightly diluting the singular purpose. It distinguishes from 'pagarme_payables_get' only implicitly.

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. There is no comparison to sibling tools like 'pagarme_payables_get'. Bulk support is mentioned but not clarified as a filtering option.

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 destructiveness (destructiveHint=true). The description adds that deletion is irreversible and supports batching, which are behavioral traits beyond the annotations. However, it does not disclose side effects, authorization needs, or response behavior, so disclosure is good but not exhaustive.

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

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

The description is two concise sentences: the first covers the core action and requirement, the second adds bulk support. No unnecessary words; every sentence earns its place.

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

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

Given 3 parameters, no output schema, and a destructive operation, the description covers the purpose and key constraints but lacks details on expected results, error handling, and effects on related entities (e.g., subscriptions). It is adequate for basic use but not fully complete.

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

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

The schema has no descriptions (coverage 0%). The description partially compensates by explaining 'plan_id' (required) and 'plan_ids' (batch support). However, the 'account' parameter is left unexplained. Thus, the description adds meaningful context for two of three parameters but is incomplete.

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

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

The description clearly states the tool's purpose: to remove a plan in Pagar.me V5. The verb 'Remove' and resource 'plano' are specific. The distinction from sibling tools is implicit as there is no other delete tool for plans, and the description explicitly mentions irreversibility and bulk execution.

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 mentions that 'plan_id' is required and that batch execution via 'plan_ids' is supported, giving some usage context. However, it does not explicitly state when to use this tool versus alternatives (e.g., updating a plan) or provide conditions for use. The lack of when-not advice limits guidance.

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