DataCrazy

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

Beyond the annotations (idempotentHint: true, readOnlyHint: false, destructiveHint: false), the description adds behavioral context: using the config header gives a permanent non-expiring connection, while passing a token gives a session-only login. It also clarifies that calling with no args returns a login link. This goes beyond structured data, though it doesn't cover edge cases like invalid tokens.

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

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

The description is a single paragraph but well-structured, leading with the action then presenting two clear options. It's slightly verbose but each sentence adds value, with no repetition. It could be more concise by trimming redundancy, but it remains focused.

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

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

The tool is simple (one optional parameter, no output schema), and the description covers all necessary information: the authentication flow, the two modes (config vs session), and the case of no arguments. It's complete for an agent to understand how and when to invoke it, given the minimal schema and annotations.

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

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

Schema has 0% description coverage for the single 'token' parameter. The description compensates fully by explaining the token is a JWT to be pasted after the user logs in, and that passing it provides session authentication. It also explains the alternative of using config header and calling with no args to get the link, which fully clarifies parameter usage.

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

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

The description clearly states the tool's purpose: to authenticate the MCP server for IDE agents by logging in via browser and obtaining an access token. It distinguishes itself from sibling tools by being the only authentication tool, and uses specific verbs ('log in', 'copy', 'add', 'paste') tied to the auth resource.

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

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

The description provides explicit usage options: either add the token to the server config for a permanent connection, or paste it as a parameter for session-only login. It also explains when to call with no args (to get the link). However, it does not explicitly state when not to use this tool or mention any alternatives, though none exist among the siblings.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds behavioral specifics about return values in different states (authenticated and pending arrays, connect_url presence), which complements the annotations without contradiction.

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

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

The description is two sentences, concise, and front-loaded with the core purpose. Every sentence adds value: the first states what it returns, the second details conditional behaviors.

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 no parameters, no output schema, and clear annotations, the description is complete for an agent to understand what it does and what it returns. The conditional logic is clearly explained.

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

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

The tool has zero parameters, and schema coverage is 100% (empty schema). The description explains the output semantics, which is more relevant than parameter details. With no parameters, the baseline of 4 is appropriate.

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

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

The description clearly states the tool returns connection status and URLs, and specifies the behavior in different scenarios (all providers connected vs. missing credentials). It distinguishes from siblings like 'authenticate' and other CRUD tools.

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

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

The description implies usage for checking connection status, but does not explicitly state when to use it versus other tools like 'authenticate' or list tools. However, given the clear purpose and sibling context, the intended usage is apparent.

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=false, and the description adds '[write, altera dados]' which is consistent but redundant. It reveals the HTTP method but no additional behavioral traits like auth requirements, side effects, or limitations.

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

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

The description is extremely short and front-loaded, containing the essential action and endpoint. No fluff, but it is so minimal that it borders on under-specification rather than effective conciseness.

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

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

For a create operation with two undocumented parameters and no output schema, the description provides almost no context about request format, expected response, or prerequisites. It is inadequate for an agent 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 0%, and the description provides no explanation of the 'body' or 'account' parameters. The agent is left entirely without semantic information about how to construct the 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 clearly states the tool creates an activity, with the HTTP method and endpoint (POST /api/v1/activities). This distinguishes it from sibling tools like get, list, patch, and delete.

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

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

No guidance is provided on when to use this tool versus alternatives such as patching or deleting activities. The verb 'create' implies usage for new records, but there are no explicit exclusions or context.

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

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

Annotations include readOnlyHint=false and destructiveHint=false, but the description says '[write, altera dados]' and 'DELETE', which implies deletion. However, destructiveHint=false contradicts the notion that deletion is destructive. The description adds the bulk execution note but does not clarify side effects, irreversibility, or authorization. The contradiction with destructiveHint is notable.

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 includes the endpoint and bulk support. It is front-loaded with the core purpose. However, the note '[write, altera dados]' is redundant given the annotations and the DELETE verb, so a slight waste. But overall, 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?

This is a simple delete tool with no output schema, but the description does not cover critical aspects like error handling, idempotency, or the effect of deletion. Given the annotations are sparse (no idempotent hint), the description should provide more context but doesn't. It is minimally adequate for a simple tool but has gaps.

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

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

Schema description coverage is 0%, so the description should compensate. The description only mentions 'ids' for batched execution, but does not explain 'id', 'body', or 'account'. Even the id parameter is unclear in terms of format or required context. With 4 parameters and 0% coverage, this is a significant gap.

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

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

The description clearly states the tool's verb ('Excluir atividade'), the resource (activity), and the HTTP DELETE endpoint. It also mentions bulk support. However, it doesn't explicitly differentiate from sibling tools like datacrazy_activities_patch or datacrazy_activities_create, though the DELETE verb inherently distinguishes it.

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

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

The description does not explain when to use this tool versus alternatives. It only mentions the endpoint and bulk support. There is no guidance on prerequisites (e.g., authentication) or scenarios where deletion is appropriate, which is insufficient for an agent to decide between this and other activity 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, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds the bulk support behavior (accepting 'ids') and notes the endpoint, which is additional context. However, it does not disclose details about error handling, return format, or pagination, so transparency remains moderate.

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

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

The description is extremely concise—two short sentences. It front-loads the main purpose (fetch by ID) and adds bulk support as a secondary note. No wasted words, easy to scan.

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 four parameters and no output schema, the description should clarify what each parameter does and what the response looks like. It covers 'id' and 'ids' implicitly, but leaves 'query' and 'account' unexplained. Given the simplicity of a GET operation, it might suffice, but gaps in parameter understanding and response format make it only partially complete.

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

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

Schema description coverage is 0%, so the description carries the burden. It implicitly explains 'id' (by ID) and 'ids' (bulk support), which are the core parameters. However, 'query' and 'account' are not mentioned at all, leaving them unexplained. The description partially compensates but does not fully cover all parameters.

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

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

The description clearly states the tool retrieves an activity by ID, referencing the exact endpoint (GET /api/v1/activities/{id}). It also mentions bulk support via 'ids', which distinguishes it from other activity tools like datacrazy_activities_list or datacrazy_activities_patch.

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

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

The description does not provide any guidance on when to use this tool versus alternatives. It does not mention that this should be used when you have a specific ID or ID list, nor does it differentiate from datacrazy_activities_list or other get operations for other resources. There is no explicit when/when-not 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, idempotentHint, and destructiveHint, and the description adds no behavioral context beyond restating the GET HTTP verb. It does not disclose filtering behavior, pagination, authentication needs, or what activity data is returned.

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 containing the action and endpoint, with no wasted words. It is concise and easy to parse, though it is so sparse that it sacrifices useful 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 list tool with no output schema and undocumented parameters, this description is incomplete. The agent cannot infer parameter semantics, result shape, or when this tool is more appropriate than the many sibling list/create/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?

The input schema has two optional parameters (query and account) with 0% description coverage, and the description does not explain either parameter. The agent is left with no semantic information about what these parameters do, their expected formats, or how they affect the 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 clearly states 'Buscar atividades' (search activities) and includes the GET endpoint, making the action and resource explicit. It is distinguishable from sibling tools like datacrazy_activities_get, create, patch, and delete since this is the list-style operation, though it does not clarify whether it returns all activities or supports scoped search.

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

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

The description provides no guidance on when to use this tool versus alternatives such as datacrazy_activities_get or datacrazy_leads_activities_list. It does not mention exclusions, preferred contexts, or how the optional query/account parameters should influence selection.

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

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

Annotations already indicate readOnlyHint=false, so the write nature is known. The description adds the bulk support capability and repeats the write intent with '[write, altera dados]'. However, it does not disclose partial update semantics, authentication needs, or return behavior, so it provides only modest additional context beyond annotations.

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

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

The description is two concise sentences, front-loaded with the main action and endpoint, followed by a brief note on bulk support. It contains no filler and every phrase adds value, making it highly efficient.

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

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

For a tool with four parameters, no parameter descriptions in the schema, and no output schema, the description is notably incomplete. It omits essential details about the 'body' parameter (what fields can be updated and their format), the 'account' parameter, and what the response contains. This leaves an agent unable to reliably construct a correct request.

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

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

With schema description coverage at 0%, the description partially compensates by explaining the 'id' parameter via the endpoint path and introducing the 'ids' parameter for bulk execution. However, it leaves 'body' and 'account' unexplained, which are crucial for constructing a valid update request, so the semantic guidance is incomplete.

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

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

The description clearly states 'Atualizar atividade' (Update activity) and specifies the PATCH endpoint, making it obvious this tool updates an existing activity. It distinguishes itself from siblings like datacrazy_activities_create, delete, get, and list by using the verb 'atualizar' and the HTTP method.

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

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

