Hotmart

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

Annotations already indicate idempotentHint=true and non-destructive. Description adds that it's for session vs permanent, and token is JWT. No contradiction. Could mention side effects like setting server state, but sufficient.

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

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

Concise single paragraph, front-loaded with purpose. Every sentence provides useful instructions. No waste.

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 it's an authentication tool with optional param and no output schema, description covers all needed context: login flow, token options, and config persistence. Complete.

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

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

Schema has 0% coverage (no description for 'token'). Description compensates by explaining token is optional JWT, used for session login, and calling without args retrieves link. Adds meaning beyond schema.

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

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

Description clearly states verb 'authenticate', resource 'MCP.AI for IDE agents', and distinguishes from sibling tools (none do auth). It specifies login, token handling, and optional config vs session.

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

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

Explicitly provides when to use: for authentication, with instructions for browser login, config setup, or session paste. Also says call with token or no args for link. No exclusions needed.

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

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

Annotations already declare readOnly and idempotent. Description adds value by detailing the two possible response shapes (authenticated vs missing credentials) and specific fields like 'connect_url' and 'pending[]'. No contradictions.

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

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

Two sentences, no waste. Front-loaded with main purpose, then explains details. Perfectly concise.

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

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

Given no parameters and no output schema, description fully covers the tool's behavior for both scenarios. No gaps.

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

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

No parameters, schema coverage 100%. Baseline for 0 params is 4. Description doesn't need to add parameter info; it is clear about the no-parameter behavior.

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

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

Clear verb 'returns' and resource 'connection status and URLs'. Description distinguishes between two states (all connected vs missing credentials), and the name 'connect' implies connection status check, differentiating from siblings like 'authenticate'.

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 implicitly tells when to use (to check connection status) and implies not for authentication (sibling 'authenticate' available). No explicit when-not or alternatives, but 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 declare readOnlyHint=true and idempotentHint=true, so the description adds little beyond listing the data fields (name, document, settings). It does not contradict annotations but provides minimal extra behavioral context.

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

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

The description is a single, concise sentence that front-loads the purpose. However, it sacrifices necessary details like parameter usage, making it efficient but incomplete.

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 fails to cover input (parameter meaning) and output (return format, as there is no output schema). Despite low complexity, the gaps in parameter semantics and undefined return type hinder full understanding.

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

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

The single parameter 'account' (string) has no description in the schema or in the tool description. With 0% schema description coverage, the agent is left to guess what value to provide (e.g., account ID or identifier). This is a significant 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 that it returns connected Hotmart account data (name, document, settings), distinguishing it from sibling 'hotmart_list_accounts' which likely lists multiple accounts. However, it could be more explicit about which account it refers to.

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 any guidance on when to use this tool versus alternatives like 'hotmart_list_accounts' or other hotmart tools. There is no mention of prerequisites or context for invocation.

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

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

Annotations already indicate read-only and idempotent behavior. The description adds value by mentioning bulk support (module_ids, user_ids) and the flattening action. No contradictions with annotations, but it does not disclose potential rate limits or pagination.

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 mixes Portuguese and English, uses a bullet-style list for actions, and includes a redundant line about flattened action. It is reasonably concise but lacks a clear hierarchical structure. Every sentence adds some information, but the list of actions could be misinterpreted.

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 an output schema and the presence of eight parameters, the description should cover response format, pagination, and error handling. It only addresses bulk support and basic parameter requirements. The relationship with sibling tools is unclear, reducing 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?

Schema description coverage is 0%, so the description must compensate. It explains subdomain, is_extra, module_id, student_email, and user_id usage. However, it omits the 'account' parameter and does not fully detail the behavior of all eight parameters. Partial but not complete 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 states it inventories and tracks course content and lists multiple actions (modules, pages, students, lessons), but the tool name is 'lessons'. This creates ambiguity as to whether it is a combined tool or solely for lessons. The sibling tools include dedicated tools for modules, pages, and students, making the overlapping actions confusing.

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 notes that subdomain is required and mentions bulk support, but it does not guide when to use this tool versus sibling tools like hotmart_club_modules or hotmart_club_pages. It lists those as actions within this tool, which may mislead agents into using this tool for tasks better handled by separate 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 declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, so the description adds limited behavioral insight. It mentions bulk support (module_ids, user_ids) and the requirement for subdomain, which is useful but not extensive. No contradictions with annotations.

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

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

The description is relatively short and uses bullet points for clarity. The 'Flattened action' note and bulk support mention are efficient. However, the phrasing 'Flattened action: modules' is somewhat cryptic and could be clearer.

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 covers parameter usage for each action and bulk support. However, it lacks details on return values, does not clarify the relationship with sibling tools, and omits the 'account' parameter. Completeness 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 coverage is 0%, so the description must compensate. It maps parameters to actions (e.g., module_id for pages, user_id for lessons, is_extra for filtering) and notes bulk parameters. While not every parameter is explained (e.g., account is omitted), the description adds significant 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 states the tool inventories course content and lists actions (modules, pages, students, lessons). However, it is unclear why multiple actions are in one tool when separate sibling tools exist (hotmart_club_lessons, hotmart_club_pages, hotmart_club_students). The phrase 'Flattened action: modules' suggests it primarily handles modules, but the inclusion of other actions blurs 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 specifies required parameters for each action (e.g., module_id for pages) but fails to guide when to use this tool versus sibling tools like hotmart_club_lessons. There is no explicit when-not or alternative guidance, leaving the agent to infer use cases.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds minor behavioral context by mentioning bulk support (accepts module_ids, user_ids) and the requirement for subdomain. However, it does not elaborate on idempotency or safe re-use, and the flattening note is cryptic.

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 wordy, with a header, a paragraph, a list, and a footnote. It could be more focused on the primary action (pages). The structure is acceptable but not optimally concise; every sentence does not earn its place due to redundant mentions.

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 having 8 parameters, no output schema, and zero schema descriptions, the description fails to fully explain the tool's behavior. It omits return format, error handling, bulk execution details, and how the 'flattened action' affects parameter usage. Significant gaps remain for an 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 description coverage, the description must compensate. It explains subdomain, module_id, is_extra, student_email, user_id, user_ids, and module_ids to some extent, but mixes parameters across multiple actions without clear mapping for the 'pages' action. The 'account' parameter is unexplained, and the bulk usage details are vague.

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 attempts to cover multiple actions (modules, pages, students, lessons) rather than clearly stating the tool's primary purpose. The name 'hotmart_club_pages' suggests a focus on pages, but the description conflates several sub-actions, and the phrase '[Flattened action: pages]' adds confusion. It is not specific about what the tool does as a single 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?

