9bot

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful context by noting that forecasts are not recalculated, which confirms a read-only/cached access behavior. It does not go further into auth, staleness, or rate limits, but this is acceptable given 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 concise sentence, front-loaded with the returned object and the key behavioral qualifier. Every part of the sentence contributes meaning and there is 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 seven parameters and low schema coverage, the description is too thin. An agent can understand the purpose and required groupJid, but it cannot confidently understand the optional date/language parameters or when to choose this tool over related reporting tools. The output schema helps with return shape, but input-side context remains 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?

Schema description coverage is only 14%, with just groupJid documented. The description restates group scoping ('para um grupo') but says nothing about jid, days, lang, language, startDate, or endDate, so it does not compensate for the low parameter 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 uses a specific verb ('Retorna'), identifies a concrete resource ('Forecast Payload do Predictive Engine'), and scopes it to a group with the qualifier 'sem recalcular previsoes'. This is clear and unlikely to be confused with sibling report tools, though it does not explicitly name an alternative.

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

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

There is no explicit guidance on when to use this tool versus alternatives. The phrase 'sem recalcular previsoes' implies it is for retrieving an existing/precomputed forecast, but no condition, alternative tool, or exclusion is stated.

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

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

Annotations already indicate destructiveHint=true, and the description merely restates the disable action without adding behavioral context such as reversibility, confirmation requirements, or side effects. It neither adequitely discloses the impact nor contradicts 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 brief and frontloaded with the core action. The second sentence is vague but does not add meaningful bulk, so overall the definition is concise and well-structured.

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

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

For a complex, destructive tool with 7 parameters, nested objects, and low schema coverage, the description is far too thin to be operationally complete. It does not clarify which argument is required, what the destructive effect is, or how to distinguish this from other automation tools.

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

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

With schema description coverage at only 14% and 7 parameters, the description needed to compensate by explaining key parameters like groupJid or confirmation_id. It provides no parameter-level guidance at all, so the agent has nearly no semantic support beyond the sparse 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 a specific action ('desativar anti_link') and a clear resource ('painel 9bot'). It is distinguishable from sibling tools like automations_anti_link_enable or anti_spam, since it unambiguously targets disabling anti-link automations.

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 to use it when the user requests 'automacoes', even with incomplete terms or synonyms, but this is too broad and does not differentiate this tool from the many other automation-related siblings. It does not explicitly say to use this tool only when the user wants to disable anti-link or point to enable/update 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 annotations already flag the operation as non-read-only and destructive, and the description adds no behavioral context such as side effects, required permissions, reversibility, or what enabling anti_link changes. It does not contradict the annotations, but it also does not go beyond them.

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

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

Two short sentences with the main action front-loaded and no filler. It could have expanded parameter guidance, but that is a completeness concern rather than a conciseness or structure problem.

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 destructive mutation tool with five parameters, a nested config object, and dozens of sibling automation tools, this description is far too thin: it omits required inputs, side effects, and how this tool differs from anti_link_disable/update. The agent lacks enough to invoke it safely and correctly.

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

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

Schema description coverage is only 20%, so the description needed to explain the parameters, especially the required groupJid. It mentions none of them, leaving the agent unable to determine what values to pass for groupJid, active, enabled, type, or config.

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 a specific verb ('ativar') and resource ('anti_link') on the 9bot panel, which clearly separates it from anti_link_disable/get/update siblings. The action is immediately recognizable even without relying on the tool name.

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

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

It gives an explicit trigger: use when the user asks for automations, including vague or synonymous phrasing. However, it does not mention when not to use it or name alternative automations tools, and the broad 'user asked automations' rule could overmatch given the many sibling automations 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 and destructiveHint=false, and the description's 'consultar' is consistent with a read-only operation. However, it adds little beyond that alignment: no auth requirements, rate limits, or result behavior are 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?

The description is two sentences with the core action front-loaded. The routing sentence is concise but too broad, so it is not fully earned; otherwise there is 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?

The output schema and read-only annotations cover return values and safety, but the required groupJid is left unexplained and the broad 'automacoes' routing guidance could misdirect the agent among many similar tools. This is not complete enough for reliable selection and invocation.

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

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

Schema description coverage is only 20%, and the description does not explain the required groupJid or the optional active, enabled, and config fields. With low schema coverage, the description needed to compensate, but it does not.

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 a clear action and resource: 'consultar detalhes de anti_link no painel 9bot' (query anti-link details). It is specific enough to identify the get behavior, but it does not actively differentiate itself from sibling tools such as automations_anti_spam_get or other anti_link mutators.

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

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

It provides a trigger ('use when the user asks for automations, even with incomplete terms or synonyms'), but this is too broad given the large number of automation siblings. It gives no exclusions or alternatives, so an agent could route generic automation requests to this specific anti-link getter.

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 annotations already carry the destructive and write-only profile, so the bar is lowered. The description adds modest context by listing which aspects of the anti-link rule are configurable, beyond what annotations state. However, it does not disclose whether the update repaces or merges existing config, what prerequites exist, or what side effects occur on the group — a notable gap for a destructive operation with a free-form config object.

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

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

One single sentence that front-loads the verb and resource and then lists the configurable dimensions. There is no filler, no repetition of schema content, and every word earns its place. The Portuguese phrasing also matches the language of the schema's only field description, keeping the tool definition internally consistent.

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?

Although an output schema covers return values, the operational picture remains incomplete for a destructive, write-oriented tool: the required groupJid is unexplained, the duel active/enabled booleans are ambiguous, and the overwrite-vs-merge behavior of the free-form config is absent. An agent invoking this destructively from the description alone risks clobbering an existing anti-link configuration with incomplete data.

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

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

With schema description coverage at only 20%, the description must compensate. It partially does: the list (modo de ação, domínios permitidos, redes sociais, documentos, texto puro, aviso) maps to the intended contents of the config object, which the schema does not describe. But it leaves groupJid (the required target) unexplained and does not clarify the active/enabled boolean distinction, so compensation is partial.

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

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