The description implies usage for updating activities via the verb 'atualizar' and the HTTP PATCH method, but it does not explicitly contrast with alternatives or state when not to use it. It mentions bulk support, which provides a specific usage scenario, but lacks explicit exclusions or comparisons.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds the bulk support trait (accepts ids for batched execution), which is useful beyond annotations. However, it doesn't explain behavior like error handling, return format, or pagination if multiple IDs are used. Given annotations cover safety, this is adequate 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 extremely concise: two sentences, with the endpoint and a clear bulk note. Every word adds value: it identifies the resource, the HTTP method, and the bulk capability. No fluff.

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

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

For a simple get-by-ID tool with annotations covering safety and idempotency, the description covers the core function and bulk support. However, it lacks an output schema (so no return details are provided), and with 4 parameters but only 2 documented implicitly, an agent might not know how to use 'query' and 'account'. The bulk feature is mentioned but not detailed (e.g., limits, response shape). Overall, it's adequate but incomplete for full usage.

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

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

Schema description coverage is 0%, and there are 4 parameters, one required. The description only mentions 'id' (singular) and 'ids' (batched) but doesn't explain 'query' or 'account' parameters at all. Since the schema lacks descriptions, the description fails to compensate for the coverage gap: it leaves two parameters undocumented, which could confuse an agent about their purpose.

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

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

The description clearly states 'Buscar atendente por ID (CRM)' with the HTTP endpoint, which is a specific verb (buscar/get) and resource (attendant). It distinguishes from 'datacrazy_attendants_crm_list' and 'datacrazy_attendants_multi_get' by focusing on single ID retrieval, and mentions bulk support via ids. Sibling differentiation is partially clear because 'multi_get' likely offers a similar bulk capability, but the description doesn't explicitly contrast with it.

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

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

The description implies usage: fetch an attendant by ID, with bulk support for multiple IDs. However, it doesn't explicitly state when to use this tool versus 'datacrazy_attendants_multi_get' or 'datacrazy_attendants_crm_list'. No exclusions or alternative recommendations are given. The bulk support note hints at when multiple IDs are needed, but the distinction with the multi_get sibling is not clarified.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds only the HTTP endpoint and does not disclose any additional behavioral aspects such as return format, pagination, or whether it returns a full list or partial results.

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

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

The description is a single sentence with no wasted words. It briefly states the action and includes the endpoint, which is useful. However, it is so terse that it borders on under-specification, though for conciseness alone 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 two optional parameters and no output schema, the description should at least mention what the parameters do and what the response looks like. It provides none of this, leaving significant gaps in understanding. The tool is simple but the description is inadequate for effective use.

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

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

Schema description coverage is 0%, and the description does not explain the parameters 'query' and 'account'. An agent has no idea what these parameters mean or how to use them, so the description completely fails to add meaning beyond the bare parameter names.

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 'Buscar atendentes (CRM)' essentially restates the tool name 'datacrazy_attendants_crm_list' (a list of CRM attendants) with a Portuguese verb, providing little new information. It does add the HTTP endpoint, but it does not differentiate this from sibling tools like datacrazy_attendants_crm_get or datacrazy_attendants_multi_list, so it is clear but only minimally distinguishable.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of filtering criteria, or how this differs from the 'get' or 'multi' variants. An agent would need to infer usage from the name alone.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is covered. Description adds the bulk execution behavior, though it doesn't disclose any other quirks like pagination or limits. 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 sentences, front-loaded with the purpose and endpoint, no wasted words. Perfectly sized.

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?

Tool is simple with no output schema, but annotations cover safety. However, description fails to explain the 'query' and 'account' parameters, and does not describe the response format. For a tool with 0% schema coverage, more is needed.

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

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

Schema description coverage is 0%, so description must compensate. It mentions 'id' and 'ids' but not 'query' or 'account'. No explanation of what these parameters do beyond the schema names. This is a significant gap for a 4-parameter 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?

Purpose is clearly stated: 'Buscar atendente por ID (multiatendimento)' with HTTP endpoint, and it mentions bulk support via 'ids' parameter. It distinguishes from sibling datacrazy_attendants_crm_get by the 'multi' qualifier, though it doesn't explicitly contrast with the sibling.

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

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

The description implies usage for fetching attendants by ID, but does not provide explicit guidance on when to use this tool versus alternatives like datacrazy_attendants_multi_list or datacrazy_attendants_crm_get. Bulk support is mentioned but no conditions are given.

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

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

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds the endpoint and the term 'multiattendance', but it does not disclose additional behavioral aspects such as pagination, result size limits, or authentication requirements. Since annotations cover safety, 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?

The description is a single concise sentence that includes the endpoint, which is useful. However, it lacks additional context that would be expected, but it is not verbose or wasteful.

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

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

With 0% schema coverage and no param explanations, nor behavior details beyond annotations, the description is minimal. The tool has two parameters and no output schema, so more explanation is needed to make it usable, especially since 'multi' is ambiguous.

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

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

Schema description coverage is 0%, meaning the description must explain the parameters 'query' and 'account', but it does not. No additional meaning is provided beyond the schema's raw type declarations. This is a significant gap.

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

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

The description states 'Buscar atendentes (multiatendimento)' (Search attendants (multi-service)) and identifies the HTTP endpoint, but does not clarify what 'multi' means or how it differs from other attendant list tools like datacrazy_attendants_crm_list. The purpose is partially clear but lacks specificity to distinguish it from siblings.

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

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

No context is provided about when to use this tool versus alternatives. It mentions the endpoint but not any conditions or use cases. The description does not guide the agent on choosing between this and other attendant-related 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=false and destructiveHint=false, but the description adds only '[write, altera dados]' which aligns with those annotations. However, it does not explain what 'lose' means in terms of business lifecycle, whether any data is historically preserved, or the effect on related entities, which is a gap given the non-idempotent and non-readOnly nature.

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

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

The description is extremely concise, only one sentence plus the endpoint and tags. It is front-loaded with the primary purpose, though it sacrifices necessary detail for brevity.

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

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

Given the lack of output schema, no annotations for semantics, and two unclear parameters, the description is not complete enough. It does not explain the request body format, required fields, possible errors, or what happens on success, so an agent would struggle 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 0% and there are two parameters ('body' and 'account') with no descriptions. The description does not explain what 'body' should contain (e.g., business ID, loss reason) or how 'account' is used, so it offers no added value beyond the schema property names.

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

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

The description states the tool is for losing businesses (POST /api/v1/businesses/actions/lose) and indicates it alters data, which is clear enough for the action. However, it does not explicitly differentiate from sibling tools like datacrazy_businesses_actions_win_create or datacrazy_businesses_actions_restore_create, beyond the verb in 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?

There is no guidance on when to use this tool versus alternatives. It only says 'lose businesses' with an endpoint, which implies usage but does not mention that win/restore/move are for other status changes, nor any prerequisites like needing an existing business or account.

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

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

The description adds '[write, altera dados]' which aligns with the annotation readOnlyHint=false, but it does not provide additional behavioral details such as side effects, reversibility, or requirements. Since annotations already cover the write nature, the extra context is minimal and does not contradict them.

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

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

The description is a single concise sentence with the action and an HTTP reference. It wastes no words, though it could be slightly more structured with parameter hints. Overall, it is appropriately sized.

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 action with two undocumented parameters and no output schema, the description is too sparse. It lacks details about expected inputs, what 'move' entails, or any special conditions. The description does not adequately prepare the agent 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?

The two parameters (body and account) are not explained at all. Schema description coverage is 0%, so the description should compensate, but it only mentions the endpoint without elaborating on what body or account should contain. This is a critical gap for a tool with no default parameter info.

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

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

The description clearly states the action: 'Mover negócios' (Move businesses) and includes the HTTP endpoint POST /api/v1/businesses/actions/move. This is specific and distinct from sibling tools like lose/restore/win, making the purpose unambiguous.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention context, prerequisites, or alternatives, leaving the agent to infer usage from the name and endpoint alone.

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

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

Annotations indicate readOnlyHint=false, so a write operation is expected. The description adds '[write, altera dados]' which repeats this hint without additional insight into side effects, required permissions, or outcome. It does not contradict annotations, but adds minimal 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 extremely short (one line), which is concise, but it lacks substance. It front-loads the endpoint and a write flag, but under-specification negates the benefit of brevity.

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

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

Given the tool's complexity (write operation, 2 undocumented parameters, no output schema), the description is grossly incomplete. It fails to explain request body structure, account usage, or expected behavior, making it inadequate for reliable 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 coverage is 0% and the description provides no meaning for the two parameters ('body' and 'account'). With no parameter documentation in either schema or description, the agent cannot correctly construct requests.

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: 'Restaurar negócios' (restore businesses) and provides the endpoint. It distinguishes from sibling actions like lose, move, and win by using a specific verb, though it doesn't elaborate on what 'restore' entails.

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 other business action tools (e.g., win, lose, move). The description merely names the action without explaining the context or prerequisites, leaving the agent to infer usage 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 indicate readOnlyHint: false and destructiveHint: false. The description adds '[write, altera dados]', which clarifies the operation writes data. While this aligns with annotations and reinforces the non-read-only nature, it does not disclose further behavioral details like idempotency caveats, permissions, or side effects, missing an opportunity to add more value.

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

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