No explicit guidance is given on when to use this tool versus its siblings (e.g., hotmart_club_modules, hotmart_club_lessons, hotmart_club_students). The description implies multiple actions but fails to clarify which tool should be used for which scenario, leaving the 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 declare readOnlyHint=true and destructiveHint=false, so the tool is safe and read-only. The description adds 'Bulk support' and mentions required subdomain, but no additional behavioral traits like rate limits, authentication specifics, or data freshness. It does not contradict 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 moderately concise with bullet points for actions and a note on bulk support. However, it mixes multiple actions into one paragraph and includes a redundant '[Flattened action: students]' line, which adds noise.

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 is complex (multi-action with 8 parameters, no output schema). The description lacks information on return values, pagination, error handling, and how to select which action to invoke. It does not fully compensate for the missing output schema.

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

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

Schema has 8 parameters with 0% description coverage. The description explains subdomain (required), module_id (for pages), student_email (optional filter), and mentions module_ids/user_ids for bulk. However, parameters like account, is_extra, and user_id are not explained clearly, leaving gaps for an agent.

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 'Área de membros (Hotmart Club)' and lists actions (modules, pages, students, lessons). However, the tool name 'hotmart_club_students' suggests a focus on students, but the description includes multiple other sub-tools, making the primary purpose unclear. The '[Flattened action: students]' hints at a focus but the breadth of actions dilutes 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 hotmart_club_modules or hotmart_club_lessons. The description mentions bulk support but does not explain when to choose this aggregated tool over separate sibling tools for specific actions.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, destructiveHint=false. Description adds bulk execution support, which is useful but does not contradict or significantly expand beyond annotations.

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

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

Two efficient sentences, front-loaded with core action and requirements, followed by bulk support. Every word adds value.

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

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

Covers main requirement and filters, but misses explaining the 'account' parameter and does not mention return values or pagination behavior. Adequate but with clear 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, description partially compensates by explaining product_id as required, and filters code/page_token, plus bulk product_ids. However, it omits the 'account' parameter entirely, leaving its purpose unclear.

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 discount coupons for a product, requires product_id, and provides filters. It distinguishes from sibling write tools (hotmart_coupons_write_create/delete) as a read 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 specifies required parameter product_id, available filters, and bulk support, implying when to use this tool for listing versus sibling write tools. Lacks explicit 'when not to use' but context is clear.

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

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

The description indicates the tool is a mutation (creates coupons), consistent with readOnlyHint=false. No annotations are contradicted. However, it lacks details on permissions, idempotency, or what happens to existing coupons with the same code, which limits 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 relatively short but includes redundant information about the delete action and a 'Flattened action' note that adds confusion. The structure uses a list and a sentence, but 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?

Given the tool has 7 parameters with no output schema, the description leaves many aspects unexplained: required vs optional parameters, default values, response format, error handling, and detailed behavior for bulk operations. This incompleteness hampers the agent's ability to 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?

The description explains product_id, code, and discount (decimal 0-1), and mentions bulk arrays product_ids and coupon_ids. However, several parameters (account, coupon_id) are not explained, and the relationship between bulk parameters and the create action is ambiguous, leaving gaps since schema coverage is 0%.

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 'create: cria um cupom num produto (product_id + code + discount decimal 0-1)' which clearly identifies the tool's purpose as creating a coupon. The mention of a delete action and 'Flattened action: create' introduces minor confusion but does not obscure the 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?

The description lists actions and mentions bulk support, implying when to use the tool for creating coupons. However, it does not explicitly differentiate from sibling tools like hotmart_coupons_write_delete or provide 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 states delete removes a coupon (destructive), but annotations set destructiveHint=false, creating a contradiction. No other behavioral context (e.g., permissions, idempotency) is provided.

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 poorly structured. The 'Ações' list and '[Flattened action: delete]' note are confusing and could be more coherent. Redundancy and lack of logical flow reduce effectiveness.

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 does not explain return values. With 7 parameters and mixed actions, the description is insufficient for an agent to correctly invoke the tool without guessing.

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 for some parameters (e.g., discount decimal range, bulk fields), but the 'account' parameter is unexplained, and the mapping of parameters to create vs delete actions is ambiguous.

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 performs mutations (create/delete) on Hotmart coupons, but the addition of '[Flattened action: delete]' creates confusion about whether this tool actually handles both or only delete. The sibling 'hotmart_coupons_write_create' suggests the delete-only interpretation, 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 hotmart_coupons_write_create or hotmart_coupons. Mention of bulk support gives some context but does not differentiate from 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 declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds that event_id is required and that bulk execution is supported. It does not contradict annotations. However, it does not disclose any additional behavioral traits such as rate limits or side effects beyond what annotations imply.

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 to the point, using bullet points to separate actions and features. Every sentence adds value: purpose, required parameter, distinction from participants, bulk support. 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?

For a tool with 5 parameters (only 2 explained) and no output schema, the description is incomplete. It does not describe the return structure or behavior of unmentioned parameters. Given the context signals (no output schema, 0% parameter coverage), the description should have provided more detail.

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 should compensate. It only explains event_id and event_ids, leaving account, page_token, and max_results unexplained. This insufficiently documents the parameters, especially since the schema provides no 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 that the tool provides info about Hotmart Events, requiring event_id. It distinguishes between info and participants actions, and notes that the current tool is for the info action. This differentiates it from the sibling tool hotmart_events_participants.

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 notes that event_id is required and that bulk execution is supported via event_ids. It implicitly suggests that for participant data, one should use a different tool (hotmart_events_participants). However, it does not explicitly state when not to use this tool or enumerate all 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 readOnly, idempotent, and non-destructive. The description adds bulk support behavior, which is beneficial, but does not discuss pagination, rate limits, or other traits beyond the annotations.

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

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