The description uses a specific verb (Configura/configure) with a clear resource (anti-link) and enumerates the configuration areas: action mode, allowed domains, social networks, documents, plain text, and warning. This content clearly separates it from the sibling toggles (disable/enable) and the read operation (get), since only an update tool would carry this field list. It stops slightly short of a 5 because it never explicitly names its role as the update variant in the family.

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 given on when to invoke this tool versus alternatives. It does not contrast with automations_anti_link_get (to read current settings), automations_anti_link_disable/enable (to toggle without changing settings), or the generic automations_update (mentioned in the schema's type field). The agent must infer the appropriate scenario entirely from the name.

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 flag destructiveHint=true and readOnlyHint=false. The description confirms the mutation but adds no context about side effects — what disabling anti-spam does to group protection, whether confirmation is required (despite a confirmation_id parameter existing), or what happens to existing settings. Without annotation coverage this would score lower; with annotations present, the description still fails to add meaningful 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 two short sentences with the core action front-loaded. It is appropriately sized for the information it conveys, though the second sentence's guidance is vague and could arguably be replaced with more useful routing or parameter context.

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 destructive tool with 7 parameters and minimal schema coverage, this description is far from complete. It omits which group the action applies to, the confirmation flow implied by confirmation_id, and the operational consequences of disabling anti-spam. The output schema covers return values, but the invocation context is missing.

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

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

With only 14% schema description coverage and 7 parameters, the description must compensate but provides zero parameter information. groupJid, mode/preview, active, enabled, config, and confirmation_id are all left unexplained by the description, so the agent has no semantic understanding of even the required groupJid parameter.

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

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

The description states a specific action — 'desativar anti_spam' (disable anti-spam) — on a specific resource, the 9bot panel. The verb clearly distinguishes this from the enable/get/update sibling tools, though without explicit contrast. The Portuguese phrasing is unambiguous about the mutation intent.

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

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

The description advises using the tool when the user asks about automations, even with incomplete terms or synonyms, but this guidance is overbroad — dozens of sibling tools handle automation requests (automations_get, automations_list, automations_update, automations_anti_spam_enable, etc.). It fails to specify when to choose disable over enable or get, and gives no exclusions or alternatives.

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

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

Annotations already carry readOnlyHint=false and destructiveHint=true, so the description needed to add context about consequences—what gets overwritten, reversibility, or side effects on existing anti-spam config. It adds none of that; 'ativar anti_spam' merely restates the operation without disclosing destructive behavior implied by the annotation.

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 short sentences with no filler; purpose is front-loaded and a usage hint follows in the second sentence. Slight deduction because the second sentence is so vague that it adds little routing value, but overall the prose is economical and every sentence earns its place.

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

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

For a destructive 5-parameter mutation tool with nested objects and a nearly empty schema, this description is inadequate. It fails to state which parameters activate anti-spam, how it differs from automations_anti_spam_update, or what destructiveHint=true implies in practice. The output schema helps, but invocation ambiguity remains unresolved.

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 only 20% (only 'type' is documented), so the description had to compensate for the meaning of groupJid, active, enabled, and config. It mentions no parameters at all and does not map 'ativar' to a specific boolean field, leaving an agent unable to determine how to correctly perform the destructive activation.

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 a specific action ('ativar anti_spam') and a resource with context ('no painel 9bot'), clearly indicating this is an enable operation for the anti-spam automation. It contrasts implicitly with siblings like automations_anti_spam_disable/get, but never explicitly names them to rule them out.

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

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

The description gives an explicit trigger: 'Use quando o usuario pedir automacoes, mesmo com termos incompletos ou sinonimos,' which tells an agent when to invoke based on user intent. However, the rule is too broad given the large family of automation siblings (anti_link, welcome, auto_response, rss, timed_access) and includes no exclusions or alternatives.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description aligns by saying 'consultar'. It adds only the 'painel 9bot' context and no additional behavioral details such as what data is returned or prerequisite conditions.

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 brief sentences are easy to scan and the purpose is front-loaded. However, the second sentence's overly broad routing advice weakens its value, so the structure is compact but not fully effective.

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 sparse schema descriptions and many automation siblings, the description does not provide enough to route correctly or populate parameters. The output schema mitigates return-value ambiguity, but the missing param semantics and broad usage rule leave significant gaps.

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

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

Schema description coverage is 20%, so the schema is largely uninformative; the description does not compensate by explaining the required groupJid or the optional type/active/config/enabled fields. It only implies that anti_spam settings are the target.

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 a specific action ('consultar detalhes de anti_spam') and resource, which distinguishes it from the anti_spam_enable/disable/update siblings. It does not fully explain what an anti_spam detail is, but the core purpose is clear.

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

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

It gives a trigger ('quando o usuario pedir automacoes') but that is far too broad given the many sibling automations_* tools, and it provides no exclusions or alternatives. The instruction is likely to send an agent to anti_spam_get for requests that should go to automations_list, auto_response_get, or anti_link_get instead.

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

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

Annotations already declare destructiveHint=true, so the description correctly elaborates by naming the destructive behavior (apagar mensagens - deleting messages) plus strikes and warnings. It adds some context beyond annotations but does not disclose scope (what messages get deleted), permission requirements, or immediacy of effect.

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

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

A single efficient sentence packs the purpose and the configurable fields with no filler. It loses a point for not front-loading the destructive aspect and for being in Portuguese, which adds a translation burden for English-native agents.

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 5-parameter destructive tool with an open config object, the description covers what the config contains but omits required-parameter semantics (groupJid), the relationship to the generic automations.update, and preconditions for the destructive delete-messages behavior. An output schema exists and softens the need for return-value docs, but the invocation path is still underspecified.

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 only 20%, so the description must compensate. It partially does by mapping the opaque config object to specific anti-spam settings, but groupJid, active, and enabled remain unexplained in both description and schema. The config enumeration adds genuine meaning to the nested object, yet leaves multiple parameters 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 a specific verb (Configura = configures) and resource (anti-spam) and enumerates exactly what is configurable: message limit, time window, deleting messages, strikes, warnings, and admin alerts. It is clearly distinct from the enable/disable/get anti-spam siblings by verb and scope, though it never explicitly names a sibling or the generic automations.update as an alternative.

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

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

No guidance is given on when to call this tool versus automations_anti_spam_enable, automations_anti_spam_disable, automations_anti_spam_get, or the generic automations_update. The only hint is buried in the schema's type parameter description, which is too oblique to count as usage 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 declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds that this is a 'query details' operation in the 9bot panel, which is mildly useful, but it does not describe any behavior beyond that. 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 short and front-loaded with the core action. The second sentence is somewhat generic and less valuable, but the overall length is appropriate and there is no redundant repetition of the tool name.

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 five parameters, a required groupJid, and many closely related siblings, this description is too sparse. The read-only hint is helpful, but the agent still lacks guidance on which parameters to provide, what differentiates this from other automation getters, and what 'detalhes' means operationally. The output schema reduces the need to explain return values, but other gaps remain significant.

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 only 20%, and the description provides no parameter-level guidance at all. The required groupJid parameter is never mentioned, and the only described schema property ('type') is oddly tied to automations.update rather than this get operation. The description does not compensate for the schema's low 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 a clear action ('consultar detalhes de auto_approve_members') and a specific resource, so an agent can identify this as a read operation for auto-approve membership details. It does not explicitly contrast itself with the many sibling automations tools, but the resource name and verb provide enough differentiation for basic selection.

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 'use when the user asks for automations, even with incomplete terms or synonyms,' which is far too broad given the large number of automation-related sibling tools. It does not say when to prefer this tool over automations_get, automations_list, or auto_approve_members_update, nor does it mention that the request must specifically involve auto_approve_members.

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?

As anotações já declaram readOnlyHint=true e destructiveHint=false, e a descrição é consistente com elas ('Permite logs' implica leitura, sem contradição). A descrição adiciona pouco além disso — não fala de paginação, filtros, formato das logs ou limitações — mas com a segurança já coberta pelas anotações, o patamar de 3 é adequado.

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

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

A descrição tem apenas duas frases e é curta, mas a segunda frase ('Use quando o usuário pedir automações...') não justifica seu espaço — é genérica e potencialmente enganosa no contexto dos irmãos. A primeira frase é gramaticalmente estranha ('Permite logs auto_approve_members'), o que reduz a clareza estrutural.

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?

Dada a complexidade — 5 parâmetros, objeto aninhado (config), 1 parâmetro obrigatório e ~170 irmãos — a descrição é insuficiente. Não explica o papel do groupJid, o conteúdo das logs nem como este tool difere do irmão _get. O output schema existente cobre os retornos, mas o comportamento de chamada correto continua subespecificado.

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?

A cobertura do esquema é de apenas 20% (só 'type' tem descrição), e a descrição da ferramenta não menciona nenhum parâmetro. O parâmetro obrigatório groupJid, além de active, enabled e config, fica sem significado semântico na descrição e no esquema, e a descrição não compensa essa lacuna.

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?

A descrição identifica o recurso 'logs auto_approve_members' e o domínio 'painel 9bot', o que o separa superficialmete dos irmãos get/update/test. Porém, o verbo 'Permite' é générico e não diz claramete se a ferrameta lista, consulta ou exporta logs, deixado a ação real ambígua. Está etre um propósito vago e uma tautologia do ome.

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?

A orientação 'Use quando o usuário pedir automações, mesmo com termos incompletos ou sinônimos' é ampla demais diante de ~40 ferramentas irmãs de automação, e não distingue este tool de automations_auto_approve_members_get, automations_get ou automations_list. Não há exclusões nem critérios que direcionem o agente a escolher este tool especificamente para logs, então a orientação pode levar a seleções erradas.

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 flag readOnlyHint=false and destructiveHint=true, but the description adds no behavioral context about side effects, reversibility, or what the test actually changes. The word 'test' may mislead an agent into thinking the call is harmless, so more disclosure was 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 short and front-loaded with the core action. The second sentence adds a usage rule without excessive wording, though the rule itself is problematic.

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 destructive tool with 5 parameters and a vague 'test' behavior, this description is not sufficient. It does not explain what running the test does, how the parameters are used, or any precautions; the output schema covers return values but not behavioral context.

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 only 20%, so the description needed to compensate by clarifying the parameters. It does not: groupJid, type, active, config, and enabled are all left unexplained, and the description adds no parameter-level meaning.

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

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

The description uses a specific verb ('test') and a specific resource ('auto_approve_members'), which helps distinguish it from sibling _get, _logs, and _update tools. However, it does not say what the test does or what scope it operates in, so it is clear but incomplete.

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 include a trigger rule: use it when the user asks for automations, even with incomplete terms or synonyms. But this rule is too broad and misleading because there are many automation tools among the siblings, and the description does not specify when to prefer this test tool over 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 'editar/configurar', which aligns with the destructiveHint and readOnlyHint annotations but adds little beyond them. It does not disclose what changes are applied, whether the operation is reversible, what happens to existing settings, or what effects enabling/disabling auto-approve has.

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

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

The description is concise and front-loads the core purpose in the first sentence. The second sentence is also brief, but it is too generic and could misdirect the agent, so it does not fully earn its place.

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

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

This is a destructive mutation tool with 5 parameters, a nested config object, and only 20% schema coverage. The description does not explain required inputs, parameter semantics, or the scope of the change, leaving major gaps for an agent trying to invoke 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 description coverage is only 20%, and the description does not compensate. It gives no meaning for groupJid, active, enabled, or config, and the config object is entirely unexplained. An agent cannot determine what values parameters accept or how they relate to auto_approve_members.

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 a specific action and resource: 'editar/configurar auto_approve_members no painel 9bot', so an agent can tell this is the update path for auto-approve member automation. However, it does not distinguish this from the many sibling automations_*_update tools; the second sentence says to use it for any automation request, which is too broad.

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

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

It says 'Use quando o usuario pedir automacoes', but that is an overly broad trigger given the large set of sibling automation tools. It provides no information about when to prefer this specific tool over automations_auto_approve_members_get, automations_auto_removal_members_update, automations_auto_response_update, or automations_update.

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, covering the safety profile. The description's 'consultar' (consult/read) verb is consistent with those annotations and adds minor context about operating in the 'painel 9bot'. It does not contradict the annotations but adds little beyond confirming the read nature and the location.

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 compact: two short sentences with the primary purpose front-loaded in the first sentence. There is no fluff or redundant restating of the title. The second sentence is concise though semantically over-broad, but structurally it is efficient.

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

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

Despite having an output schema and read annotations, the tool has 5 parameters (1 required) with 20% schema coverage and nested objects, and the description leaves critical input semantics unexplained — what groupJid refers to, what the config object contains, and what 'detalhes' the call returns. An agent cannot confidently determine how to construct a correct call from this description. The annotations cover safety and the output schema covers return shape, but the input side is a significant 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?

Schema description coverage is only 20% (1 of 5 parameters described), so the description must compensate for the missing parameter semantics — but it names no parameters at all. The required groupJid parameter is left undocumented, and the only schema description for 'type' confusingly references a different tool ('quando usar automations.update'). With high schema coverage, baseline would be 3, but here coverage is low and the description contributes nothing, making the input contract effectively opaque.

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 a specific verb and resource: 'Permite consultar detalhes de auto_removal_members no painel 9bot' (allows consulting auto_removal_members details in the 9bot panel). This identifies a clear read operation on a specific resource. However, it does not specify what 'detalhes' includes, and sibling differentiation is carried mostly by the '_get' suffix in the tool name rather than the description, so it is not a top-tier 5.

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 guidance 'Use quando o usuario pedir automacoes, mesmo com termos incompletos ou sinonimos' (use when the user asks for automations, even with incomplete terms or synonyms) is over-broad and potentially misleading: there are roughly 30 automations_* sibling tools, and routing every automation request to this specific auto_removal_members getter would be wrong. No exclusions are given (e.g., do not use when the user wants to update — that is automations_auto_removal_members_update), and no alternatives are named.

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 safety profile is covered and there is no contradiction. However, the description adds almost no behavioral context beyond the annotation: it only mentions the panel name and repeats 'logs', without disclosing what the logs contain, how they are scoped (e.g., per groupJid), or any pagination/filtering behavior. Credit for the read-only hint cannot raise this above a 2 because the description itself contributes little.

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 (two sentences), but brevity achieved by under-specification, not crafted efficiency. The opening sentence is grammatically broken and restates the name, and the second sentence is a misrouting heuristic — neither sentence earns its place. Front-loading is acceptable in structure, but the content quality fails.

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, a required groupJid, nested objects, and 8 auto_removal_members siblings, the description is far from complete. It does not differentiate itself from automations_auto_removal_members_get/_update/_preview/_simulate, nor explain the purpose of the required parameter. Although an output schema exists (relieving the need to describe return values), the lack of sibling differentiation and parameter semantics leaves an agent unable to invoke this tool correctly.

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

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

Schema description coverage is only 20%, and the description provides zero parameter guidance. Four of the five parameters (active, config, enabled, groupJid) are undocumented in both schema and description, including the required groupJid. The only documented parameter, 'type', has a description that confusingly references a different tool ('quando usar automations.update'), adding noise rather than clarity.

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

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

The description 'Permite logs auto_removal_members no painel 9bot' essentially restates the tool name ('logs auto_removal_members') with a weak verb ('permite') and broken grammar. It never states a concrete action such as 'list', 'view', or 'return' the removal logs, so an agent cannot tell what operation invoking this tool performs. The only added context is 'no painel 9bot', but the core phrase is a near-tautology of the name.

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

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

The only guidance is 'Use quando o usuario pedir automacoes, mesmo com termos incompletos ou sinonimos,' which routes ANY automation request to this logs tool. With roughly 25 automations_* siblings (get, update, preview, simulate, list, etc.), this is actively misleading — a user asking about automations generally should not be directed to a removal-members log viewer. It provides no when-to-use, when-not-to-use, or alternative-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 already declare readOnlyHint=true and destructiveHint=false, so the safe non-destructive nature is covered. The description adds only the preview/simulate framing, which reinforces that no permanent changes are made, but it does not explain what the preview shows, how the simulation behaves, or what limits exist. This is acceptable but not rich.

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

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

The description is concise: two short sentences with the core purpose in the first sentence. The second sentence is somewhat overbroad but still adds a usage cue without unnecessary length.

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

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

This tool has five parameters, a nested config object, and an output schema, plus a nearly identical sibling (automations_auto_removal_members_simulate). The description does not explain how this preview differs from simulate, which parameters matter for a preview, or what the returned preview represents. The output schema reduces the need to document return values, but too much essential context is still missing.

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

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

Schema description coverage is only 20%, and the only described parameter, type, is explained in relation to automations.update rather than this preview tool. The description does not clarify the required groupJid parameter or the purpose of config, active, and enabled. With such low schema coverage, the description needed to compensate and did not.

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 a clear action (pre-visualizar/simular) and a specific resource (auto_removal_members no painel 9bot). However, it does not distinguish this tool from the sibling automations_auto_removal_members_simulate, which appears to perform a very similar function, so it is clear but not fully differentiated.

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

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

The description gives a routing cue: use when the user asks about automations even with incomplete terms or synonyms. But this guidance is overbroad and applies to nearly every automations_* sibling tool, not specifically to this preview operation. It does not mention when to prefer get, simulate, or update variants, nor does it give any exclusion criteria.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description's 'simulate' wording is consistent with those hints, so there is no contradiction. However, the description adds no behavioral context beyond what the tool name and annotations imply: it never states that this is a dry-run that does not actually remove members, what a successful simulation returns, or whether confirmation is needed before performing real removals.

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 front-loaded: the first sentence states the core purpose immediately, and the second sentence adds routing context. No words are wasted, though the second sentence is somewhat vague and could have been replaced with more precise parameter or scope information.

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

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

For a tool with 5 parameters, a nested open-ended config object, and a near-identical sibling (preview), the description is too thin. An output schema exists, which reduces the need to explain return values, but the description still fails to clarify what the simulation actually evaluates, what groupJid refers to, or how this tool relates to the preview sibling, leaving an agent with meaningful gaps before a correct call.

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 only 20% schema description coverage (just the 'type' field is documented) and a low-coverage schema, the description was expected to compensate, but it mentions no parameters at all. The required groupJid is left unexplained, and the open-ended nested config object plus the two similar booleans (active/enabled) receive no semantic guidance, leaving an agent unsure what values are valid or meaningful.

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 a specific verb and resource ('simular auto_removal_members no painel 9bot'), clearly identifying what the tool does. It distinguishes itself from siblings by naming the simulate action, which differs from the get/logs/update variants. However, it does not differentiate itself from the closely named automations_auto_removal_members_preview, so an agent could conflate the two.

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 offers a routing rule ('use when the user asks for automations, even with incomplete terms or synonyms'), but this guidance is overbroad and could misroute generic automation requests to this specific auto_removal simulation tool. It provides no exclusions, no mention of when to prefer _get, _update, or _preview instead, and no clarification of when simulating is appropriate versus other operations.

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

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

The description states editing/configuring, which aligns with destructiveHint, but adds no behavioral context beyond the annotation. It does not disclose what the update affects, whether member removal is triggered immediately, or what side effects may occur.

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 text is short and the core purpose is front-loaded. However, the second sentence is vague and potentially misleading, so not every sentence earns its place.

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

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

Given this is a destructive mutation with five parameters and a nested config object, the description is too thin. It lacks parameter semantics, effects, prerequisites, and guidance on how this tool relates to the sibling preview/simulate/get tools.

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

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

Schema description coverage is only 20%, and the description does not compensate. Required groupJid, active, enabled, and nested config are left unexplained, so an agent cannot determine correct values for the update from the description.

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

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

The description identifies a clear verb+resource: 'editar/configurar auto_removal_members'. This distinguishes it from sibling tools like get, logs, preview, and simulate for the same automation type. It is slightly weaker because it doesn't contrast with the general automations_update 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?

It says to use when the user asks for automations, even with incomplete terms or synonyms, but this is far too broad given the many automation siblings. It provides no exclusions and doesn't point to alternatives like automations_auto_removal_members_get or automations_update.

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, and the description is consistent with them — 'consultar detalhes' is a non-destructive read. It adds only marginal context (the 'painel 9bot' workspace scope) and does not disclose behaviors like auth needs, rate limits, or what 'detalhes' includes, though the output schema partially covers returns. No contradiction with annotations.

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

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

Two short sentences, front-loaded with the core purpose. The second sentence is a genuine usage heuristic but its broadness risks misrouting; overall there is no filler or repetition of the schema.

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 an output schema present and read-only annotations, the return-values and safety halves of the picture are covered. Gaps remain: the required groupJid is unexplained, config's semantics are invisible, and the over-broad usage sentence does not help an agent pick this over the many sibling automation tools. Adequate but with clear gaps for a 5-param tool with nested objects.

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 only 20% (a single parameter, type, has text, and that text points to another tool: 'Tipo da automacao quando usar automations.update'). The required groupJid and the opaque nested config object are undocumented in both schema and description, so an agent cannot infer what to pass. Since coverage is low (<50%), the description was expected to compensate, and it says nothing about 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 states a concrete verb ('consultar' – query) and a specific resource ('detalhes de auto_response no painel 9bot'), which clearly identifies this as the read-only getter for auto_response among the many automations_*_get siblings. It does not, however, contrast itself with sibling getters like automations_anti_link_get or automations_welcome_get, so differentiation relies mostly on the resource name. Clear enough for a 4.

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

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

It provides an explicit trigger — 'Use quando o usuario pedir automacoes, mesmo com termos incompletos ou sinonimos' — which tells an agent to apply it to vague automation requests. But that condition is too broad: it would route nearly any automation request to this tool, and it names no when-not-to-use cases or alternatives such as automations_auto_response_update for mutations. Some context exists, but no exclusions or alternatives.

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

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

Annotations already mark the tool as non-read-only and destructive, but the description adds no behavioral context beyond that. It does not explain that existing responses may be overwritten, what impact active/enabled have, or whether a group must already exist. There is no annotation contradiction, but the description contributes little 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 a single front-loaded sentence with no filler, which is concise. However, it is so terse that it provides little structure or additional useful context beyond the bare minimum.

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 destructive update tool with five parameters, a nested free-form config object, and many automations_* siblings, this description is not complete enough. It omits parameter semantics, usage guidance, and behavioral details needed to invoke the tool confidently.

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 only 20%, with only the 'type' parameter described. The description hints that the config relates to keywords or phrases, but it does not explain groupJid, active, enabled, config structure, or how to combine them. An agent would struggle to construct a valid request from this information.

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

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

The description uses a specific verb ('Configura') and resource ('respostas automáticas') with a clarifying qualifier ('por palavras-chave ou frases'), so an agent can understand what the tool does. It does not explicitly mention 'update' or contrast with automations_auto_response_get, but the intended action is reasonably clear.

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

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

There is no guidance about when to use this tool versus automations_auto_response_get, automations_update, or the other automations_* update tools. An agent must infer from the tool name that this updates existing keyword/phrase auto-response settings; no alternatives, prerequisites, or exclusions are stated.

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

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

As anotações já declaram readOnlyHint=true e destructiveHint=false, e a descrição é consistente com elas. A descrição acrescenta pouco além do contexto 'painel 9bot'; não informa, por exemplo, se é necessário groupJid, como o resultado é filtrado ou o que acontece na ausência de dados. Com anotações seguras, 3 é adequado.

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?

Duas frases curtas, com o propósito na primeira posição e sem palavras redundantes. A frase de uso é um pouco genérica diante da quantidade de ferramentas irmãs, por isso não recebe 5.

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?

Para uma ferramenta com 5 parâmetros, schema pouco descritivo e uma grande família de irmãos automations_*, a descrição é curta demais: omite o parâmetro obrigatório, não esclarece o escopo (uma automação específica vs. todas) e não ajuda a diferenciar de automations_list ou automations_update. O output schema existe, mas não compensa a falta de orientação sobre entrada.

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?

A cobertura do schema é de apenas 20%; quatro dos cinco parâmetros não têm descrição e o texto da ferramenta não explica nenhum deles nem menciona o groupJid obrigatório. A única descrição de parâmetro existente ('Tipo da automacao quando usar automations.update') é confusa em uma ferramenta de leitura, e a descrição não compensa essa lacuna.

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?

A descrição declara o verbo e o recurso: consultar detalhes de automações no painel 9bot. Isso distingue claramente a operação de leitura, mas não diferencia o escopo em relação a automations_list ou aos vários automations_*_get, então não chega a 5.

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?

Há uma instrução explícita de quando usar: quando o usuário pedir automações, mesmo com termos incompletos ou sinônimos. Porém, não há exclusões nem alternativas nomeadas entre os muitos irmãos automations_*, o que limita a precisão da seleção.

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 safe read-only nature is covered. The description adds that the tool reports 'estado' (status) scoped to a group, but it does not describe auth needs, pagination, or output behavior; the presence of an output schema mitigates this somewhat.

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

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

The description is one short sentence with no filler, and the key action 'Lista estado' is front-loaded. It earns its place without unecessary detail.

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

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

For a simple read-only list operation with one well-documented parameter and an output schema, the description is largely sufficient. The main gap is the lack of guidance about which sibling automations tools should be used instead, but that is not crippling for this basic use case.

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 sole parameter groupJid is 100% documented in the schema as the WhatsApp group JID. The description only restates the group-level scoping and adds no extra format, constraints, or examples 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 names a specific action and resource: it lists the state of automations per group. The group scoping helps distinguish it from broader list/get tools, but it never explicitly differentiates from automations_get or the many other automations_* siblings.

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

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

The description implies the tool is used to fetch automations status for a specific group, but it gives no guidance on when to prefer this over automations_get, automations_update, or the other automations_* tools. No alternatives or exclusions 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 already provide readOnlyHint=true and destructiveHint=false. The description's 'Consulta' simply restates the read-only behavior and adds no further behavioral context, such as error cases, authentication needs, or what happens when no RSS configuration exists. It does not contradict the annotations, but it adds no behavioral value beyond them.

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

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

The description is a single concise, front-loaded sentence with no filler. It loses a point because its brevity comes at the expense of useful context, but structurally it is efficient.

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

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

With readOnly annotations and an output schema present, a basic call using only the required groupJid is reasonably inferable, and the resource being queried is clear. However, the optional input parameters are unexplained and no usage guidance is given, leaving notable gaps for a tool with five parameters and a nested config object.

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 only 20%, so most parameters (active, enabled, config, groupJid) lack descriptions. The description only weakly implies groupJid through 'de um grupo' and does not clarify the roles of type, active, enabled, or the nested config object.

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

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

The description uses a specific verb ('Consulta') and a specific resource ('configuração RSS/notícias automáticas de um grupo'), which clearly identifies the tool's purpose. This distinguishes it from sibling tools like automations_rss_update, automations_rss_validade, and the generic automations_get.

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

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

No guidance is provided about when to use this tool instead of alternatives such as automations_rss_update, automations_rss_validade, or automations_get. The description states what the tool does but gives no context for selection among the many automations_* siblings.

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

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

The annotations already indicate destructiveHint=true, but the description does not disclose what may be destroyed or overwritten, nor what side effects follow an update. The active=true instruction adds minor usage nuance, but the potentially destructive behavior remains opaque.

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, front-loaded, and contains no filler. The two sentences each carry useful information, though the brevity does sacrifice some needed detail.

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, a destructive hint, and no explanation of the required groupJid or scheduling fields, this description is too incomplete. It also fails to clarify what 'update' means in this context, leaving too much to inference.

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 adds little beyond the schema: it only restates the active=true activation rule, which the schema already documents. With 50% schema coverage and 8 parameters, it should compensate for undocumented fields like groupJid, scheduleMode, and scheduleTimes, but it does not.

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 a clear action and resource: 'Cria noticias recorrentes por RSS no menu Workflows'. However, the tool is named 'update', so the described 'create' behavior is not aligned with the name. It also does not distinguish this tool from siblings such as workflows_rss_create or automations_rss_get.

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

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

It gives one explicit usage directive: set active=true when the user asks for activation, and remind the user that management happens at /dashboard/workflows. That is useful operational context. But it never explains when to choose this tool over alternatives, nor when not to use it.

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

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

The annotations already declare readOnlyHint=false and destructiveHint=true, so the agent is warned that this is not a safe read-only operation. The description adds no extra behavioral context, such as what may be modified, removed, or disabled during validation, but it does not openly 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 two short sentences, front-loads the main purpose, and contains no redundant filler. The structure is compact and easy to parse, even though the usage guidance is imprecise.

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?

An output schema exists, so return values are covered, but this is a destructive-capable tool with a vague validation action. The description omits side effects, what exactly gets validated, and how this relates to the RSS get/update siblings, leaving important operational gaps.

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

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

Schema description coverage is only 20%, and the description explains none of the parameters. The required groupJid, config, active, and enabled fields remain semantically unexplained, so an agent would not know how to configure the validation request.

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 names the action 'validar rss' and the target 'painel 9bot', which distinguishes it from the sibling tools automations_rss_get and automations_rss_update. However, it does not clarify what 'validar' actually involves, leaving the concrete scope somewhat vague.

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

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

The instruction 'use quando o usuario pedir automacoes' is far too broad because there are dozens of automation-related siblings. It gives almost no guidance on when this specific RSS validation tool should be selected over alternatives like automations_rss_get or automations_rss_update.

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 annotations already declare readOnlyHint=false and destructiveHint=true, and the description confirms a mutating operation. However, it does not explain what gets changed or destroyed, whether existing configurations are overwritten, or what side effects temporary access expiration may have.

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 redundant words. It is concise and readable, though the brevity comes at the cost of important operational detail.

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 destructive tool with a nested config object, 5 parameters, and only 20% schema description coverage, this description is far too minimal. The output schema exists so return values do not need explaining, but the missing usage guidance, parameter semantics, and behavioral detail make it inadequate for correct invocation.

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

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

Schema description coverage is only 20%, with only 'type' having any description. The tool description adds almost no parameter-level meaning: it does not explain groupJid, config, active, or enabled, nor how they map to temporary access or expiration. With such low schema coverage, the description needed to compensate and did not.

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 a specific action ('Configura' = configures) and a clear resource ('acesso temporário/expiração de membros do grupo' = temporary access/expiration of group members). However, it does not explicitly distinguish itself from sibling timed-access tools like automations_timed_access_remove or list.

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

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

There is no guidance on when to use this tool versus siblings such as automations_timed_access_remove, list, or logs. The description does not mention prerequisites, alternatives, or exclusions, so the agent must infer when 'add' is appropriate.

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 need not repeat that. It does add the context that this is a read/list operation in the 9bot panel, which is consistent. However, it does not disclose anything else about behavior such as filtering, pagination, or required scoping beyond what annotations and the schema 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?

Two short sentences, front-loaded with the core verb and resource, and no filler. The second sentence adds routing guidance, though it is somewhat overbroad; still, the definition is appropriately compact.

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 output schema partially covers return values, and the read-only annotation covers safety. But the definition is incomplete for a list tool: it lacks parameter semantics, does not explain the required groupJid, and gives overbroad selection guidance that ignores numerous more specific automation siblings. An agent would need external knowledge to call this correctly in ambiguous cases.

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 only 20% (only 'type' has a description, and it refers to automations.update rather than this list tool). The description itself mentions none of the five parameters and does not clarify the required groupJid or how active/enabled/config/type affect the listing. This is a clear gap for a tool with an unexplained required parameter.

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

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

The description clearly states a specific verb ('listar/consultar') and resource ('timed_access') in the 9bot panel, which distinguishes it from many siblings at a basic level. However, the broader phrase 'quando o usuario pedir automacoes' blurs the line with the large family of automations_* tools, so it is not fully discriminative.

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

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

It gives an explicit trigger ('use when user asks for automations, even with incomplete terms or synonyms'), but it offers no exclusions or alternatives. Given the large sibling set covering anti_link, anti_spam, welcome, rss, auto_response, etc., this guidance is too broad and could lead an agent to select this tool for unrelated automation requests.

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 annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds no behavioral context beyond that: no mention of return shape, scope, pagination, or effects, and it does not explain what 'logs' means in practice.

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 front-loaded with the resource, but the second sentence about using it whenever the user asks for automations is too generic and adds little decision value. It is concise, though the structure prioritizes a vague usage directive over operational specifics.

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 five parameters, one required, nested config objects, a complex sibling family, and a low schema coverage, this description is far from sufficient. It does not state what the logs contain, how to filter them, or what the output schema represents, so an agent cannot reliably invoke it.

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

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

Schema description coverage is only 20%, and the one described parameter (type) is documented as 'when using automations.update', which is misleading for a logs tool. The description itself explains none of the five parameters, including the required groupJid, so there is nothing to compensate for the schema gap.

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

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

The description names the resource 'timed_access logs' and the panel '9bot', which distinguishes it somewhat from siblings like timed_access_add/list/remove. However, the verb 'Permite' (allows) is vague and does not state the actual operation (e.g., retrieve, list, view), leaving the tool's purpose ambiguous.

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

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

It instructs use when the user asks for automations, even with incomplete terms or synonyms, but this is too broad and does not differentiate among the many automations_* siblings. No mention of when not to use it or of the more specific timed_access alternatives, so an agent could select this tool for any automation request.

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

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

Annotations already mark destructiveHint=true, so the mutation risk is known. The description adds only 'no painel 9bot' and does not disclose permanence, confirmation flow (despite confirmation_id parameter), or what data is affected beyond the resource name.

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 first sentence is short and front-loaded. The second sentence is vague and does not earn its place, and the description lacks useful structure for a 7-param destructive tool.

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

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

For a destructive tool with 7 params, an output schema, and a low-coverage schema, this description is far too thin. It leaves the required groupJid, the preview mode, and confirmation semantics unexplained.

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 only 14%, and the tool description does not clarify any of the 7 params (groupJid, mode, confirmation_id, config, etc.). With such low coverage, the description was obligated to compensate and did not.

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 a specific verb ('remover') and resource ('timed_access no painel 9bot'), which clearly states what the tool does. It does not explicitly distinguish it from the many automations_* siblings or from automations_update, and the second sentence broadens the trigger to all automations requests, so it stops short of a 5.

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 phrase 'Use quando o usuario pedir automacoes' is actively misleading: it routes any automation request to a tool that only removes timed access, when there are dedicated add/list/log/update siblings. It gives no exclusions and no alternatives, so an agent could select this tool for the wrong intent.

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?

As anotações já indicam destructiveHint=true e readOnlyHint=false; a descrição não as contradiz. Ela acrescenta que a automção é selecionada por tipo, mas não detalha o comportamento da atualização, como substituição de config ou efeitos colaterais. A transparência é mínima, mas não contraditória.

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

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

A descrição é uma frase única e objetiva, com o verbo no início e a lista de tipos compacta. Cada elemento contribui para o entendimento imediato da função.

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?

Embora exista output schema, a descrição e o esquema deixam ambiguidades importantes: type não é obrigatório no esquema, embora a descrição diga que a atualização é por tipo; config é um objeto aberto sem orientação; e não há orientação sobre o relacionamento com as ferramentas específicas. Isso torna a chamada correta incerta para um agente.

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?

A cobertura do esquema é de 20% e a única descrição existente, a do parâmetro type, repete o nome da ferramenta. A descrição da ferramenta compensa parcialmente ao listar tipos naturais aceitos, mas não explica active, enabled, config nem groupJid, deixando o agente sem semântica suficiente para os demais parâmetros.

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?

A descrição afirma claramente a ação (Atualiza) e o recurso (automação do grupo), e acrescenta a informação de que a atualização é feita por tipo, listando valores aceitos. Não distingue explicitamente dos irmãos específicos como automations_rss_update, mas o escopo básico é compreensíve.

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?

Não há orientação sobre quando us ar esta ferramenta em vez das ferramentas específicas de atualização (rss, welcome, antiLink, etc.). A listagem de tipos sugere o uso, mas sem critérios de seleção nem exclusões, o agente pode não saber se deve escolher automations_update ou automations_rss_update.

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 only restates the destructive action 'desativar' and does not explain side effects, reversibility, prerequisites, or what happens to the welcome configuration. The destructiveHint annotation covers the broad risk, but the description adds little behavioral context beyond what the name and annotation already provide.

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

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

The description is brief and front-loaded, with no filler content. It loses a point because the second sentence adds a broad and potentially misleading usage instruction.

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 output schema and destructive annotation reduce the need to describe return values and risk, but the description still lacks operational details: what 'welcome' refers to, which parameters are needed, and what the disable action changes. For a destructive tool with low schema coverage, this is insufficient.

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

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

Schema description coverage is only 14% and the description provides no parameter guidance. Fields like groupJid, active, enabled, config, mode, and confirmation_id remain unexplained, which is especially problematic for a 7-parameter destructive tool.

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

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

The description clearly states the action: desativar welcome no painel 9bot, which is a specific verb and resource. It distinguishes the disable intent from welcome get/preview/update siblings, though it does not explicitly name those alternatives.

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 to use it when the user asks for 'automacoes' even with incomplete terms or synonyms, but this trigger is much broader than the tool's actual purpose. It provides no exclusions or alternatives, so an agent could misselect this tool for any automation-related request.

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?

As anotacoes ja informam readOnlyHint=false e destructiveHint=true, entao o perfil de seguranca esta coberto. A descricao acrescenta pouco alem disso — nao detalha efeitos colaterais, pre-requisitos, nem o que ocorre com a configuracao existente ao ativar. Nao ha contradicao com as anotacoes.

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

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

A descricao e curta e front-loaded: o proposito vem primeiro e a heuristica de uso em segundo lugar, sem verbosidade. A segunda oracao e um tanto vaga, mas nao incha o texto.

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?

A ferramenta tem 5 parametros, objetos aninhados e hint destrutivo, mas a descricao e minimalista e nao da conta dessa complexidade. O esquema de saida existente cobre o retorno, mas pre-requisitos, efeitos colaterais e a semantica dos parametros-chave ficam de fora — insuficiente para um agente invocar com seguranca.

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?

A cobertura do esquema e de apenas 20% — so o parametro 'type' tem descricao. A descricao da ferramenta nao explica 'groupJid', 'active' vs 'enabled', nem a estrutura de 'config', que e um objeto aninhado. Os nomes sao parcialemente auto-evidentificaveis, mas a distincao funcional entre active e enabled e os valores aceitos de type ficam sem semantica.

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?

A descricao afirma um verbo especifico ('ativar') e recurso ('welcome') no contexto do 'painel 9bot', deixando claro o que a ferramenta faz. No entando, nao diferencia explicitamente as irmas automations_welcome_disable/_get/_update — a distincao vem do proprio nome da ferramenta, nao da descricao.

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?

A descricao orienta o uso quando o usuario pedir 'automacoes, mesmo com termos incompletos ou sinonimos', o que da uma heuristica de disambigacao util. Porem, como ha mais de 30 ferramentas automations_* irmaas, essa instrucao e ampla demais para rotear corretamente; nao menciona alternativas nem quando NAO usar.

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, and the description's 'consultar' is consistent with a read operation. It adds only the 9bot-panel context and does not disclose response behavior, but with the annotations covering safety, this is acceptable.

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 short, front-loaded sentences: the first states the action and resource, the second gives a trigger condition. There is no filler, repetition, or unnecessary detail.

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 five parameters, a nested config object, and a large sibling toolset, this minimal description leaves important invocation details unstated, particularly the meaning of the required groupJid and how optional fields apply to a read operation. The presence of an output schema reduces the need to describe return values, but the selection and parameter context is still too thin.

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 only 20%, and the description provides no parameter guidance at all. The required groupJid is left semantically unexplained, and the roles of active, enabled, config, and type in a GET call are not clarified, so the description fails to compensate for the sparse 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 a specific read action ('consultar detalhes de welcome') and a resource ('painel 9bot'), which clearly distinguishes it from welcome update/disable/enable actions. It does not explicitly contrast it with automations_welcome_preview or the broader automations_get/automations_list siblings, so it stops short of full 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?

The description gives an explicit trigger ('Use quando o usuario pedir automacoes') and mentions tolerance for incomplete terms or synonyms. However, this trigger is overbroad—most general automation requests would better fit automations_list or automations_get—and it provides no exclusions or named 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's 'pre-visualizar/simular' wording clearly indicates a non-mutating preview action, which aligns with the readOnlyHint=true and destructiveHint=false annotations. It adds the context that this happens 'no painel 9bot,' going slightly beyond the structured data.

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

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

The description is very concise: two short sentences, with the core purpose front-loaded and the usage hint in the second sentence. Every part adds information, and there is no redundancy.

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

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

Although annotations and an output schema exist, the description omits essential parameter context, especially the required groupJid, and gives overly broad usage guidance that doesn't account for the many related automation tools. An agent would still need to infer critical details about what this preview actually requires and returns.

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 provides no explanation of the parameters, not even the required groupJid. Schema description coverage is only 20%, and the single existing property description ('type') refers to automations.update rather than this preview tool, so the description fails to compensate for the schema gap.

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

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

The description states a specific action ('pre-visualizar/simular') and a specific resource ('welcome') within the 9bot panel. This distinguishes it from get/update/enable/disable welcome tools, though the broad usage phrase 'quando o usuario pedir automacoes' introduces some ambiguity about scope.

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

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

The description gives an explicit when-to-use hint: use it when the user asks about automations, even with incomplete terms or synonyms. However, it does not mention alternatives or when not to use it, and the broad reference to 'automacoes' could over-route the agent toward this tool instead of related automations_* 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 flag this as mutating and destructive, but the description adds no behavioral detail beyond what is being configured. It does not say whether the update overwrites the entire welcome config, whether enabled/active must be set together, or what side effects occur on existing automations.

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 filler, and the listed configuration dimensions add real meaning. It is slightly too terse for a tool with five parameters and a nested object, but the structure is efficient.

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

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

For a mutating tool with a nested config object, five parameters, and a large family of welcome and automation siblings, the description is not complete enough. It omits the meaning of the required groupJid, the type parameter's role, the enabled/active distinction, and the relationship to the welcome enable/disable siblings. The output schema reduces the need to describe return values, but invocation guidance is still thin.

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 only 20%, and the description does not compensate enough. It names high-level configuration areas that likely map to the config object, but it does not explain the roles of type, active, enabled, or groupJid, nor does it give field names or formats for the nested config object.

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

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

The description clearly states the action and resource: 'Configura boas-vindas do grupo' and lists the configuration dimensions it covers (private message, group message, smart mode, delay). It is specific enough to distinguish this from welcome enable/disable/get/preview siblings, though it does not explicitly name sibling alternatives.

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: an agent can infer this tool is for configuring welcome automation settings, not for enabling/disabling or viewing them. However, there is no explicit guidance about when to prefer this over automations_welcome_enable, disable, get, or preview, and no prerequisites or exclusions 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?

Annitations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description reinforces the non-destructive preview nature but adds no further behavioral context such as return behavior, error cases, or whether previewing consumes resources. It adds some value but remains fairly thin.

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 with no filler. The purpose is front-loaded, and the key accepted parameter families are summarized efficiently.

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 output schema exists, so return values do not need explanation. But with 10 optional parameters and zero schema description coverage, the description leaves several meaningful parameters undocumented, especially sendAt, scheduledTime, and preview. An agent would not have enough context to correctly configure a preview beyond a basic message and group.

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 usefully identifies groupJid/groupJids as target groups and message/text/body as message content, reducing ambiguity among aliases. However, it leaves id, groups, sendAt, scheduledTime, and preview unexplained, which is incomplete for a 10-parameter 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 uses a specific verb ('Pre-visualiza') with a clear resource ('broadcast/envio em massa') and scope ('um ou mais grupos'). The phrase 'antes de disparar' explicitly frames it as a dry-run, distinguishing it from actual send tools like broadcast_send.

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

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

The description gives clear usage context: use this tool to preview a broadcast before actually triggering it. It does not explicitly name alternative tools or state when not to use it, but the 'antes de disparar' guidance is strong enough to route an agent away from broadcast_send.

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 destructiveHint=true, so the destructive nature is known. The description adds that only authorized groups are targeted, which is useful, but does not disclose effects such as immediate mass delivery or irreversibility.

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

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

The description is one compact sentence with no filler. It is front-loaded with the core action and then lists key accepted parameters, though it is very sparse.

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 10 optional parameters, no required fields, 0% schema coverage, and a destructive annotation, the description is insufficient for reliable invocation. It covers a few parameter names but omits scheduling, preview, recipient-array semantics, and expected effects.

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 lists groupJid/groupJids and message/text/body as accepted inputs, but leaves sendAt, scheduledTime, preview, groups, and id unexplained, and does not clarify alias relationships or required choices.

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 sends broadcast/mass messages to authorized groups, with a specific verb and resource. It does not explicitly distinguish the tool from the sibling broadcast_preview, but the send action is clear enough.

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?

There is no guidance on when to choose this tool over alternatives such as broadcast_preview or schedule-based sending tools. The mention of 'authorized groups' is a constraint, not usage direction.

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 annotations already declare destructiveHint=true and readOnlyHint=false, so the description's 'remover' only repeats the annotation. It adds no context about permanence, required confirmation, side effects, or whether deletion is idempotent. The 'confirmation_id' parameter hints at a confirmation flow, but the description never explains it.

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 the second sentence is vague and arguably misleading, so it does not earn its place. The first sentence is clean and efficient, but overall structure fails to deliver useful, scoped guidance.

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 destructive operation with 9 parameters and zero schema descriptions, this description is critically incomplete. It lacks parameter meanings, target-identification guidance, confirmation requirements, and any mention of what happens after deletion. The output schema exists but the description still fails to make the tool safely usable.

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 there are 9 parameters with no required fields. The description provides no guidance on which parameter identifies the api_config to delete, what 'mode: preview' does, or how 'confirmation_id' is used. An agent cannot infer how to invoke this tool reliably from the description.

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

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

The first sentence clearly states the operation: removing custom api_configs in the 9bot panel, distinguishing it from list/save siblings. However, the second sentence introduces ambiguity by saying 'use when the user asks for commands' without specifying deletion, which slightly muddles the purpose.

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

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

The only usage guidance is 'use when the user asks for commands, even with incomplete terms or synonyms.' This is far too broad for a delete tool and could mislead an agent into selecting it for listing, creating, or updating commands. No exclusions or alternatives are mentioned.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description confirms the read-only nature ('listar/consultar') without contradicting anything, but adds no further behavioral context such as filtering semantics, result scope, or pagination. With the annotation bar lowered, a baseline 3 is appropriate.

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 compact sentences with zero filler. The first delivers the purpose front-loaded, and the second adds the usage trigger ('mesmo com termos incompletos ou sinonimos'), which earns its place by clarifying fuzzy-match tolerance. Every word contributes.

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

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

For a read-only list tool with an output schema and safety annotations, the essentials are present: purpose, usage trigger, and non-destructive nature. The clear gaps are the unresolved api_configs-vs-'comandos' relationship and the absence of any parameter semantics, both of which matter for correct invocation. Adequate 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?

Schema description coverage is 0% across 7 parameters, and the description contributes nothing about them. It never indicates that name, command, enabled, trigger, commands, groupJid, and response serve as filters for the listing. Since coverage is below 50%, the description was required to compensate and did not; only the self-evident parameter names offer any hint.

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 a specific action and resource: 'listar/consultar custom api_configs no painel 9bot' (list/query custom api_configs). The verb and resource are clear. However, the second half equates this with generic 'comandos' requests, which blurs the resource boundary given the many command-list siblings (commands_custom_list, commands_system_list) present in the toolset.

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?

Gives explicit positive trigger conditions: use when the user asks for commands, even with incomplete terms or synonyms — this signals tolerance for fuzzy input. But it names no alternatives and offers no exclusion rules, so the agent cannot tell when commands_custom_list or commands_custom_get would be the better choice. Clear context, no 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 mark this as non-read-only and destructive, so the agent knows it writes/mutates. The description adds no behavioral context beyond that—it doesn't say whether existing api_configs get overwritten, whether the save is an upsert, or what side effects occur.

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 short sentences with no filler; the key action is front-loaded. The mixed English/Portuguese phrasing is awkward but not bloated.

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 destructive save tool with 7 undocumented parameters, the description is far too thin; there is no guidance on required inputs, accepted formats, or overwrite behavior. The output schema does not remedy the input ambiguity.

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 7 parameters with 0% description coverage and no enums, and the description names none of them. There is no compensation for the schema gap, so an agent cannot determine how to fill 'name', 'command', 'trigger', 'commands', 'groupJid', 'response', or 'enabled'.

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 a concrete action ('save') on a specific resource ('custom api_configs' in the 9bot panel), so it is not a tautology. However, it doesn't clarify whether this is a create or update operation, and the routing phrase 'quando o usuario pedir comandos' is broad enough to apply to many sibling command tools.

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

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

The description gives an explicit trigger ('use when the user asks for commands, even with incomplete terms or synonyms'), but it provides no contrast with sibling tools such as commands_custom_api_configs_delete/list or commands_custom_create/update. This is more than no guidance, but it's too broad to reliably select this specific save 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 declare readOnlyHint=false and destructiveHint=true, and the description's 'set' wording is consistent with them — no contradiction. However, for a destructive operation the description adds nothing about what gets overwritten (e.g., an existing api_password) or what side effects occur; it only supplies the location 'painel 9bot', which is thin added 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?

Two short sentences with the primary action front-loaded and no filler. It earns points for brevity, though the second sentence's value is questionable because it introduces routing confusion rather than clarifying the tool.

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

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

Even though an output schema exists and annotations cover the safety profile, everything operational is unexplained: 7 parameters with 0% schema coverage and zero parameter guidance, no disclosure of the destructive side effect, and no relationship to the closely related commands_custom_api_password_status/verify siblings. For a write tool flagged destructiveHint=true, this is severely underspecified.

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 names no parameters at all. Worse, the 7 schema fields (name, command, enabled, trigger, commands, groupJid, response) resemble a command-definition object rather than a password, and none obviously represents an api_password. An agent has no way to map user intent to 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 first sentence states a specific operation — 'set custom api_password no painel 9bot' — with a clear verb, resource, and location, and it separates the set operation from sibling status/verify tools. However, the second sentence ('Use quando o usuario pedir comandos...') muddles the scope by tying a password-setting tool to generic command requests, leaving the actual purpose ambiguous.

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

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

The description gives an explicit 'use when' trigger, telling the agent to use this when the user asks for commands, even with incomplete terms or synonyms. But this guidance is misplaced: a user asking for commands would more plausibly need commands_custom_list/get/create, and no alternatives or exclusions are named. The routing advice is more likely to mislead than help.

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 safety profile is covered. The description adds only the 9bot panel context and the word 'status'; it does not disclose what status information is returned or whether authentication is required, but no contradiction exists.

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

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

The description is short, but the first sentence is grammatically awkward and largely restates the tool name. The second sentence provides an actionable use case, yet the structure is not polished enough to be considered high quality.

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?

Although an output schema exists and annotations cover safety, the description leaves the meaning of 'status' and the role of the 7 optional parameters unexplained. For a status tool among many similar command tools, this is not enough context for confident selection and invocation.

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

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

Schema description coverage is 0% for 7 parameters, and the description adds nothing about name, command, enabled, trigger, commands, groupJid, or response. The description does not compensate for the missing parameter documentation.

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

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

The description says 'Permite status custom api_password no painel 9bot', which lacks a clear verb like gets/checks and mostly restates the tool name. It does not distinguish this status tool from sibling commands_custom_api_password_set/verify or commands_custom_get/list.

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

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

It gives a trigger ('use when the user asks for commands, even with incomplete terms or synonyms') but this is overbroad and does not point to the actual scenario of checking API-password status. No alternatives or exclusion criteria are provided, so an agent could select the wrong tool from the large commands_* sibling group.

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 'verify', which strongly implies a safe checking operation, while the annotations declare readOnlyHint=false and destructiveHint=true. This is a direct contradiction: an agent would reasonably expect a verification tool to be non-destructive. The description also discloses no side effects, authentication requirements, or consequences of calling the 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 short and avoids bloat, which is positive. However, it mixes an awkward bilingual phrase ('Permite verify') with a routing-style instruction that feels disjointed from the tool name. It is compact but not well-structured enough to be highly useful.

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 destructive annotations, 7 undocumented parameters, a name suggesting verification, and no required parameters, this description is severely incomplete. It does not explain return behavior, side effects, parameter usage, or how to distinguish this from the related commands_custom_api_password tools. An agent cannot safely select and invoke this tool based on the provided text.

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

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

There are 7 parameters with 0% schema description coverage and the description provides no parameter guidance at all. The parameter names (name, command, enabled, trigger, commands, groupJid, response) do not obviously relate to 'api_password' verification, so an agent has no way to map the intended data to the schema. The description completely fails to compensate for the schema gap.

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

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

The description names a verb and resource ('verify custom api_password no painel 9bot'), so the general domain is clear. However, it does not explain what 'verify' actually returns or does, and the added trigger about 'usuario pedir comandos' muddies the purpose instead of clarifying it. It also fails to distinguish this from sibling tools like commands_custom_api_password_set or commands_custom_api_password_status.

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

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

There is an explicit usage trigger: 'Use quando o usuario pedir comandos, mesmo com termos incompletos ou sinonimos.' This gives some context for when the tool should be invoked. But it does not explain when not to use it, does not name alternatives, and the connection between asking for commands and verifying an API password is not made.

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 annotations already indicate a non-read-only, destructive operation, so the description does not need to restate that. However, it adds no behavioral context beyond the literal action: it does not mention overwriting existing commands, idempotency, side effects, or permission requirements. The description neither contradicts the annotations nor enriches 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, efficient sentence with the action front-loaded and no redundant wording. It is concise and grammatically clean. However, it is terse to the point of under-specification, so it does not earn a 5.

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 six parameters, no schema descriptions, and a destructive hint, the one-line description is insufficient for an agent to invoke it confidently. The output schema exists, so return-value documentation is not required, but the description omits usage context, parameter semantics, and distinctions from nearby sibling tools. The definition is not minimally viable for correct tool selection.

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

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

Schema description coverage is 0%, so the description needed to compensate by explaining the meaning of the six parameters. It does not. The phrase 'personalizado simples' hints at a lightweight command, but it never maps to groupJid, trigger, response, name, enabled, or preview. While the parameter names are somewhat self-explanatory, the description itself adds essentially no parameter-level meaning.

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

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

The description states a clear action and resource: 'Cria ou atualiza comando personalizado simples' (Creates or updates a simple custom command). It conveys the core purpose of the tool. However, it does not distinguish this tool from the sibling commands_custom_update, since 'updates' already overlaps with that tool's responsibility.

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 about when to use this tool versus commands_custom_update, commands_custom_toggle, commands_custom_delete, or commands_custom_preview. The description does not explain whether this tool is an upsert, nor does it state the conditions that would lead an agent to choose 'create' over 'update'. This leaves usage largely to inference.

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 annotations already declare destructiveHint=true, and the description merely repeats the removal intent without adding consequences, irreversibility, permission requirements, or confirmation behavior. The presence of confirmation_id in the schema hints at a confirmation flow, but the description does not disclose it. No contradiction exists, but the description adds little 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 short and front-loaded with the main action, but the second sentence is ambiguous and potentially misleading about when to use the tool. It is compact but does not earn its place because it confuses rather than clarifies.

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 destructive tool with 9 parameters, no required fields, and an output schema, the description is far too thin. It fails to explain how to identify what is being deleted, what the confirmation_id is for, or how this tool differs from related custom-command tools. The agent does not have enough information to invoke it reliably.

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

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

The schema has 9 parameters with 0% description coverage, and the description names none of them. An agent cannot determine which field identifies the target custom command, what 'mode' does, or how 'confirmation_id' fits into the deletion flow. The description provides no parameter-level guidance whatsoever.

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 a clear action and resource: 'remover custom no painel 9bot' aligns with deleting a custom command. However, 'custom' is jargon, and there is no explicit contrast with sibling tools like commands_custom_update or commands_custom_toggle, so some differentiation is left to inference.

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 guidance 'Use quando o usuario pedir comandos' is too broad and does not specify that the user is asking to remove/delete a command. It could mislead an agent into selecting this tool when the user merely asks about commands, for which commands_custom_list or commands_custom_get would be more appropriate. No exclusions or explicit alternatives are provided.

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, covering the safety profile. The description adds little behavioral detail beyond 'detect' and the usage trigger; it does not explain what happens during detection or what kind of results are produced. This is adequate but not highly transparent.

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, front-loaded with the core purpose, and contains no filler. The second sentence adds a useful usage condition. Minor grammatical awkwardness in the Portuguese text prevents a perfect score, but it is concise and scannable.

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 seven optional parameters with no descriptions and no guidance in the tool description, the definition is incomplete. An agent can understand the general intent but cannot confidently know which parameters to pass, how they relate to detection, or what inputs are expected. The output schema exists, so return-value documentation is not the bottleneck, but invocation semantics are still underspecified.

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 all seven parameters are undocumented in the schema. The description does not compensate: it mentions none of the parameters (name, command, enabled, trigger, commands, groupJid, response) and gives no guidance on how or whether they should be supplied. This is a serious gap.

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

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

The description states a specific action and resource: detecting custom API fields in the 9bot panel. It is not a tautology and differentiates itself from sibling command tools by focusing on 'api fields custom'. However, the phrase 'detect api fields custom' remains somewhat jargon-heavy and does not fully explain what detection means operationally.

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

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

The description gives a clear usage context: use when the user asks for commands, even with incomplete terms or synonyms. This is explicit enough to route an agent toward this tool. It does not mention when not to use it or name alternative tools, so it stops short of a 5.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the read-only safety profile is covered by structured data. The description adds the 9bot panel context and hints at fuzzy matching ('termos incompletos ou sinonimos'), which goes beyond the schema, but it does not disclose what happens on partial matches, how multiple parameters combine, or any response behavior — the output schema covers the latter.

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 short sentences with no filler: the purpose is front-loaded first, followed by a routing instruction. Every clause 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 an output schema covering returns and annotations covering safety, the request side is under-specified: 7 undocumented optional parameters with additionalProperties:true mean an agent cannot determine what to pass, whether parameters combine, or which field supports the promised synonym/incomplete-term search. For a tool of this open-ended complexity, the description is too thin to be reliably invoked.

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% across 7 optional parameters, so the description carries the full burden of explaining parameter meaning — and it does not. The mention of 'termos incompletos ou sinonimos' weakly implies name/command accept partial or synonymous values, but none of the parameters (groupJid, trigger, enabled, response, commands) are clarified, and the description never indicates which parameter is the primary lookup key.

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 a specific verb ('consultar' — query) and resource ('detalhes de custom no painel 9bot'), clearly identifying a read operation on custom command details. It is clear about the action and object, though it does not explicitly mark the boundary against siblings like commands_custom_list or commands_custom_preview, so differentiation relies partly on the tool name.

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

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

The second sentence gives an explicit when-to-use rule: whenever the user asks about commands, even with incomplete terms or synonyms. It provides clear routing context but names no alternatives or exclusion cases (e.g., when the user wants to list all customs or toggle one), leaving some ambiguity with sibling custom-command tools.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false, and the description is consistent with that read-only profile. It adds no further behavioral context such as pagination, sorting, or behavior with an invalid groupJid, but for a simple read-only list this is acceptable.

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

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

One short sentence with no filler or repetition. The key action, resource, and scope are front-loaded, and every word contributes to meaning.

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

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

For a single-parameter read-only list operation, the description plus schema plus annotations cover what is needed: what the tool does, the required groupJid, and the safety profile. An output schema exists, so return-value details do not need to be described.

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

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

The input schema provides 100% parameter coverage, including a clear description of groupJid as the WhatsApp group JID. The tool description does not add semantics beyond the schema, so the baseline score of 3 applies.

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 a specific action ('Lista' = lists), a precise resource ('comandos personalizados' = custom commands), and a scope ('de um grupo' = of a group). It distinguishes from sibling commands_custom_get by using the list verb, making selection straightforward.

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

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

The usage is implied: use it when you need to list custom commands for a group. However, it does not explicitly contrast with commands_custom_get or other custom-command siblings, so an agent gets no explicit when-to-use/alternative guidance.

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