The description is extremely concise, with a single front-loaded sentence containing the action, endpoint, and a write indicator. While it wastes no words, the '[write, altera dados]' tag is partially redundant with annotations, and the saved space could have been better used for parameter clarifications.

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 mutation action with two undocumented parameters and no output schema, the description is too sparse. It fails to explain what the body should contain, what 'winning' a business semantically involves, or any required account context, making 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 0% and the description provides zero information about the two string parameters ('body' and 'account'). The description neither explains the expected format, purpose, nor relationship to the body/account fields, leaving the agent with no guidance beyond param names.

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 'Ganhar negócios' (Win businesses) uses a specific verb and resource, clearly distinguishing it from sibling actions like 'lose' (datacrazy_businesses_actions_lose_create) and 'move'. Including the full HTTP endpoint (POST /api/v1/businesses/actions/win) removes ambiguity.

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

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

The description implies when to use this tool (to mark a business as won), and the sibling list provides natural alternatives (lose/move/restore). However, it does not explicitly state when to use it over alternatives or provide any exclusions or prerequisites, so it's at the 'implied usage' level.

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=false, and the description adds '[write, altera dados]' to explicitly state the mutation behavior. However, it provides no additional context about side effects, permissions, or response handling, so it adds only marginal value beyond annotations.

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

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

The description is exceptionally concise—a single sentence plus a tag—and includes the essential endpoint. Every token serves a purpose, with no waste or 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?

The tool has two parameters with no schema explanations, no output schema, and no mention of prerequisites like authentication (sibling 'authenticate' exists). The description is too sparse to fully support agent invocation, especially given the ambiguous 'body' parameter.

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

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

Schema description coverage is 0%, and the description gives no explanation of the 'body' or 'account' parameters. An agent cannot infer what the body should contain or how account is used, making successful invocation unlikely.

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 'Criar negócio' clearly states a create action on the business resource, reinforced by the explicit POST /api/v1/businesses endpoint. The verb 'Criar' distinguishes it from sibling tools like patch, delete, get, and list.

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

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

The usage is implied by the create verb and endpoint, but there is no explicit guidance on when to use this tool versus alternatives, nor any mention of prerequisites or exclusions. It's adequate but lacks explicit 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?

Annotation contradiction: the description says 'Excluir negócio' and uses HTTP DELETE, implying destructive behavior, while annotations declare destructiveHint:false. No soft-delete or reversible-delete qualification is provided to reconcile this mismatch. The '[write, altera dados]' note matches readOnlyHint:false but does not resolve the destructive conflict.

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 tightly written and front-loaded: it names the operation, gives the HTTP endpoint, flags it as a write operation, and notes bulk support. There is no filler or redundant prose.

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 four parameters, no output schema, and no schema-level descriptions, this definition is incomplete. It does not explain 'body' or 'account', mention return/error behavior, or clarify whether deletion is soft or destructive. The destructiveHint contradiction further undermines completeness.

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

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

The endpoint clarifies the 'id' parameter and the bulk note gives meaning to 'ids', but 'body' and 'account' remain unexplained. With schema description coverage at 0%, the description needed to compensate for all parameters but 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 clearly states the operation ('Excluir negócio') and the exact endpoint (DELETE /api/v1/businesses/{id}), making it unambiguous that this tool deletes a business. It distinguishes itself from sibling get/list/patch/create tools and adds bulk support context.

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

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

The description provides a clear action and a bulk-use note ('accepts ids for batched execution'), implying when to use it. However, it does not explicitly state alternatives, prerequisites, or when not to use it, leaving usage guidance somewhat implicit.

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

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

Annotations already establish the tool as read-only, idempotent, and non-destructive. The description adds that this is a GET endpoint and supports batched ids, but it does not mention authentication needs, rate limits, response shape, or any other execution behavior.

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

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

Two short lines contain the required entity, the HTTP endpoint, and the bulk capability. No filler, repetition, or unnecessary details.

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

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

For a read-only tool with strong annotations, the description is decent but still incomplete: there is no output schema, and several parameters are not described. An agent would need to infer the roles of 'query' and 'account' from the raw property names.

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

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

The description explains the core 'id' semantic and indicates 'ids' is for batch execution, which adds value over bare property names. However, schema description coverage is 0% and the 'query' and 'account' parameters remain unexplained, leaving meaningful gaps.

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

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

Clearly states 'Buscar negócio por ID' (find business by ID) and gives the REST endpoint. The bulk support differentiates this from a plain single-get and from sibling list/patch/create tools.

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

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

The description implies usage when one business ID is available, but it does not explicitly say when to use this instead of datacrazy_businesses_list or when to prefer batch ids over a single id. There is no when/when-not 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, idempotentHint, and destructiveHint, so the description adds no extra behavioral context (e.g., pagination, result format, or access restrictions). It simply repeats the obvious search intent without enrichment.

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 (one sentence), which is good, but it lacks essential details that would make it useful. It is front-loaded with the action, but the brevity borders on under-specification rather than effective conciseness.

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

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

Given the absence of an output schema and the lack of parameter descriptions, the description is incomplete. It provides no information about return values, pagination, or how to use the query/account parameters, making it inadequate for a list operation.

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

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

With 0% schema description coverage, the description must explain the parameters, but it does not mention 'query' or 'account' at all. The agent has no semantic information about these inputs beyond their names.

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

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

The description clearly states it searches businesses and provides the endpoint, indicating a list/search operation. It is distinguishable from create/delete/get tools, though not explicitly contrasted with datacrazy_businesses_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 given on when to use this tool versus alternatives like datacrazy_businesses_get or datacrazy_leads_businesses_list. The context of query/account filters is not explained, leaving usage ambiguous.

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 a write operation, but the description reinforces this with '[write, altera dados]' and adds bulk execution behavior. It does not disclose partial-failure semantics or response details, but the annotation coverage lowers the burden 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 very short, front-loaded with the core purpose, and every sentence adds value. The bulk-support note is a meaningful addition without unnecessary verbosity.

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

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

Despite simple annotations and clear purpose, the description is incomplete for a PATCH tool with 4 parameters and no output schema. It does not explain how 'body' should be structured, how 'account' is used, or how bulk execution with 'ids' behaves. More operational detail is needed.

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

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

Schema description coverage is 0%, so the description must compensate for the 4 parameters. It only explains 'ids' (batched execution) and leaves 'id', 'body', and 'account' undocumented. The body parameter is critical for an update tool and is not explained at all.

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

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

The description clearly states 'Atualizar negócio' (update business) and gives the exact endpoint PATCH /api/v1/businesses/{id}, making the verb and resource explicit. It also distinguishes itself from sibling create/delete/get/list tools for businesses.

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 update purpose is implied and the bulk support line provides some usage context, but there is no explicit guidance about when to use this tool versus create/delete or other business 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?

The description adds '[write, altera dados]' and the POST method, making the mutating nature of the operation clear beyond the annotation readOnlyHint=false. However, it does not disclose additional behavioral details such as safety, authentication requirements, or side effects beyond writing 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 a single concise sentence that leads with the core action, includes the endpoint, and adds a short behavioral flag. There is no filler or repeated schema information.

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

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

Given no output schema, no parameter details, and minimal behavioral context, this description is not sufficiently complete for an agent to confidently invoke the tool. The account and body parameters remain ambiguous, and no expected response or side-effect information is supplied.

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 two parameters, body and account, but schema description coverage is 0% and the description provides no explanation of their meaning, format, or required content. The agent cannot tell what account means or what shape body should take.

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 'Criar motivo de perda' (create loss reason) along with the exact POST endpoint, making the verb and resource explicit. It also differentiates itself from sibling tools like business_loss_reasons_get, _list, _update, and _delete by identifying a distinct create action.

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

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

The description provides no explicit when-to-use or when-not-to-use guidance. It does not mention alternatives such as updating or deleting loss reasons, nor does it distinguish this from related create actions like datacrazy_businesses_actions_lose_create.

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=false and destructiveHint=false, but the description explicitly says '[write, altera dados]' which aligns. However, it doesn't disclose consequences like irreversible deletion, cascading effects, or auth requirements beyond the brief '[write]' tag. There is no contradiction, but little added behavioral context beyond what annotations imply.

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

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

Description is brief and front-loaded with the action, no fluff. However, it dedicates a line to bulk support which is useful, but could note more about parameters. Still, it's concise and not padded.

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 4 parameters, no output schema, and low annotation richness, the description is incomplete. It lacks parameter details, usage scenarios, and any mention of return values or error handling. For a delete operation, it's minimal but misses critical operational 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 coverage is 0%, so description must explain parameters. It only mentions 'ids' for bulk support but doesn't define 'id', 'ids' relationship, 'body', or 'account'. The description fails to compensate for the lack of schema descriptions, leaving most 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 clearly states the tool deletes business loss reasons via DELETE endpoint, with the resource and HTTP method. It distinguishes from siblings (create, get, list, update) by explicitly being the delete operation. The '[write, altera dados]' notation clarifies it mutates data.

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

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