The description is relatively short but includes extraneous information about the 'info' action, which is not the focus of this tool. The bulk support mention is useful but the structure could be more streamlined to focus only on participants.

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 5 parameters, the description is insufficient. It explains the purpose and bulk execution but lacks details on return format, pagination, and other parameter behaviors, leaving significant gaps 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 input schema has 5 parameters with 0% description coverage. The description only adds context for event_id and event_ids (bulk), leaving account, page_token, and max_results unexplained.

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 handling participants of Hotmart Events, with a specific mention of 'participants' action and bulk support. However, it also includes an 'info' action which may cause confusion since hotmart_events_info is a separate sibling 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 implies usage by stating 'requires event_id' and mentions bulk support, but it does not explicitly differentiate from alternatives like hotmart_events_info or provide when-not-to-use guidance.

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

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

Annotations already provide safety traits (readOnlyHint, idempotentHint, destructiveHint). The description adds return field details but no extra behavioral traits like rate limits or scoping.

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

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

Single sentence that front-loads the verb and resource, with no wasted words.

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

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

Missing essential details: no mention of pagination, what 'this install' means, or any explanation of the parameter. Incomplete for a list 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?

The optional 'account' parameter is not described at all. With 0% schema description coverage, the description fails to explain its purpose (e.g., filtering by specific account).

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

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

The description clearly states the tool lists Hotmart accounts (creators) linked to this install, specifying the return fields (id, label, apelido). It distinguishes from the sibling tool 'hotmart_account' which likely retrieves a single account.

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 vs. alternatives. It does not mention that this lists all accounts while other tools (e.g., hotmart_account) exist for individual accounts.

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

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

Annotations provide all false hints, so the description carries full burden. It states that the tool creates a negotiation, but does not disclose behavioral traits such as authorization requirements, idempotency, rate limits, or side effects beyond the basic write operation. This is a significant gap for a mutation tool.

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

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

The description is a single sentence that efficiently conveys the tool's purpose and required input. It is front-loaded and contains no unnecessary words, earning its place as being 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 low complexity (2 parameters, no output schema), the description is adequate but not complete. It lacks explanation of the optional 'account' parameter and what the response looks like. It covers the core purpose but misses details that could help an agent 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%, so the description must compensate. It mentions that subscriber_code is required, but does not explain the 'account' parameter. The description adds minimal meaning beyond the schema, leaving the optional parameter undocumented.

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

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

The description clearly states the verb 'cria' (creates), the resource 'negociação (recuperação) de uma assinatura em atraso', and the required input subscriber_code. It is specific and distinguishes from siblings like reactivate or cancel by explicitly mentioning negotiation for overdue subscriptions.

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 says 'requires subscriber_code' but does not provide explicit guidance on when to use this tool versus alternatives (e.g., reactivate or cancel). Usage is implied by the context of overdue subscriptions, but no exclusions or alternative recommendations are 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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, indicating a safe read operation. The description adds no further behavioral context (e.g., pagination, ordering, or response format), but it does not contradict the annotations.

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

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

The description is a single, front-loaded sentence with no wasted words. However, it could be slightly longer to include parameter explanations without losing conciseness.

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

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

Given the tool has 3 undocumented parameters and no output schema, the description is critically incomplete. It fails to explain parameter usage or return values, which is essential for a list tool.

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

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

Schema description coverage is 0%, meaning the input schema provides no parameter descriptions. The tool description does not mention or explain any of the three parameters (account, page_token, max_results), leaving the agent with no semantic guidance for invocation.

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 'Lista os links de pagamento' (lists payment links), which identifies the verb and resource. However, it does not differentiate from sibling tools like hotmart_sales_history or other list tools, so it lacks sibling differentiation.

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

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

No guidance is provided on when to use this tool versus alternatives. The description simply states what the tool does without any context, conditions, 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?

The description adds context that the tool 'gera cobrança, mexe em dinheiro' (triggers charges, handles money), which goes beyond annotations by indicating financial impact. However, it does not disclose other behavioral details like idempotency, authorization requirements, or side effects.

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

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

The description is not concise; it lists multiple actions that are not part of this tool, adding redundancy and potential confusion. It includes a disclaiming line about flattened action, but the extra list increases verbosity without added value.

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

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

Given the complexity (3 params, no output schema, no required params), the description fails to explain the account parameter, data format, or return behavior. It does not compensate for the lack of annotations or output schema, leaving significant gaps for correct tool usage.

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

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

With 0% schema description coverage, the description partly explains parameters: 'payment_link_ucode + data' for add_offer, but omits the 'account' parameter entirely and does not describe the structure of 'data'. The description lacks enough detail to guide 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 states the tool is for mutations on Hotmart payment links, specifically adding an offer, which is clear. However, it lists multiple actions in the description, which could cause confusion, but the flattened action 'add_offer' clarifies the specific action. It does not explicitly differentiate from sibling tools like add_plan.

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 by naming and the phrase 'add_offer', but there is no explicit guidance on when to use this tool versus alternatives (e.g., add_plan, charge_offer). No when-not-to-use or alternative tools are mentioned.

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

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

Annotations indicate readOnlyHint=false and destructiveHint=false, which are consistent with a mutation that is not destructive. The description adds 'gera cobrança, mexe em dinheiro' (generates charges, messes with money), providing behavioral context beyond annotations. However, it lacks details on side effects like whether adding a plan creates immediate charges or modifies existing subscriptions.

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 irrelevant actions (create, add_offer, etc.) that do not belong to this tool. It could be a single sentence specifying this tool's function. The extraneous content wastes tokens and introduces confusion.

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

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

Given the complexity of a mutation affecting payment links (money), and the absence of output schema or parameter descriptions, the description is incomplete. It does not explain what a plan is, what the response looks like, or potential errors. The agent lacks sufficient information to 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 the description must compensate. It mentions payment_link_ucode and data for add_plan, but does not explain the structure or required fields of the data object. The schema shows additionalProperties: true for data, so the description should guide the agent on valid keys; it fails to do so, leaving the parameter semantics underdefined.

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, add_offer, add_plan, charge_offer, charge_value) and states '[Flattened action: add_plan]', implying this tool is for add_plan only. However, the description does not clearly and exclusively state that the tool adds a plan to a payment link; it is muddled by extraneous actions. This ambiguity makes it difficult for an agent to discern the 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 provides no guidance on when to use this tool versus siblings like hotmart_payment_links_write_add_offer or hotmart_payment_links_write_charge_offer. It does not mention prerequisites, conditions, or alternatives, leaving the agent without decision-making context.

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

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

Annotations are minimal (readOnlyHint=false, destructiveHint=false). The description states it 'gera cobrança, mexe em dinheiro', indicating a mutation that creates charges, but does not disclose any side effects, required permissions, or what happens upon success/failure. More behavioral context is needed.

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 cluttered with a list of actions that do not apply to this specific tool, making it longer than necessary. The key information (flattened action) is useful but buried among 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?

For a tool that handles financial transactions (charges), the description fails to specify required fields within the 'data' object, expected return values, or error conditions. With three parameters, no output schema, and high complexity, the description is severely incomplete.

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, so the description must add meaning. It only vaguely mentions that 'data' should contain 'token/oferta' for charge_offer, but does not explain the 'account' or 'payment_link_ucode' parameters. The parameter descriptions are insufficient for an agent to construct correct inputs.

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 five different actions (create, add_offer, add_plan, charge_offer, charge_value) but the tool name and the flattened action note indicate this tool is specifically for 'charge_offer'. This inconsistency misleads the agent about the tool's actual purpose, making it unclear what this 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 the sibling tools (e.g., hotmart_payment_links_write_create, hotmart_payment_links_write_charge_value). The description lists other actions that are actually separate tools, but does not direct the agent to use those alternatives.

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

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

Annotations indicate readOnlyHint=false (write) and destructiveHint=false (not destructive), which is consistent with creating a charge. The description adds the context that it 'gera cobrança, mexe em dinheiro' (generates charges, touches money). However, it does not disclose potential side effects like payment processing, refund implications, or rate limits. With only basic annotation coverage, the description adds moderate value but leaves behavioral gaps.

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 a list of actions that belong to the broader tool family but not specifically to this tool. The key information about charge_value is buried after several lines of unrelated actions. The structure is not front-loaded; the '[Flattened action: charge_value]' note comes at the end, which is inefficient.

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 (3 params, 0% schema coverage, no output schema, many siblings), the description is incomplete. It fails to clarify required parameters for this action, expected output, or how to differentiate from the large number of sibling tools (e.g., charge_offer, create). The description of the 'data' object is vague, and there is no explanation of the 'account' parameter.

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

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

Schema coverage is 0%, so the description must compensate. It explains that for charge_value, 'data' should contain 'token' and 'valor' (value). This adds meaning beyond the empty schema definition. However, it does not explain the 'account' parameter or whether 'payment_link_ucode' is required for this action, leaving significant ambiguity for the agent.

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 mutations on Hotmart payment links that generate charges and deal with money. It explicitly lists 'charge_value: cobra por valor (data com token/valor)' which clarifies the specific action. However, the preceding list of multiple actions (create, add_offer, etc.) creates confusion about which action this tool actually performs, partly mitigated by the '[Flattened action: charge_value]' note.

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 like 'charge_offer' or 'create'. The description lists other actions but does not compare or contrast; an agent would need to infer that charge_value is for fixed-value charges and charge_offer for offer-based charges. This lack of differentiation increases selection risk.

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 behavioral info beyond annotations: it creates payment links and can generate charges ('gera cobrança, mexe em dinheiro'). This provides context about financial impact, which annotations alone (readOnlyHint=false, destructiveHint=false) do not convey. 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 moderately concise but includes a list of five actions, most of which are irrelevant to this specific tool. The bullet list format is clear, but the inclusion of extra actions and the 'Flattened action' note add unnecessary complexity for a tool that only performs the create 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 0% schema coverage, the description should explain the full context: what the create operation returns, how to use parameters correctly, and the effect on the system. It only provides an overview of actions and minimal parameter info, leaving significant gaps for an agent to understand the tool's complete behavior.

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

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

Schema coverage is 0%, so parameters have no descriptions in schema. The description only vaguely explains the 'data' parameter for the create action ('data com a config do link'), but does not explain 'account' or 'payment_link_ucode'. This is insufficient for an agent to correctly supply parameter values.

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

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