No guidance on when to use this vs alternatives. It doesn't explain prerequisites (e.g., need an existing loss reason) or contrast with update/disable. Only bulk support is mentioned, which is a feature, not usage context.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the description doesn't need to repeat safety. It adds behavioral context: bulk support for batched execution, which is useful. However, it doesn't disclose any nuances like pagination, error behavior, or required auth context. With annotations covering safety, a 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?

The description is two sentences with no filler. It front-loads the core purpose and adds the bulk note concisely. Every word earns its place.

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

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

Given the tool has 4 parameters, no output schema, and simple GET semantics, the description covers the primary functionality and bulk support. However, the unexplained 'query' and 'account' parameters and lack of output format info leave gaps for an agent, but for a simple get operation with annotations, it's acceptable. Overall, minimally adequate.

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

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

Schema description coverage is 0%: no parameter descriptions in the schema. The description mentions 'ids' for bulk but does not explain the exact format of 'id', 'ids', 'query', or 'account'. The 'query' and 'account' parameters are completely unexplained. The description adds minimal value beyond the schema property names, failing to compensate for 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 clearly states the tool fetches business loss reasons by ID via GET endpoint, distinguishing it from list/create/update/delete siblings. The purpose is specific: 'Buscar motivos de perda por ID' (fetch loss reasons by ID). It could be more explicit about the resource type but 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?

The description states the primary use case (fetch by ID) and mentions bulk support via 'ids', which implies when to use ids instead of id. However, it does not explicitly say when NOT to use this tool vs alternatives like list (for fetching all) or the sibling get tools for other resources. No direct alternative 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, covering the safety profile. The description adds the HTTP GET method and endpoint path, reinforcing non-mutating behavior, but it does not disclose response format, pagination, or account scoping.

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

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

The description is a single front-loaded sentence with no wasted words. However, it is extremely sparse and could include useful parameter or behavior details without becoming verbose.

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

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

For a simple list tool with no output schema, the description omits key functional details such as how 'query' and 'account' filter results, whether the response is paginated, and what fields are returned. Annotations cover safety but not operational completeness.

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

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

Schema description coverage is 0% and the description does not explain the 'query' or 'account' parameters. The agent cannot determine their meaning or usage from the description, only from the parameter names.

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 'Buscar' (search/list) and a clear resource 'motivos de perda' (loss reasons), reinforced by the GET endpoint indicating a collection read. It implicitly distinguishes from sibling get/update/delete tools, though it does not explicitly state the scope or filtering semantics.

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 alternatives like datacrazy_business_loss_reasons_get for a single item or create/update for modifications. It only states the operation without context, prerequisites, or exclusions.

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

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

Annotations already indicate it's a write operation (readOnlyHint=false) and not destructive (destructiveHint=false). The description adds that it alters data and supports batch execution, which is extra behavioral context, but it doesn't disclose other side effects or response details.

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 two sentences: the first states the primary purpose, the second adds bulk support. No fluff or redundant information.

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

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

The tool has 4 parameters and no output schema, yet the description provides minimal context. It doesn't explain the body format, the meaning of 'account', or how a single update differs from bulk. Significant ambiguity remains for agents.

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 only mentions the 'ids' parameter for bulk support, leaving 'id', 'body', and 'account' undocumented. This is insufficient for a 4-parameter 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 it updates a loss reason ('Atualizar motivo de perda') and specifies the HTTP PUT endpoint, distinguishing it from sibling create/delete/get/list tools. It also mentions bulk support, adding a unique capability.

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

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

The description implies usage for updating existing loss reasons and explicitly notes bulk support for batched execution, guiding when to use it. It doesn't explicitly exclude alternatives but the context is clear enough.

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

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

The description adds '[write, altera dados]' and the HTTP method, explicitly signaling a state-changing operation, which is useful beyond the annotations' readOnlyHint=false. It also discloses batch execution behavior via ids. It does not detail side effects or idempotency, but the annotations already cover idempotentHint=false.

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

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

Two sentences with the endpoint and write semantics front-loaded, followed by a useful bulk-support note. No filler or 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?

For a simple finish action with annotations present, the description covers endpoint, write semantics, and batch capability. However, it leaves the body/account parameters undocumented and gives no guidance on response or prerequisites, so it is only minimally complete.

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

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

Schema description coverage is 0%, so the description should explain the parameters, but it only clarifies that 'ids' enables batched execution. The 'body' and 'account' parameters remain completely unexplained, and 'id' is only implied by the endpoint.

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

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

The description clearly identifies the action as 'Finalizar atendimento' (finish service) and gives the exact endpoint POST /api/v1/conversations/{id}/finish, making the resource and operation unambiguous. It distinguishes this from sibling conversation tools like list and message creation by naming the finish action.

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 for closing/finishing a conversation and notes bulk support, but it does not explicitly state when to prefer this over alternatives or provide exclusion conditions. The usage context is inferable from the endpoint but not fully specified.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description's mention of GET aligns with these annotations and does not contradict them. However, it adds no additional behavioral context such as pagination, filtering limits, or whether authentication is required beyond what the annotations imply. Given the annotation coverage, this is adequate but not enriched.

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

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

The description is extremely brief (a single phrase), which is concise, but it is under-specified to the point of being almost tautological with the tool name. It lacks structure or additional detail that would earn its place. Effective conciseness should still convey essential information; here it provides only 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?

With no output schema, no parameter documentation, and a minimal description, the tool is incomplete. The description does not explain what the response contains (e.g., list of conversations, fields, pagination) or how the parameters affect results. Given the simplicity of the tool (two optional string params), a robust description could easily cover these aspects, but it does not.

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

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

Schema description coverage is 0%, and the description provides no explanation of the 'query' or 'account' parameters. The schema only gives types (both strings) but not their semantics. The description does not compensate for this gap, leaving the agent to guess what these parameters filters do (e.g., text search, account ID). This is a critical deficiency for parameter usability.

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 'Buscar conversas' clearly indicates the tool searches/lists conversations, and the HTTP method GET is specified. This distinguishes it from sibling tools like datacrazy_conversations_finish_create (which implies a write action) and datacrazy_conversations_messages_list (which focuses on messages within conversations). However, the scope (e.g., all conversations vs. filtered) is implicit, so it is specific but not fully explicit.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention any context, prerequisites, or exclusions, and it does not differentiate it from the many other list operations in the sibling set. An agent would need external knowledge to decide whether this is the appropriate tool for a given query.

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=false, and the description additionally adds '[write, altera dados]' to reinforce the writing nature. It also surfaces the POST method and the bulk batch behavior, which adds the context beyond the annotations. No contradiction exists, and it is richer than the annotation-only safety profile.

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 has a front-loaded core sentence with the verb, resource, and endpoint, followed by the write tag and a concise bulk note. Every sentence earns its place. Slight credit loss for not mentioning the missing parameter semantics, but the structure is optimal for what is included.

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 write tool with no output schema and 4 parameters, the description covers only ID selection and bulk mode but omits the essence of message content (`body`) and account scope (`account`). Without those, an agent cannot craft a correct request, especially with 0% schema coverage. The overall behavior is incomplete for reliable invocation.

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

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

Schema description coverage is 0%, so the description must compensate for parameter sense. The description only addresses `id`/`ids` (via 'Bulk' and the endpoint), but leaves `body` and `account` entirely meaningless. An agent cannot reason about what `body` should contain (message text) or what `account` refers to (tenant context).

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

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

The description uses a specific verb and resource: 'Enviar mensagem para uma conversa' (send a message to a conversation), and reinforces it with the exact POST endpoint. It clearly distinguishes from sibling tools like datacrazy_conversations_messages_list, which is the read counterpart.

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 context is implied by the name (create vs list) and the endpoint. The 'Bulk support' note gives a clear hint for when to use the `ids` batch capability, but the description does not explicitly state exclusions or refer to alternatives, so the agent must infer the boundary between send-message and list-messages.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds useful behavioral context by naming the exact GET endpoint and disclosing bulk/batched execution support, but it omits details like pagination, filtering behavior, or authentication needs. 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 two compact, front-loaded sentences: first the core endpoint, then the bulk behavior. It contains no fluff or repetition. Minor wording could be improved, but the structure is highly efficient.

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

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

Basic invocation is understandable: provide id, optionally use ids for batch. However, with no output schema and 0% parameter description coverage, the unexplained query and account parameters leave meaningful gaps. It is adequate for simple calls but not fully complete for all input options.

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 carries the burden of explaining parameters. It clarifies id as the conversation identifier and ids for batched execution, but provides no meaning for query or account parameters. This is only partial compensation for the lack of schema descriptions.

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

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