The description states it handles mutations on Hotmart payment links and mentions creating a link as one action, but it also lists four other actions that are not relevant to this tool, causing ambiguity. The name 'write_create' and the flattened action note clarify it is for create, but the inclusion of other actions weakens 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 vs sibling tools like hotmart_payment_links_write_add_offer. The 'Flattened action: create' note implies it's for create, but does not explain when this is appropriate or mention 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 declare readOnlyHint true, idempotentHint true, and destructiveHint false, so safety is clear. The description adds that the list action supports filters max_results and page_token, hinting at pagination. However, it doesn't specify what data is returned (e.g., only creator's products) or other behavioral traits, so it 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?

The description is relatively short but includes redundant information about offers and plans that are not part of this tool's primary function. The '[Flattened action: list]' label attempts to clarify but adds clutter. It 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?

Given the low schema coverage, no output schema, and the presence of sibling tools, the description should provide more context. It does not describe the output format, pagination behavior, or the role of ucode and account parameters. The tool is a read-only list operation, but completeness is lacking.

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

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

With 0% schema description coverage, the description must explain parameters. It only mentions max_results and page_token as filters for the list action, ignoring ucode and account entirely. These two parameters are not described, leaving ambiguity about their purpose. The description partially compensates but is insufficient.

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 products ('lista produtos'), so the primary purpose is clear. However, it also includes separate actions for offers and plans, which belong to sibling tools, causing confusion. The tool name suggests it's only for listing, so the extra actions dilute 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 guidance is provided on when to use this tool versus sibling tools like hotmart_products_offers or hotmart_products_plans. It mentions that offers and plans require a ucode but does not explain when to use list vs those. There are no when-not-to-use or alternative suggestions.

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

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

Annotations already indicate read-only and non-destructive behavior. The description adds that the 'offers' action requires 'ucode', which is useful context but does not elaborate on other behavioral 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 short but includes extraneous information (listing all actions) when the tool is specifically for offers. The '[Flattened action: offers]' note adds confusion rather than clarity.

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

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

No output schema, and the description does not explain return values or behavior for different parameters. For a tool with 4 undocumented parameters, more context is needed to use it 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?

Input schema has 0% description coverage. The description only mentions 'max_results' and 'page_token' for the list action, and 'ucode' for offers, but omits 'account' entirely. No details on format or allowed values.

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

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

The description mentions multiple actions ('list', 'offers', 'plans') but the tool name and '[Flattened action: offers]' indicate it's specifically for offers. This creates confusion about the tool's actual 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?

No guidance on when to use this tool versus siblings like 'hotmart_products_list' or 'hotmart_products_plans'. The description does not distinguish scenarios or provide 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, idempotentHint, and no destructive behavior. The description adds that some actions require ucode, but does not disclose any additional behavioral traits such as pagination limits or authentication needs.

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 includes redundant bullet formatting and the ambiguous '[Flattened action: plans]' note. It front-loads the main purpose but the listing of actions adds clutter without clear delineation.

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 and lack of output schema, the description is incomplete. It does not explain how to select an action, what each action returns, or how parameters interact. Sibling tools cover list and offers, but this tool's description creates confusion about coverage.

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 partially explains max_results and page_token as filters for list, and ucode as required for offers/plans, but does not cover the 'account' parameter. The action selection mechanism is not parameterized, leaving ambiguity.

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

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

The description lists multiple actions (list, offers, plans) but the tool name and flattened action suggest it is specifically for plans. It does not clearly distinguish from sibling tools hotmart_products_list and hotmart_products_offers, leaving ambiguity about the 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 this tool versus alternatives. It mentions filters for list and ucode requirement for offers/plans but does not state exclusions or preferred 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 and destructiveHint=false. The description adds that it returns raw Hotmart data with pagination (items + page_info), 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 structured with actionable bullet points and includes a flattened action marker. It is informative but contains some redundancy (e.g., repeating tool name) and could be slightly tighter.

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 0 required parameters, no output schema, and existing annotations, the description covers actions, parameters, bulk support, and return format. It lacks output structure details but is adequate for a read 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 compensates fully by listing 7 of 9 parameters with their formats (e.g., start_date/end_date YYYY-MM-DD, buyer_email, product_ids for bulk). Only 'account' is omitted, but the high coverage adds significant 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 states it reads sales commissions via the Hotmart Payments API and lists specific actions. Although the name suggests a narrow focus, the list of multiple actions (history, summary, users, commissions, price_details) could blur the purpose relative to sibling tools like hotmart_sales_history. However, the flattened action note clarifies it's commissions 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 mentions filters and bulk support but does not explicitly guide when to use this tool versus the many sibling sales tools (e.g., hotmart_sales_history, hotmart_sales_summary). The context is implied but lacks explicit alternatives 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 indicate read-only and idempotent. The description adds that it returns raw data with pagination (items + page_info) and supports bulk via product_ids. However, the inclusion of multiple actions that are likely not active (given '[Flattened action: history]') introduces confusion.

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 verbose with a bullet list of actions and technical notes. It is well-structured with a header and sections, but could be more concise without losing key 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?

No output schema and complex optional parameters. The description only vaguely explains the output as raw data with pagination. It fails to clarify the relationship to sibling tools or the exact meaning of the flattened action.

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 compensates by listing most parameters: start_date/end_date, product_id, transaction_status, buyer_email, max_results, page_token, product_ids. Only 'account' is not explained. This adds significant 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 states 'Leitura de vendas na Hotmart (Payments API)' and lists filters, indicating it retrieves sales history. However, it also lists multiple actions (summary, users, commissions, price_details) that correspond to separate sibling tools, creating ambiguity about the 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?

No guidance on when to use this tool versus sibling tools like hotmart_sales_summary or hotmart_sales_users. The description does not exclude other tools or specify context.

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

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

Annotations already indicate readOnly, idempotent, and non-destructive behavior. The description adds that the response contains 'items + page_info de paginação', which is useful but does not go further.

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 irrelevant information about other actions, making it less concise. The 'Flattened action' note is unclear, and the listing of unrelated actions adds noise.

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 response format and pagination but omits details on some parameters (e.g., account) and fails to differentiate this tool from its many siblings.

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 provides meaning for 6 of 9 parameters, including date format hints and bulk product_ids. This significantly aids understanding beyond the bare schema.

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

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

The description identifies the core purpose as 'price_details: detalhes de preço/taxas por venda', but it muddles this by listing multiple other actions (history, summary, users, commissions) that belong to sibling tools, causing 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 explicit guidance on when to use this tool versus sibling tools like hotmart_sales_history or hotmart_sales_commissions. The mention of bulk support is helpful but insufficient to guide 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 correctly indicate read-only, idempotent, non-destructive. Description adds 'Flattened action: summary' (behavioral constraint not in annotations) and bulk support via product_ids. However, lacks details on authentication, rate limits, or response structure.

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 includes redundant listing of actions that may not all be active. The 'Flattened action' note is helpful but could be integrated more efficiently. It is not overly verbose but could be tighter.

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 9 parameters, no output schema, and many sibling tools, the description is incomplete. It does not explain the return format, pagination beyond page_info, or how the summary action differs from the others. The description leaves significant gaps for an agent to use it 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 9 parameters with 0% description coverage. The description explains several filters (start_date, end_date, product_id, etc.) and mentions product_ids for bulk, adding partial meaning. But some parameters (account) remain unexplained, and the description does not fully compensate for the 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 lists multiple actions (history, summary, users, commissions, price_details) but the tool name and annotation suggest a summary-only function. It mentions 'Flattened action: summary', which implies only summary is active, creating confusion about the tool's actual purpose. It does not clearly distinguish from sibling tools like hotmart_sales_history.

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 the specific sales tools (e.g., hotmart_sales_history, hotmart_sales_commissions). The description merely states it's for reading sales, but does not provide context 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 and destructiveHint=false. The description adds that it returns raw data with pagination (items + page_info) and supports bulk execution via product_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 somewhat verbose with a list of actions that are not all relevant due to the flattened action, and includes redundant information. Could be more concise and better 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?

No output schema is provided, and the description only minimally describes the return format as 'raw data with items and page_info.' More detail on the output structure would improve completeness, especially given the number of parameters.

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 listing filters (start_date/end_date, product_id, etc.) and specifying date format (YYYY-MM-DD). It also explains the product_ids array for bulk usage, though the account parameter remains unexplained.

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 performs 'Leitura de vendas' (reading sales) specifically for users, as indicated by the flattened action 'users'. This distinguishes it from sibling tools like hotmart_sales_commissions, hotmart_sales_history, etc., which cover other 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?

The description lists parameters but does not explicitly state when to use this tool versus alternatives. It implies use for getting participants but 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?

The description explicitly states the operation is 'irreversível' (irreversible) and that it returns the amount to the buyer, adding critical behavioral context beyond the annotations. This helps the agent understand the permanent effect and financial impact. 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 short and to the point, with a bullet list for actions. The 'Flattened action' line is somewhat redundant but does not significantly detract. Overall, it is concise and front-loaded with the purpose.

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

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

For a financial write operation with two parameters and no output schema, the description is incomplete. It lacks information on return values, error conditions, required permissions, and the state of the transaction (e.g., must be refundable). The agent has insufficient context 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?

The description mentions transaction_code as the identifier for the refund, adding some meaning beyond the schema. However, it fails to explain the account parameter, its purpose, or any constraints. With 0% schema coverage, the description should provide more detail for all parameters.

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

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

The description clearly states the tool performs 'refund' on Hotmart sales, using specific verb and resource. It identifies the required input (transaction_code) and the irreversible nature. While it distinguishes from siblings by name, it does not explicitly compare or contrast with other similar 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?

No guidance on when to use this tool versus alternatives like hotmart_subscriptions_write_cancel or other sales tools. No prerequisites, conditions, or scenarios provided. The agent must infer usage from the name and minimal description.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, establishing the tool as safe and idempotent. The description adds behavioral context beyond annotations by noting bulk support via 'product_ids' and listing available filters. It does not cover rate limits or auth, but the core behavior is well-documented.

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, but includes details about actions not part of this tool (summary, purchases, transactions, switch_plan_plans). This extra information, while contextual, adds length and potential confusion. The '[Flattened action: list]' note helps, but the description 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?

With no output schema and 8 parameters, the description covers purpose and parameters well, but lacks information about the return format or pagination behavior beyond mentioning page_token and max_results. The tool's overall behavior is adequately described for a list operation, but the omission of output details leaves a 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?

Despite 0% schema description coverage, the description thoroughly explains most parameters: it lists filters (product_id, subscriber_email, status with explicit enum values, max_results, page_token) and identifies product_ids for batched execution. It also clarifies that subscriber_code is not for list but for other actions. This adds significant 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 that the tool performs a list operation on Hotmart subscriptions, with explicit filters. However, it also lists other actions (summary, purchases, transactions, switch_plan_plans) that are not part of this tool, which could blur the focus. The '[Flattened action: list]' note clarifies, but the inclusion of unrelated actions is unnecessary.

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

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

The description provides explicit guidance by listing alternative actions (summary, purchases, transactions, switch_plan_plans) and their requirements. Since sibling tools exist for these actions, it effectively tells the agent when to use this tool (for list) versus the others. It lacks explicit 'when not to use', but the context is clear.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, and the description's 'Leitura' aligns. The description adds bulk support context, but does not clarify how actions are selected or what happens if multiple actions are implied. No contradictions.

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

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

The description is lengthy and includes actions irrelevant to the tool's primary purpose (purchases). It could be significantly shortened by focusing on the flattened action and removing redundant action listings that belong to siblings.

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 parameters, no output schema, and 0% schema descriptions, the description should provide more guidance on parameter combinations and return values. It only partially explains the purchases action but omits other parameters and does not address the tool's composite nature.

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

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

Schema description coverage is 0%, meaning no individual parameter descriptions in the schema. The tool description partially compensates by mentioning subscriber_code requirement for purchases, product_ids for bulk, and filters for list. However, parameters like account remain undefined, and the mapping of actions to parameters is unclear.

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, purchases, transactions, switch_plan_plans) that correspond to separate sibling tools. The 'flattened action: purchases' hint is buried and insufficient to clarify that this tool is specifically for retrieving purchase invoices. Thus, it fails to clearly distinguish from siblings.

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

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

No explicit guidance on when to use this tool versus sibling tools like hotmart_subscriptions_list or hotmart_subscriptions_transactions. The description only mentions that purchases requires subscriber_code, but does not provide conditions 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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds context about aggregated totals and bulk support, which enhances transparency beyond the annotations.

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

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

The description front-loads the purpose but includes an extensive list of actions that are irrelevant to this specific tool (since other tools exist). This extra detail dilutes conciseness and could mislead the 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 core function (aggregate totals) and bulk capability, but lacks detail on return format or which parameters specifically apply to the summary. For a read-only tool with no output schema, more guidance on output structure would be helpful.

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

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

With 0% schema description coverage, the description must compensate. It explains parameters for other actions (list, purchases, transactions) but not for the summary action itself. It mentions product_ids for bulk, but the mapping of schema properties to summary is unclear, leaving ambiguity.

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

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

The description clearly states 'Leitura de assinaturas na Hotmart' (reading subscriptions) and specifies the flattened action as 'summary', distinguishing it from sibling tools like hotmart_subscriptions_list and hotmart_subscriptions_purchases. The tool name reinforces the purpose, making it unambiguous.

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

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

The description lists actions but does not explicitly state when to use this tool versus alternatives. It implies the summary action based on '[Flattened action: summary]', but lacks direct guidance or exclusion criteria for other scenarios.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, covering key behaviors. Description adds that subscriber_code is required, but lacks other behavioral context like pagination or response format.

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 not concise; it includes a generic header and lists multiple unrelated actions. The relevant info for this tool is embedded within a larger block, reducing 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?