The description identifies the exact endpoint and resource: GET /api/v1/conversations/{id}/messages, so it clearly refers to listing messages for a conversation. This distinguishes it from sibling tools like datacrazy_conversations_list. However, 'Buscar conversa por ID' is slightly ambiguous because it could be read as fetching a conversation rather than its messages.

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 intended use is implied: pass a conversation ID to retrieve its messages, and use ids for batch execution. But there is no explicit guidance about when to prefer this over datacrazy_conversations_list or datacrazy_conversations_messages_create, nor any exclusions or prerequisites.

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 cover readOnly and idempotent nature. The description adds context about bulk support, which is a behavioral aspect not fully captured by annotations. No contradictions.

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

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

The description is extremely concise, consisting of two short sentences with no extraneous information. It follows a clear format of stating purpose then a note on bulk support.

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?

While the purpose is clear, the description omits details about response content, prerequisites, or how it fits with sibling tools. It is adequate but not fully complete for comprehensive understanding.

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

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

The description explains 'id' and 'ids' implicitly via bulk support, but does not clarify the 'query' or 'account' parameters. With 50% coverage, it fails to fully explain the input schema.

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

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

The description clearly states the tool retrieves an instance by ID, with Spanish verb 'Buscar' and resource 'instancia'. It also mentions bulk support, distinguishing it from list operations.

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

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

The description mentions bulk support but does not explicitly contrast with the sibling list tool or specify when to use this versus other retrieval methods. The usage context is implied but not fully articulated.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds only the HTTP method, but nothing about response format, filtering behavior, pagination, or any side effects beyond what annotations imply. It does not contradict annotations, but adds minimal 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 extremely short, one sentence, with no fluff. However, its brevity is not justified because it omits essential information about parameters and usage. It is under-specified rather than appropriately concise.

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

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

For a list operation with two undocumented parameters and no output schema, the description should explain the query and account parameters and any filtering semantics. It only states the endpoint and a generic verb, leaving the agent without sufficient information to invoke it correctly. This is inadequate for a tool with this complexity.

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

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

Schema description coverage is 0%, and the description does not mention the 'query' or 'account' parameters at all. There is no explanation of what these parameters mean, their formats, or how they affect the search. Since these are the only parameters, this is a severe 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 'Buscar instancias' (Search instances) clearly indicates it lists instances, and the endpoint GET /api/v1/instances confirms the action. However, it does not differentiate from the sibling datacrazy_instances_get, which retrieves a single instance, so it lacks explicit scoping or uniqueness guidance.

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 alternatives such as datacrazy_instances_get. No mention of conditions, prerequisites, or when not to use it. The description provides no context for selection.

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

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

Annotations already convey readOnlyHint=true, idempotentHint=true, and destructiveHint=false, which cover the safety profile. The description adds the bulk support behavior (accepts ids) and the endpoint path, but does not disclose details like pagination, limits, or what happens if the lead does not exist. Since annotations provide the core behavioral traits, the description adds some context but not comprehensive 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 two sentences: one explaining the primary function with the endpoint, and one noting bulk support. It is concise and front-loaded, with no unnecessary words. It earns its place but could add a bit more on parameter usage if needed.

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 that the tool has 4 parameters with 0% schema coverage, no output schema, and annotations cover safety, the description is minimally viable but lacks details on pagination, filtering options, and how bulk execution works (e.g., response structure). The complexity is moderate; the description covers the endpoint and bulk support but not enough for a fully informed agent 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%, meaning the description does not explain the parameters, but the schema lists 'id', 'ids', 'query', and 'account'. The description only mentions 'id' in the endpoint and 'ids' for bulk support. It does not clarify the meaning of 'query' or 'account'. With low coverage, the description could compensate but does not sufficiently do so; however, the tool has only 4 parameters and required one is obvious, so a score of 3 is appropriate.

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

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

The description clearly states the tool retrieves activities for a lead via a specific REST endpoint. It distinguishes from sibling tools like datacrazy_activities_list (which lists activities generally) by focusing on lead-specific activities. The verb 'Buscar' (search/get) is specific, and the endpoint is explicit.

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

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

The description mentions 'Bulk support: accepts ids for batched execution', which gives some usage guidance, but it does not explicitly state when to use this tool versus the sibling datacrazy_activities_list or other lead-related tools. It implies usage for fetching activities of a specific lead, but no clear context or exclusions 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?

With annotations already indicating readOnlyHint=false, the description's '[write, altera dados]' tag adds no new behavioral information. It discloses the HTTP endpoint but not consequences, required authentication, response behavior, or error conditions, so it provides minimal value 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, but it repeats the mutation signal already present in annotations with '[write, altera dados]'. It is concise yet under-specified, so the brevity is not fully 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 two-parameter tool with no output schema, the description still lacks essential context: the payload format for 'body', the role of 'account', and when this endpoint differs from datacrazy_leads_create. The annotations and sibling names provide some orientation, but the description does not make the tool safely invocable.

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

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

Schema description coverage is 0% and the description does not explain what 'body' or 'account' mean. 'Campos adicionais' hints at the purpose of body but gives no structure, format, or example, forcing the agent to guess how to construct a valid 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 clearly states the action ('Criar lead') and the specific resource ('campos adicionais', POST /api/v1/leads/additional-fields). It also distinguishes this from the sibling datacrazy_leads_create by emphasizing additional fields, though it doesn't explicitly contrast them.

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 alternatives like datacrazy_leads_create. The description implies 'use when creating a lead with additional fields,' but it does not state prerequisites, exclusions, or when the normal lead creation tool would be preferred.

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 repeats the write nature but doesn't detail side effects, required data format, or response behavior, relying solely on annotations.

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

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

The description is concise, one sentence with endpoint info, no fluff.

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

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

Missing critical details such as the expected format of the body (e.g., file upload, base64), any authentication requirements, and what the response contains.

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

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

No parameter descriptions are provided; leadId, body, and account are unexplained, leaving users to guess their roles.

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 'Attach file to lead' (Anexar arquivo ao lead) and provides the HTTP POST endpoint, making the tool's purpose unambiguous and distinct from list/delete attachment 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 lacks explicit guidance on when to use this tool versus others, but the action is clear; it could benefit from mentioning that it is for creating new attachments, not updating or deleting.

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

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

The description explicitly states 'Delete' and 'write, altera dados', indicating a destructive write operation, but the annotations declare destructiveHint=false, which contradicts the action. This is a direct contradiction, warranting a score of 1 per the rules.

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

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

The description is concise, with the main purpose stated in the first sentence and a separate note for bulk support. It is front-loaded and contains no fluff or redundancy.

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

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

Given the tool has 5 parameters, no output schema, and sparse annotations, the description is incomplete. It lacks explanations for 'body' and 'account', does not mention side effects or prerequisites, and omits return value details. The contradiction further reduces completeness.

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

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

Schema description coverage is 0%, so the description must compensate. It explains leadId and id/ids partially via the endpoint and bulk note, but ignores 'body' and 'account' parameters entirely. This leaves much of the parameter semantics unexplained.

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

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

The description clearly states the action: 'Delete file attached to lead' with the HTTP endpoint, distinguishing it from sibling tools like create and list. It specifies both the resource (attachment) and the operation (delete) clearly.

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

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

No explicit guidance is given on when to use this tool versus alternatives, such as create or list for attachments. It implies usage for deletion but does not mention exclusions or conditions, and the bulk execution is only mentioned as a note without context on when to use it.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, which cover the safety profile. The description adds the HTTP GET method and endpoint, which is consistent with the read-only behavior, but does not add details about response format, auth requirements, or pagination.

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

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

A single sentence with the essential action and endpoint, no filler. The description is front-loaded and easy to parse.

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

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

The tool is simple and the purpose is clear: retrieve a lead's attachments. However, the optional query and account parameters are undocumented and there is no output schema, so the agent still faces some uncertainty about filtering options and response shape.

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 endpoint makes it explicit that leadId is a path parameter identifying the lead. The description does not explain the meaning of the query or account parameters, and with schema coverage at 0%, these two optional parameters remain 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 clearly states the operation: 'Buscar os arquivos anexados ao lead' (fetch the files attached to the lead), with the exact endpoint. This differentiates it from sibling tools like datacrazy_leads_attachments_create/delete and datacrazy_leads_list.

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

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

The intended context is clear: use this tool when you need the attachments for a lead, using the leadId. It does not, however, mention exclusions or alternative tools to avoid, so it stops short of fully explicit 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?

Since annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, the description adds modest value by specifying the GET method and bulk execution via ids. It does not discuss pagination, return format, or possible limitations, so the additional transparency is limited.

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 highly concise: a single purpose line with the endpoint, plus one clear sentence about bulk support. No filler or redundant restatement 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?

Despite having helpful annotations, the tool has four parameters, all undocumented in the schema, and no output schema. The description only partially explains id and ids, leaving query/account and return-behavior mysteries, which makes it insufficient for fully informed invocation.

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

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

Schema description coverage is 0%, and the description only hints at the 'id' (via endpoint) and 'ids' (via bulk support) parameters. The 'query' and 'account' parameters are not explained, leaving 50% of the schema without semantic meaning.

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

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