Incomplete for a tool with 8 parameters and no output schema. Missing explanation of response structure, pagination, filtering, and default behavior. Does not compensate for schema's lack of descriptions.

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

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

Input schema has 8 parameters with 0% description coverage. Only subscriber_code is explained in the description, leaving other parameters (status, product_id, etc.) undocumented and their roles unclear.

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 'switch_plan_plans: planos disponíveis pra troca (requer subscriber_code)' which clearly identifies the tool as listing available plans for switching. However, the description is cluttered with other actions, reducing focus on this specific 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?

Minimal guidance: mentions requirement of subscriber_code but does not specify when to use this tool over siblings like hotmart_subscriptions_write_switch_plan or other list tools. No explicit when-not-to-use or alternative recommendations.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description's mention of actions and bulk support adds some context. However, it does not clarify potential rate limits, authentication requirements, or any side effects beyond the annotations. The description does not contradict 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 moderately concise but includes an awkward '[Flattened action: transactions]' annotation that detracts from clarity. It is structured with a list of actions, but the purpose remains unclear. A more streamlined description focusing on transactions would improve readability.

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

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

Given the tool has 8 parameters (none required), no output schema, and a confusing multi-action scope, the description is insufficient. It does not explain return values, pagination behavior, or how the different actions are invoked. The bulk support mention is helpful but incomplete.

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 listing some filters for the list action (product_id, subscriber_email, status, max_results, page_token) and mentioning subscriber_code for purchases/transactions. However, parameters like 'account' and 'status' are not explained, and the description does not cover semantics for all 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 lists multiple actions (list, summary, purchases, transactions, switch_plan_plans) but the tool name and '[Flattened action: transactions]' suggest it is specifically for transaction-related operations. This creates ambiguity about the tool's primary purpose, especially given sibling tools exist for each action. The verb 'Leitura' (reading) 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?

No explicit guidance on when to use this tool versus sibling tools like hotmart_subscriptions_list or hotmart_subscriptions_purchases. It mentions that purchases and transactions require subscriber_code, but does not state when to use this tool instead of 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 says 'cancela 1+ assinaturas', which is a destructive operation, yet the annotations set 'destructiveHint': false. This is a direct contradiction. No additional behavioral traits like authorization requirements or side effects are mentioned.

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 but includes extraneous information about other actions. The key point (cancel) is mentioned, but the structure could be tighter without listing unrelated capabilities.

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 (7 parameters, nested object, no output schema), the description lacks essential details such as required fields, error handling, return values, and full parameter semantics. It does not compensate for the lack of annotations or schema descriptions.

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 carries full burden but only explains a few parameters: send_mail (default true), charge (default false), subscriber_codes. It fails to describe 'data' (a nested object with additionalProperties), 'account', 'due_day', and 'subscriber_code', leaving the agent with incomplete understanding.

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 mutations on Hotmart subscriptions and specifically mentions 'cancel' as an action, but it also lists other actions (reactivate, change_due_day, switch_plan) that are not relevant to this tool, creating confusion. The title clarifies it is for cancel, but the description's inclusion of multiple actions blurs 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?

No guidance is provided on when to use this tool versus its siblings (e.g., hotmart_subscriptions_write_reactivate). The description lists alternative actions but does not indicate that this tool is specifically for cancel, leaving the agent without clear selection 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 show readOnlyHint=false and destructiveHint=false. The description states 'Mutações' (mutations), which is consistent, but does not add value beyond annotations. No details on side effects, prerequisites, or error cases are provided.

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 a bullet list format but includes irrelevant actions. It is not concise for the specific tool; it could be reduced to a single sentence about changing the due day. The final note about flattened action is helpful but does not compensate for verbosity.

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 7 parameters, 0 required, 0% schema coverage, no output schema, and nested objects, the description is severely incomplete. It does not specify required parameters for change_due_day, explain the data object, or describe the response. An agent cannot reliably use this tool.

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

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

Schema coverage is 0%. The description lists parameters (subscriber_code, due_day, etc.) but does not clarify which are relevant for change_due_day. It includes parameters for other actions, causing confusion. No explanation of nested objects or expected values.

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

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

The description lists multiple actions (cancel, reactivate, change_due_day, switch_plan), but the tool name and final note 'Flattened action: change_due_day' indicate it is specifically for changing the due day. This is confusing and leads to ambiguous 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 guidance on when to use this tool vs. alternatives. Sibling tools like hotmart_subscriptions_write_cancel and hotmart_subscriptions_write_reactivate exist, but the description does not direct the agent to use them. Including unrelated actions in the description misleads agents.

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 mentions that charge defaults to false and that reactivate works on one or more subscriptions, but does not disclose potential side effects, idempotency, or failure modes. Annotations only show readOnlyHint=false and destructiveHint=false, so the description adds some context but not enough.

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 list of actions not relevant to this specific tool, making it longer than necessary. The key information that this tool is for reactivate is placed at the end as a note, not front-loaded.

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

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

Given the complexity (7 params, nested object, no output schema, no annotations), the description fails to explain prerequisites, authentication, error handling, or expected outcomes. It is incomplete for an agent to correctly use 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 7 parameters and 0% schema description coverage, the description only names a few parameters (subscriber_codes, charge, send_mail, subscriber_code, due_day) without explaining their usage, relationships, or constraints. The 'data' parameter is not explained at all.

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 (cancel, reactivate, change_due_day, switch_plan), which suggests a general subscription mutation tool, but the title and final line indicate this tool is specifically for reactivate. This makes the purpose unclear for the agent.

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 vs. sibling tools like hotmart_subscriptions_write_cancel or hotmart_subscriptions_write_switch_plan. The description does not explicitly state that this tool handles only reactivate.

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 mentions 'mutações' (mutations) and lists actions, but for switch_plan it only says 'troca o plano' with reference to external documentation. Without annotations providing safety hints (destructiveHint=false), the description fails to disclose consequences, reversibility, or side effects beyond the minimal statement.

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 but includes irrelevant details about other actions not relevant to this tool's primary function. The phrase '[Flattened action: switch_plan]' helps, but listing all actions is unnecessary and could confuse. It 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?

Given the complexity (multiple optional parameters, nested 'data' object, no output schema), the description is insufficient. It lacks examples, required parameter combinations, and behavior specifics (e.g., what does switching plan entail? Are there prerequisites?). The tool is part of a suite, but no cross-tool context is provided.

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 adds little. It mentions 'data com subscriber_code + novo plano' but does not clarify the structure of the 'data' object (what properties, required fields, types). Other parameters like 'charge' and 'send_mail' are not explained in context of switch_plan, leading to 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 states it is for 'switch_plan' action, but it also lists other actions (cancel, reactivate, change_due_day), causing confusion about the tool's singular purpose. The tool name indicates a single action, but the description implies multiple actions. This muddles the core 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 guidance is provided on when to use this tool versus its siblings like hotmart_subscriptions_write_cancel or hotmart_subscriptions_switch_plan_plans. The description does not specify context or alternatives, leaving the agent to infer from name alone.

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

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

Beyond the sparse annotations, the description discloses critical behaviors: invoke runs tools even when not installed (one-off), returns connect/checkout links for missing auth or empty wallet, and writes require workspace owner/admin. It also flags installed_in_toolkit vs installed_in_workspace. These details significantly exceed the annotation hints.

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

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

The description is lengthy but information-dense, with every sentence contributing operational context—purpose, core flow, key invoke behavior, comparison with install, and permission requirements. It is well-structured and free of fluff.

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

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

Given the tool's complexity (15 parameters, multiple actions, no output schema), the description covers the essential decision tree: search→describe→invoke, auth/payment fallback, and install-vs-invoke guidance. It falls short on exotic parameters and detailed error/return behavior, but it is sufficient for an agent to use the tool correctly in most scenarios.

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

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

With 0% schema description coverage, the description compensates by explaining main action values (search, describe, install, invoke, list_tools) and how parameters like mcp_id, tool_id, and arguments fit the flow. However, it does not describe several parameters such as limit, query, immediate, conversation, tier_slug, cancel_reason, or request_details, leaving partial 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 identifies the tool as 'the official mcp.ai marketplace — the in-platform catalog of every MCP/tool, AND the way to run them.' It outlines the core flow (search→describe→invoke) and distinguishes it from sibling Hotmart-specific tools by being the hub for discovering and executing any MCP.

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

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

The description explicitly tells when to use invoke vs install: 'prefer invoke for a single/occasional use' and 'Use install only to make an MCP PERMANENT in the active toolkit.' It also clarifies when to use list_tools, subscribe/cancel, report_bug, and request_mcp, providing a complete decision framework.

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 says 'Report a bug' implying creation of a new record, which is non-idempotent, but annotation idempotentHint is true—a direct contradiction. No other behavioral traits disclosed.

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

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

Single sentence with two distinct pieces of information. Efficient, though could better structure parameter 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?

Missing details about response, side effects, and integration context. The idempotentHint contradiction also undermines completeness.

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

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

Schema description coverage is 0%, so description must compensate. It only explains the conversation parameter as 'recent messages for reproduction', but leaves message and context unexplained.

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

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

The description clearly states the tool's purpose: reporting bugs, missing features, or feedback. It distinguishes from sibling tools which are domain-specific Hotmart or system 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?

Provides a hint to include conversation array for reproduction, but lacks explicit guidance on when to use alternatives or when not to use this tool.

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

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

Annotations already indicate readOnlyHint true, idempotentHint true, destructiveHint false. The description adds context about what is returned (platform and adapter versions), which is transparent and consistent with annotations.

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

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

Single sentence, no unnecessary words, front-loaded with the essential information. 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?

Despite no output schema, the description is sufficient to understand the tool's purpose. It could be slightly more detailed about the format of version strings, but it's complete enough for a simple tool.

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

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

No parameters exist, so schema coverage is 100%. The description adds no parameter info because none are needed. Baseline for zero parameters is 4.

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

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

The description clearly states the tool shows current MCP platform and adapter versions, with a specific verb ('show') and resource ('versions'), distinguishing it from sibling tools that handle authentication, sales, subscriptions, etc.

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, but its purpose is self-evident as a simple diagnostic tool. The lack of usage instructions is acceptable given its simplicity, but the score is moderate due to missing explicit context.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds context about the returned information (installed MCPs, connection status, catalog counts), going beyond annotations without contradicting them.

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

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

The description is a single sentence that is concise, front-loaded, and contains no unnecessary words. Every word adds value.

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

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

For a tool with no parameters and no output schema, the description fully explains what the tool returns. It is complete for its simplicity.

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

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

The tool has no parameters, and schema coverage is 100%. No additional parameter information is needed, so a baseline score of 4 is appropriate.

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

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

The description clearly states the tool's purpose: to return the current toolkit state including installed MCPs, their connection status, and catalog tool counts. It uses specific verbs and resource, distinguishing it from sibling tools that focus on individual integrations.

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

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

The description implies usage for retrieving overall toolkit status but does not explicitly state when to use it versus alternatives or provide exclusions. It is clear enough for the context.

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