The description states 'Buscar os negocios do lead' (search for the lead's businesses) and includes the exact GET endpoint, clearly specifying the resource and scope. It is distinct from sibling tools like datacrazy_businesses_list by targeting businesses belonging to a specific lead.

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 'do lead' clearly indicates this tool is used when needing businesses associated with a lead. However, it does not explicitly mention exclusions or name alternative tools for non-lead-scoped business listing.

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 clearly indicate that this is a write operation (readOnlyHint=false, idempotentHint=false, destructiveHint=false). The description adds minimal value by repeating the write nature with '[write, altera dados]'. Since annotations carry the burden, a score of 3 is appropriate, though slightly lower because the description does not provide additional 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 very brief (one sentence), but it is also under-specified. It is front-loaded with the purpose, but the lack of parameter details makes it less concise in utility. It is not verbose, but it misses critical information, so it earns a middle score.

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 is a POST operation with two undocumented parameters and no output schema, the description should provide more context. The endpoint is mentioned, but the body structure and account requirements are not explained. For a creation tool, this is insufficient for an agent to use correctly.

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

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

Schema description coverage is 0%, and the description does not explain what the 'body' or 'account' parameters should contain. The parameter names are generic, and without any description, the agent has no idea how to construct a valid request. This is a critical gap; even a basic template for the body would be valuable.

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 'Criar lead' (create lead) and includes the HTTP endpoint POST /api/v1/leads. It is distinct from other tools like datacrazy_leads_list, datacrazy_leads_get, and datacrazy_leads_patch, as it explicitly indicates creation. The inclusion of the endpoint adds clarity, though it does not explicitly differentiate from all sibling tools.

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

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

The description provides no guidance on when to use this tool versus alternatives. It only indicates it performs a write operation. There is no mention of prerequisites like authentication, context for creating a lead, or when to prefer this over other write tools like datacrazy_businesses_create.

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 claims a delete operation (altera dados) but the annotation destructiveHint is false, which contradicts the destructive nature of deletion. The description does not disclose whether deletion is permanent or irreversible, and the annotation contradiction lowers the score to 1.

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, using two sentences to convey the core function and bulk support without unnecessary fluff.

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

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

The description provides the basic context (delete lead) but lacks details on return values, error handling, or side effects. Given there is no output schema, it could be more complete about expected outcomes, especially for a destructive operation.

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

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

The description explains the 'ids' parameter for bulk execution, but does not explain 'body' or 'account'. Since the schema has no descriptions (0% coverage), the description should compensate more fully; it only partially clarifies parameters.

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

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

The description clearly states the tool's purpose: to delete a lead, with the HTTP method and endpoint. It also mentions bulk support, distinguishing it from other lead operations.

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

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

The description implies usage for deleting leads and supports bulk deletion, but it does not explicitly state when to use it versus other similar tools (though there are no direct alternatives for lead deletion). It could be clearer about prerequisites or side effects.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds useful behavior beyond annotations: the exact HTTP method (GET) and the batch execution behavior via multiple IDs. This is appropriate transparency for a simple read-only 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 highly concise: two short sentences, front-loaded with the primary purpose and endpoint. The bulk-support line is informative and adds no redundancy. 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?

The tool is simple and annotations cover safety and idempotency, but the description still leaves `query` and `account` undefined, and with no output schema it does not hint at return structure. It is adequate for basic ID-based retrieval but not fully complete for all parameters.

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

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

Schema description coverage is 0%, so the description must compensate. It explains `id` (lead ID) and `ids` (batch support), but `query` and `account` remain undocumented. This leaves meaningful gaps for optional parameters, though the core required parameter is clearly explained.

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

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

The description clearly states the tool's function: 'Buscar lead por ID' (search lead by ID) with the explicit GET endpoint. It distinguishes itself from list-type siblings by specifying ID-based retrieval, and the bulk support note adds a clear second capability.

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

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

The description provides clear usage context: use it to fetch a lead by ID, with bulk support via the `ids` parameter. It does not explicitly name alternatives like datacrazy_leads_list or state when not to use it, but the by-ID focus is sufficient for basic selection.

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

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

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds no further details about side effects, permissions, or limitations. It does not contradict annotations, but provides minimal additional 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 extremely concise, consisting of two short sentences. It conveys the essential purpose without unnecessary filler, making it easy to parse quickly.

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?

While the core purpose is clear, the description omits details about the nature of the history returned and does not explain all parameters. Given the simplicity of a GET endpoint, it may be sufficient for basic use, but lacks completeness for nuanced scenarios.

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

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

The input schema lists parameters (id, ids, query, account) with no descriptions. The description only hints that 'ids' is for bulk use, leaving 'query' and 'account' unexplained. This provides insufficient guidance for correct usage.

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

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

The description clearly states the tool retrieves lead history via GET, and mentions bulk support for multiple IDs. It distinguishes from sibling tools like datacrazy_leads_get or datacrazy_leads_list by focusing on history, but could be more specific about what constitutes 'history' (e.g., activities, notes, changes).

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

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

The description mentions bulk capability ('accepts ids for batched execution') but does not explicitly state when to use this over other lead-related tools. It lacks guidance on alternatives or conditions, such as when to prefer this over datacrazy_leads_get.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description adds little beyond the endpoint. The description does not mention any limitations (e.g., no pagination details, no sorting, no auth specifics) or what data is returned. For a tool with no additional behavioral disclosure, this is minimal.

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

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

The description is extremely short, which is concise, but it is arguably under-specified rather than efficiently written. It front-loads the purpose, but the lack of additional information means it isn't ideal. However, for a simple list operation, it may be acceptable.

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

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

With no output schema, annotations provide safety but no return format details, and parameters are undocumented, the description is incomplete. It doesn't mention pagination, response structure, or filtering options. For a list endpoint, agents need to know what data is returned and how to filter, which 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?

The schema has 2 parameters with zero description coverage. The endpoint '/api/v1/leads' implies the parameters 'query' and 'account' are used for filtering, but the description does not explain their meaning or format. With no schema descriptions, the description should compensate but only provides the endpoint, giving minimal guidance. A baseline 3 is fair because the endpoint hints at usage.

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

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

The description states it searches for leads and references the API endpoint, clearly indicating a read intent. However, it does not differentiate from siblings like datacrazy_leads_get or datacrazy_leads_activities_list, which may also involve leads. The verb 'Buscar' and resource 'leads' are 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?

No guidance on when to use this tool versus alternatives. The description does not mention filtering scope, pagination, or how it differs from datacrazy_leads_get or datacrazy_leads_list (which is the same name? Actually sibling is datacrazy_leads_get, etc.). There is no explicit context or exclusions, only a terse verb phrase.

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

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

The description explicitly notes '[write, altera dados]', which adds a behavioral signal beyond the annotations' readOnlyHint=false. However, it does not disclose other behavioral details such as required permissions, side effects, or response behavior, so it provides only modest 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 efficient sentence with the endpoint and a write tag, containing no filler or redundancy. It is front-loaded with the core action, though it sacrifices some necessary detail for brevity.

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

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

For a tool with no output schema and minimal annotations, the description is too sparse to fully support correct invocation. It omits parameter semantics, usage context, and any expected return or side-effect information, leaving 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 0%, and the description does not explain the meaning of 'body' or 'account'. Only 'leadId' is implied through the endpoint path, leaving the other two parameters semantically undocumented.

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

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

The description states a specific action, 'Adicionar comentário' (add comment), and includes the endpoint POST /api/v1/leads/{leadId}/notes, making the resource and operation clear. It distinguishes itself from sibling note tools (delete/list/update) by the create/add semantics, though it does not explicitly contrast them.

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 alternatives like datacrazy_leads_notes_update or datacrazy_leads_notes_delete. The description only states what the tool does, not the context or exclusions.

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

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

Annotations lack destructiveHint or idempotentHint, so the description must disclose effects. It states 'altera dados' (changes data) but does not clarify irreversibility, whether permissions are required, or what happens to related data. Bulk support is noted but not detailed (e.g., partial failures). No annotation contradiction, but transparency is minimal.

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 purpose. The bulk support note is helpful. It is concise with no fluff, though a bit more context could be added without sacrificing brevity.

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 there are 5 parameters, no output schema, and minimal annotations, the description is incomplete. It mentions bulk support but does not clarify parameter usage (e.g., body, account) or behavior for batch operations. For a mutation tool, 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 coverage is 0%, and there are 5 parameters (leadId, id, ids, body, account) with only leadId and id required. The description mentions bulk via 'ids' but does not clarify the role of 'body' or 'account'. With zero schema descriptions, the tool description should compensate, but it only hints at ids for bulk, leaving semantics unclear.

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

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

The description clearly states the tool deletes a lead comment/note via DELETE /api/v1/leads/{leadId}/notes/{id}. It distinguishes from 'update' and 'create' notes by indicating deletion, and the endpoint path clarifies the resource. However, it does not explicitly differentiate among delete siblings for attachments, activities, or businesses, but the resource (notes) 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?

The description mentions the HTTP method DELETE and marks it as [write], implying it modifies data. It also notes bulk support. However, it does not explicitly state under what circumstances to use this tool vs alternatives, nor does it mention prerequisites or potential cautions (e.g., irreversible deletion). Usage is implied but not elaborated.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the main safety profile is communicated. The description adds the concrete GET endpoint and confirms it reads lead notes, but it does not disclose return shape, ordering, filtering behavior, or pagination.

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

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

The description is one compact, front-loaded sentence with the core action, resource, and endpoint. There is no redundant text or repetition.

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 listing operation, the description is minimally adequate due to useful annotations, but it is not complete: it omits the meaning of two optional parameters and any return or output details. The agent can guess the primary purpose but needs additional inference for full use.

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

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

Schema description coverage is 0%, so the description must compensate, but it only clarifies leadId through the URL path. The query and account parameters remain completely unexplained, leaving the agent unsure about how filtering or account scoping works.

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 ('Buscar comentários do lead') and identifies the exact resource via the GET endpoint. It is easily distinguishable from sibling tools like datacrazy_leads_notes_create, datacrazy_leads_notes_update, or datacrazy_leads_activities_list.

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

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

The description does not explain when to prefer this tool over alternatives, nor does it mention any necessary context such as requiring a valid leadId or combining with lead lookup tools. There is no when-to-use or when-not-to-use guidance.

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

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

The description adds the write/change nature ('[write, altera dados]') and bulk execution via ids, which goes slightly beyond the annotations (readOnlyHint=false). However, it does not disclose response behavior, side effects, permissions, partial-failure behavior, or edge cases, so transparency is basic rather than 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 only two sentences, front-loads the operation and endpoint, and adds bulk support as a separate focused note. There is no filler or redundancy; 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 five parameters, no output schema, and 0% schema description coverage, this description is too sparse to fully support correct invocation. It clearly conveys the core update purpose and bulk capability but lacks critical parameter semantics and usage details for a mutation tool.

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

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

The schema has 0% description coverage. The endpoint path helps clarify leadId and id, and the bulk-support sentence explains ids, but body and account are not described. This is insufficient compensation for five undocumented parameters.

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

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

The description clearly states 'Atualizar comentário do lead' (update lead comment) and specifies the exact endpoint (PUT /api/v1/leads/{leadId}/notes/{id}). This distinguishes it from sibling tools like datacrazy_leads_notes_create/delete/list and makes the resource and operation unambiguous.

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

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

The description implies its use when updating an existing lead note, especially via the update verb and endpoint. It does not explicitly provide when-to-use guidance, exclusions, or mention alternatives such as create/delete/list sibling tools, so usage context is only implied.

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 repeats that it modifies data ('altera dados') without detailing side effects, reversibility, or consequences. Given it is a write operation, more transparency is expected; annotations already indicate non-read-only, so this adds 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 extremely concise, using two short sentences. It avoids unnecessary verbosity and directly states the purpose and bulk capability, which is appropriate for the simplicity of the tool.

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

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

Given that the schema lacks any descriptions (0% coverage), the description should compensate by explaining the purpose of each parameter. It only mentions ids, leaving id, body, and account unexplained, making it incomplete for a user to fully understand the tool's usage.

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

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

The input schema has four parameters (id, ids, body, account), but the description only references 'ids' for bulk support. It does not explain id, body, or account, leaving most parameters undefined.

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 'Atualizar lead' (update lead) and the HTTP method PATCH, distinguishing it from create, delete, and list operations. It does not elaborate on specific fields, but the verb+resource pattern is specific.

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

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

The description mentions bulk support for batched execution, providing some guidance for when to use multiple ids. However, it does not explicitly state when to use this tool versus alternatives, such as when a lead already exists or when to avoid it.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description's 'list' action is consistent. The description adds minor transparency by mentioning output fields, but does not elaborate on side effects (not needed given 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, clear sentence without unnecessary details or repetition. It efficiently conveys the tool's purpose and output.

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

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

The description covers the main purpose and output, but omits explanation of the 'account' parameter, leaving a gap in understanding how to invoke the tool correctly. Given the simplicity, it could easily have included parameter guidance.

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

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

The single parameter 'account' is not described at all. The description does not explain whether it is a filter, an identifier, or optional. With schema coverage at 0%, the description fails to provide any semantic meaning for the 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?

Description clearly states the action (list) and resource (DataCrazy connections/accounts) with a specific scope (linked to this install). It also notes the returned fields (id, label), making it distinct from other list tools in the sibling set.

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 for retrieving accounts but does not explicitly state when to use it over alternatives or any exclusions. It lacks direct guidance on context or filtering, though the resource is unique among 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 description explicitly states that this is a write operation and that it changes data via '[write, altera dados]', which provides some transparency beyond the annotations. However, it does not disclose return behavior, required authorization, or edge cases like duplicate list creation.

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, front-loads the core purpose and HTTP method, and has minimal wasted words. It is slightly redundant because 'write' and 'altera uma dadds' convey similar meaning, but it remains 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 no output schema and unexplained parameters, this description is not sufficient for a safe and correct create operation. It would need to explain what the created list should contain, how 'body' maps to the API request, and what response the agent should expect.

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

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

Schema description coverage is 0%, and the description does not explain what the 'body' string should contain or how the 'account' parameter is used. Without this information, the agent cannot correctly construct the request payload.

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 and resource: 'Criar lista' with 'POST /api/v1/lists'. This distinguishes it from sibling list operations like datacrazy_lists_delete, datacrazy_lists_get, datacrazy_lists_update, and datacrazy_lists_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 about when to use this tool versus alternatives, nor any context about required prerequisites or typical workflows. The intended usage is only implied by the tool's name and the HTTP endpoint.

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 'Excluir lista' and uses the DELETE HTTP method, which clearly implies destruction, while the annotations declare destructiveHint: false. This is an annotation contradiction, so the transparency score must be 1.

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 and endpoint. '[write, altera dados]' and 'Excluir lista' are somewhat repetitive, but the overall size and structure are efficient.

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

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

The description captures the basic delete operation and bulk capability, but it omits what body and account mean, whether deletion is permanent/reversible, and what happens in batch execution. Given the contradictory destructiveHint and no output schema, more behavioral context is needed.

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

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

With schema description coverage at 0%, the description must compensate, but only the ids parameter is explained ('Bulk support: accepts ids for batched execution'). The id, body, and account parameters are not meaningfully described, leaving important invocation details 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 clearly names the operation: 'Excluir lista' and explicitly states the HTTP endpoint DELETE /api/v1/lists/{id}. This precisely identifies the resource and action, and the bulk-support note differentiates it from simpler non-batch operations.

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

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

The description indicates when to invoke the tool (to delete a list) and mentions bulk execution using ids. However, it does not explicitly state when not to use it or point to alternatives such as datacrazy_lists_update when a list should only be changed.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior. The description adds the bulk support capability, which is a useful behavioral detail not captured in annotations. However, it does not mention failure modes or resource-specific behavior, so it does not substantially go beyond the annotation coverage.

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

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

The description is concise and well-structured: two short sentences, first stating the primary function, second adding the bulk support detail. No redundant or extraneous content.

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

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

The description lacks essential contextual details, such as what the returned list object contains, what 'query' and 'account' parameters do, or any error behavior. Given the absence of an output schema, these omissions leave the tool's behavior and expected usage incomplete.

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

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

The schema has four parameters, but the description only clarifies 'ids' by mentioning bulk support. The required 'id' is implicitly clear from the description, but 'query' and 'account' are completely unexplained. With low schema coverage and minimal descriptive help, parameter semantics are weak.

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 retrieves a list by ID, reinforced by the explicit endpoint 'GET /api/lists/{id}'. It distinguishes from sibling list operations like create/update/delete, though it does not elaborate on what type of list it returns.

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 bulk support note ('accepts ids for batched execution') offers some guidance for when multiple IDs are involved, but there is no explicit direction on when to use this tool instead of the list endpoint or other alternatives. The context of getting a single item by ID is implied but not stated as a rule.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds only the HTTP route and the phrase 'Buscar listas', without explaining return format, pagination, filtering behavior, or any other runtime characteristics.

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

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

The description is extremely short and front-loaded, with no filler: the verb, resource, and endpoint all appear immediately. It is concise, although it is so terse that it sacrifices the semantic richness needed for a tool with two undocumented parameters.

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

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

Given the two undocumented parameters, the many sibling list/get tools, the farm-style tool, and the empty output schema, this one-line description is not enough for an agent to confidently choose and invoke the tool. The annotations reduce safety concerns but do not compensate for missing parameter and return-value 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 0% and the description does not explain the 'query' or 'account' parameters. While the parameter names are somewhat self-explanatory, the description adds no meaning about expected values, formats, defaults, or how they affect the list result.

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 operation ('Buscar listas') on the lists resource, backed by the explicit GET endpoint. It is reasonably clear but does not distinguish itself from related siblings like datacrazy_lists_get or datacrazy_list_accounts beyond the generic plural endpoint.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't explain that this is for searching multiple lists, how it differs from retrieving a single list, or whether account/query filtering changes the use case. The only implied context is that it's a list/search operation.

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 '[write, altera dados]' is consistent with annotations (readOnlyHint=false) but largely redundant. It adds the PUT method and bulk-execution behavior, but does not disclose what data changes, whether it is reversible, or what response to expect.

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, front-loaded, and contains no filler. Every sentence serves a purpose, though brevity comes at the cost of omitting critical parameter details.

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

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

For a mutation tool with 4 parameters, no output schema, and zero parameter descriptions, this description is incomplete. It does not explain the body format, account context, or return value, so an agent would struggle to invoke it correctly beyond the trivial required `id`.

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 for parameter meanings. It only clarifies that `ids` enables batched execution; the required `id`, `body` payload, and `account` are left undefined.

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

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

Description states 'Atualizar lista' and specifies the HTTP PUT endpoint, clearly identifying it as a list update operation. It is unambiguous against sibling tools like lists_create, lists_get, lists_delete, and lists_list, though it does not detail what fields can be updated.

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

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

No explicit guidance on when to use this tool versus alternatives beyond 'bulk support: accepts ids for batched execution.' It does not mention when to use create/get/list instead, nor any exclusions or prerequisites.

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 cover read-only, idempotent, non-destructive behavior; the description adds bulk execution and the endpoint path. However, it does not add context like auth needs, rate limits, or how id, ids, query, and account interact.

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 and then the bulk caveat. Every element earns its place with no filler or repetition of annotations.

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 4 parameters, no output schema, and zero schema descriptions, the description is too thin: it omits query/account semantics and return behavior. Bulk support is helpful, but not enough to make the tool fully self-explanatory for an agent.

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

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

With 0% schema description coverage, the description must explain all parameters but only clarifies id ('por ID') and ids ('bulk support'). The optional 'query' and 'account' parameters remain entirely unexplained, leaving a significant semantic 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 verb+resource: 'Buscar pipeline por ID' with the exact GET endpoint, and the bulk support note distinguishes batched behavior. This clearly separates it from sibling tools like datacrazy_pipelines_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 clearly signals use when you have a pipeline ID or multiple IDs and want to retrieve pipelines. It does not explicitly name alternatives or exclusions such as using datacrazy_pipelines_list for unfiltered queries, 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?

The annotations already declare readOnlyHint, idempotentHint, and destructiveHint, making the safety profile clear. The description adds no behavioral details beyond the HTTP method (which is redundant). It does not disclose potential response characteristics (e.g., pagination, default limits) or any side effects, so it adds minimal value over 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 extremely concise, consisting of a single sentence. It is front-loaded with the core action and resource. There is no fluff, so it earns a high score for conciseness. However, its brevity works against completeness, but conciseness is about avoiding unnecessary length, which it does.

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

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

The tool has two optional parameters and no output schema, so the description must provide enough context for the agent to understand the tool's behavior and inputs. It fails to do so—no parameter descriptions, no mention of response format, and no pagination info. This is inadequate for a real-world list operation, leaving the agent to guess.

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

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

With 0% schema description coverage, the description carries the full burden of explaining the two parameters ('query' and 'account'). However, it gives no information about their semantics, formats, or optionality. This is a critical gap; an agent cannot determine how to use these filters effectively.

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 ('Buscar' = search) and resource (pipelines), along with the HTTP method. It accurately conveys the tool's primary function as a search/list operation. However, it does not explicitly distinguish itself from sibling tools like datacrazy_pipelines_get, which might also involve 'pipelines' but likely retrieves a single item. The name 'list' helps, but the description alone doesn't make the distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to prefer searching over getting a specific pipeline, nor does it explain the purpose of the 'query' and 'account' parameters. Given the sibling tools like datacrazy_pipelines_get and datacrazy_pipelines_stages_list, there is no context to select the right tool.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the GET method and bulk-execution behavior, but it doesn't disclose pagination, filtering semantics, or return shape, so it only modestly supplements 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?

Two short sentences, front-loaded with the core purpose and followed by the bulk-support detail. Every word earns its place, 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?

Despite the helpful annotations, the description lacks guidance on the meaning and usage of the 'query' and 'account' parameters, and there is no output schema to clarify the response. Given 4 parameters and zero schema description coverage, this leaves significant gaps for an agent.

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

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

Schema description coverage is 0%, so the description must clarify parameters. It explains that 'ids' enables batched execution, but 'query' and 'account' remain unexplained, and 'id' is only implied via the URL path. This is insufficient compensation for a 4-parameter 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 uses a specific verb ('Buscar') and resource ('etapas da pipeline') and includes the REST path GET /api/v1/pipelines/{id}/stages, clearly indicating it fetches stages for a pipeline. It is distinct from sibling tools like datacrazy_pipelines_get/list, though it could more explicitly describe what the returned data contains.

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 clearly implies this is the tool for retrieving pipeline stages and explicitly mentions bulk support via ids, which is a concrete usage condition. It doesn't reference alternative tools, but no sibling stage-specific tool exists, so the intended context is reasonably clear.

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

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

Annotations show readOnlyHint=false and idempotentHint=false, consistent with a write operation. The description adds '[write, altera dados]' which is redundant with the annotations.offer no additional behavioral context (e.g., side effects, limitations, rate limits, data validation). Since annotations already convey the write nature, this adds no value.

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

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

The description is extremely short – one line with the action and endpoint. It is concise but lacks any structure. It does front-load the main verb and resource, but it is too brief to be truly efficient; there is no part that adds value beyond the name. It is not bloated, so it receives a middle score.

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 2 params with no schema descriptionsative assistance and no context about the product creation process (required fields, data format, error handling, authentication), the description is severely inadequate. The agent cannot confidently invoke this tool correctly without guessing what the parameters should contain. With zero schema descriptions, the description must compensate but fails to do so.

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 2 parameters, but schema_description_coverage is 0% (no descriptions in schema). The description does not explain what 'body' or 'account' mean. The description only says 'create product' with no mention of the parameters. The agent cannot infer what to put in the body or what account refers to. This is a major gap.

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

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

The description states the action (criar produto) and the HTTP method (POST) but it essentially restates the tool name 'products_create'. It distinguishes from siblings like 'products_delete' and 'products_update' only through the verb, which is already in the name. It lacks scope details (e.g., what types of products, any required fields) and doesn't go beyond the tool name's inherent meaning.

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

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

No guidance on when to use this tool versus alternatives. Siblings include create, update, delete, get, list – but the description doesn't mention when to create vs. update, or any prerequisites like account validity or authentication. There's no when/when-not 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?

The description describes a destructive operation ('Excluir produto', DELETE) and states '[write, altera dados]', while the annotations set `destructiveHint: false`. This is a direct contradiction. The description provides no other behavioral context such as irreversibility, authorization requirements, or side effects.

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

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

The description is very concise: two short sentences with the core action, endpoint, and batch capability front-loaded. There is no filler, and every sentence adds useful information.

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

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

Given four parameters, no output schema, and an annotation contradiction, the description is too sparse. It omits the meaning of `body` and `account`, possible error/response behavior, and the destructive side effects. The bulk note is helpful but not enough for confident invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning by noting that `ids` enables batched execution and that `id` is used in the URL path. However, `body` and `account` remain completely unexplained, leaving the tool under-documented for a 4-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 clearly states 'Excluir produto' (delete product) and explicitly names the endpoint DELETE /api/v1/products/{id}. The action, target resource, and HTTP method are unambiguous, and it is easily distinguished from sibling product tools like create, get, list, and update.

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 bulk-support note provides concrete usage guidance: an agent can pass `ids` for batched deletion instead of repeatedly calling the tool. However, it does not explicitly address when not to use this tool or compare it to alternatives, though the delete purpose is inherently clear.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, indicating a safe read operation. The description adds that it accepts bulk IDs for batched execution, which is beyond the annotations. No contradictions.

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

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

The description is very brief (two sentences) and front-loaded with the main purpose. It wastes no words, but the lack of parameter detail is a minor trade-off.

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

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

Given no output schema, the description should explain return values, but it doesn't. Bulk support is mentioned, but parameter semantics for 'query' and 'account' are missing. It's adequate for a simple GET but incomplete for a 4-parameter tool with no output schema.

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

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

Schema coverage is 0%, so the description must explain parameters, but it only mentions 'ids' for bulk. The 'id', 'query', and 'account' parameters are not described at all, leaving the agent to guess their meaning. The description adds minimal value beyond the schema.

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

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

The description clearly states 'Buscar produto' (search/get product) and provides the exact endpoint GET /api/v1/products/{id}. It distinguishes this from list/create/update/delete siblings by indicating it's a retrieval operation.

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

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

The description notes bulk support via IDs, which hints at when to use this over list. However, it does not explicitly state when to use this vs. datacrazy_products_list (e.g., when you have a specific ID vs. need to list all). No exclusion guidance is provided.

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