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

With no annotations provided, the description carries the full behavioral burden. It explicitly signals read-only behavior with 'Leitura', which is useful, but it does not disclose return format, pagination, required permissions, or any other behavioral traits that could affect invocation.

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 and front-loaded, with no filler. Every word earns its place, though the brevity leaves out useful detail. It is appropriately concise for a simple listing tool.

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

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

For a tool with 3 parameters, low schema coverage, and no output schema, the description is not complete enough. It lacks explanations of the required 'repo' parameter and the 'filter' parameter, and provides no return-value context. An agent could call it but may guess at parameter behavior.

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

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

Schema coverage is only 33%, with only the 'project' parameter described. The description adds almost no parameter-level meaning: it references 'repo' generically but does not explain the required 'repo' parameter format or the semantics of 'filter'. The low schema coverage is not compensated.

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

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

The description states a specific verb and resource: 'Lista branches de um repo' (lists branches of a repo). The resource type clearly distinguishes it from sibling list tools like pr_list, commit_list, and repo_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 use is implied clearly by the tool name and description—list branches of a repository—but there is no explicit guidance about when to choose this over other list tools, nor any exclusions or alternative recommendations. The context is adequate but relies on inference.

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

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

The description explicitly says 'Leitura' (read-only), which is a useful behavioral disclosure since no annotations are provided. However, it does not describe auth requirements, default branch behavior, pagination, or output format, so the burden is only partially met.

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: a single informative sentence plus one clarifying read-only label. It is front-loaded and contains no filler.

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

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

For a simple read-only list tool with only one required parameter, the description plus schema is minimally adequate. Still, the low parameter coverage, lack of output schema, and absence of behavioral details like defaults or limits leave meaningful gaps for correct invocation.

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

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

Schema description coverage is only 25%, and the description adds minimal parameter meaning. It mentions repo/branch indirectly, but does not clarify the semantics of 'top', branch optionality, or project allowlist behavior beyond what is already in the schema.

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

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

The description states a specific action and resource: 'Lista commits recentes de um repo/branch' (list recent commits of a repo/branch). This clearly distinguishes it from sibling list tools like pr_list, branch_list, and repo_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 implies the tool is for retrieving commit history, but it does not explicitly state when to use it over alternatives or mention any exclusions. The context is clear enough for basic selection, but there is no direct guidance about sibling tools.

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

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

With no annotations, the description must carry the behavioral burden. 'Escrita: write + confirm' does disclose that this is a mutating operation and signals a confirmation requirement, which is useful. However, it does not describe side effects, permissions, idempotence, or what the confirmation step involves, leaving a substantial gap.

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-loaded with the main action, and adds a behavioral note without padding. The second sentence is terse and slightly cryptic but still scannable and short.

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

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

For a 5-parameter write operation with no annotations and no output schema, the description is too thin. It lacks detail on required parameters, confirm behavior, project allowlisting, and expected outcomes, so an agent cannot reliably invoke it from the description alone.

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

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

Schema description coverage is only 20%, yet the description contributes meaning only for 'reviewers' ('adiciona reviewers'). It does not explain repo, prId, or the critical confirm boolean, and it fails to compensate for the undocumented majority of 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 states a specific action ('Adiciona reviewers a um PR') with a clear object, and 'reviewers' clearly distinguishes it from generic PR operations like pr_create/pr_update. However, it does not explicitly disambiguate from pr_update or mention the scope of the addition, so it stops short of a 5.

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

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

The phrase 'Adiciona reviewers a um PR' implies the use case: when reviewers must be added to a pull request. There is no explicit guidance on when to prefer this over pr_update/pr_comment, no exclusions, and no mention of the confirmation workflow beyond 'write + confirm', so guidance is only 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?

With no annotations provided, the description carries the full burden. It does disclose that the operation is a write requiring confirmation and that it opens a thread, which is useful. However, it does not clarify side effects, permission requirements, whether this creates a top-level thread or replies to an existing one, or failure behavior.

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

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

The description is very short and front-loaded with the core action. There is no padding, though 'Escrita: write + confirm' is cryptic and mixes languages, slightly reducing clarity.

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

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

For a mutating tool with five parameters, no annotations, and no output schema, the description omits important usage context: how confirm is used, what the comment body should contain, how repo/prId/project relate, and what the response indicates. It is not complete 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 only 20%, so the description must compensate, but it only alludes to 'confirm' via 'write + confirm' and does not explain repo, prId, text, or the confirm behavior in detail. The parameter names are somewhat self-explanatory, but the description adds little beyond the bare schema.

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

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

The description states a specific verb ('Comenta'), a specific resource ('num PR'), and a distinguishing behavior ('abre thread'). This clearly differentiates it from sibling tools like wit_comment (work item comments) and pr_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 description gives a clear context cue ('num PR') but does not explicitly state when to use this tool over alternatives such as wit_comment, nor does it provide exclusion criteria. 'Escrita: write + confirm' describes operation mode, not tool 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?

With no annotations, the description carries the full transparency burden. It does disclose that this is a write operation requiring confirmation ('Escrita: write + confirm') and explicitly says it does not merge. However, it omits other behavioral details such as permissions, side effects, reversibility, or response format. The added context is helpful but not comprehensive.

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

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

Two short sentences contain all the essential information with no filler. The primary purpose is stated first, followed by a key non-behavior and a write/confirmation signal. 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 10 parameters, no output schema, and no annotations, the description is too sparse to be fully actionable. It does not clarify required parameter semantics, return values, or failure conditions. The minimal caution about merge and confirmation is useful, but an agent would still face ambiguity about how to fill source, target, and other fields correctly.

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

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

Schema description coverage is only 30%, so the description should compensate for undocumented parameters. It only hints at the confirm parameter via 'write + confirm' and does not explain meaning for repo, source, target, title, description, or workItemIds. Although some names are self-explanatory, the critical source/target branch semantics are not clarified.

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

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

The description explicitly states the action and resource: 'Cria um pull request' (creates a pull request). It also disambiguates by saying 'NÃO faz merge' (does NOT merge), which clearly distinguishes the operation from a merge action. This is specific and immediately understandable.

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 main use case is clear: use this tool to create a pull request. The explicit warning 'NÃO faz merge' tells the agent not to use this tool when a merge is intended. It does not name alternatives like pr_update or pr_add_reviewers, but the sibling list and the verb 'create' make the intended context clear.

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

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

The description discloses that the operation is read-only ('Leitura') and that it returns details of a pull request, which is useful behavioral context. However, with no annotations provided, the description carries the full transparency burden and does not mention potential caveats such as the ADO_PROJECT_ALLOWLIST restriction, error behavior, or what specific fields are 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 extremely concise, with no filler words. 'Detalha um pull request' states the action and object, and 'Leitura' adds the read-only distinction. Both sentences earn their place, and the information is front-loaded.

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

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

For a simple get operation this is minimal but not fully complete. There is no output schema and no annotations, so the description should provide more context about return format, the optional project parameter, or how the project allowlist works. It gives the basic idea but leaves an agent under-informed about important operational details.

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

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

The description adds no parameter-level meaning; it does not explain prId, repo, or project. Schema coverage is only 33%, so the description should compensate, but it does not. Parameter names like prId and repo are somewhat self-explanatory, yet the description contributes no value beyond the schema for the 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 uses a specific verb ('Detalha') and resource ('um pull request'), making its purpose clear: retrieve details for a single pull request. 'Leitura' further signals it is a read operation, which separates it from write siblings like pr_create, pr_update, and pr_comment. It does not explicitly differentiate from pr_list, but the singular 'um' implies a single-item detail lookup.

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

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

The description only says 'Leitura' (reading), which implies this is for read use but provides no explicit guidance on when to choose it over pr_list or other PR-related tools. It does not mention alternatives, exclusions, or any conditions that would select this tool.

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

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

With no annotations, the description carries the behavioral burden and it does state 'Leitura' (read-only), a useful side-effect hint. However, it discloses nothing else, such as pagination, ordering, or potential permission needs.

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

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

The description is two short sentences with no filler. The core purpose is front-loaded and the read-only note earns its place.

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

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

For a tool with 5 parameters, no output schema, and no annotations, this description provides only the bare purpose. It lacks enough detail about filters and behavior for an agent to confidently select correct 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 only 20%, and the description does not compensate for the undocumented parameters (status, target, creatorId). It only clarifies that the listing is scoped to a repo, leaving most parameter meanings to be inferred from names and the enum.

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 starts with 'Lista pull requests de um repo', stating a specific action and resource. 'Leitura' clarifies it is a read operation, which helps distinguish it from mutating PR tools like pr_create or pr_update, though it does not explicitly name alternatives.

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

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

There is no guidance about when to use this tool versus alternatives such as pr_get or wit_query. The name implies listing, but no context is given about filtering scenarios or when another PR-related tool would be more appropriate.

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

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

With no annotations, the description discloses that this is a read operation ('Leitura'), which is important safety-relevant behavior. It also states that it marks which projects can be used elsewhere, adding output semantics beyond the tool name. It does not detail output format, but for a zero-parameter list tool this is acceptable.

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

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

The entire description is one concise sentence that front-loads the main action and includes a useful behavioral note. No filler 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 parameterless, read-only list tool, the description sufficiently states what it returns (projects) and why it matters (valid values for the project parameter). No output schema exists, but the description covers enough 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?

The tool has zero parameters, so the baseline is 4 and there is no need to explain parameter syntax. The description still adds value by clarifying the meaning of the 'project' parameter used by sibling tools.

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

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

The description uses a specific verb and resource: it lists projects in the collection. It also adds the unique purpose of marking which projects are valid for the 'project' parameter of other tools, which clearly distinguishes it from siblings like repo_list or commit_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 implies the tool should be used before other tools to discover valid project values for their project parameter. It gives clear context but does not explicitly state when not to use it or name alternatives as 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?

Sem anotações, a descrição precisa carregar o comportamento. Ela revela que se trata de uma operação de escrita que exige confirmação ('Escrita: write + confirm') e delimita o que a ferramenta não faz. Isso adiciona contexto além do schema, embora não detalhe efeitos colaterais ou permissões.

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

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

Duas frases curtas e diretas, com a ação principal e as restrições apresentadas no início. Não há redundância ou conteúdo desnecessário.

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

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

A descrição é suficiente para o uso básico, mas não há output schema e a ferramenta tem 8 parâmetros. Faltam detalhes sobre o retorno da operação, validações de confirmação e como o agente deve lidar com o campo confirm obrigatório. Ainda assim, o essencial para uma chamada simples está presente.

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?

Com cobertura de schema de apenas 38%, a descrição ajuda ao mapear os campos editáveis (título, descrição, rascunho, branch), mas não explica parâmetros obrigatórios como repo e prId nem aprofunda o papel de confirm. O schema já documenta target, isDraft e project, então a descrição cobre parcialmente a lacuna.

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

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

A descrição usa o verbo 'Edita' com o recurso PR e especifica os campos afetados (título, descrição, rascunho, branch de destino). Diferencia-se de operações de status ao afirmar explicitamente que abandonar e mergear não passam pela ferramenta.

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

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

A frase 'NÃO altera status: abandonar e mergear não passam por aqui' estabelece uma condição clara de quando não usar a ferramenta. Não nomeia alternativas específicas, como pr_create ou pr_add_reviewers, mas o escopo de uso fica bem delimitado.

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 no annotations, the description must carry behavioral information, and 'Leitura' does state that this is a read operation. It does not disclose auth requirements, result shape, or whether the default project applies when omitted, though the schema partially covers the default.

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 entire description is two short sentences with no filler; purpose and safety trait are front-loaded. Every word contributes.

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

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

Given the tool's low complexity and full schema coverage for its only parameter, the description covers the core use case completely. It could be improved by an explicit note about which sibling to use for projects or write operations, but those are inferable.

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 optional parameter is already fully described in the schema, including the default and the allowlist condition, so the description does not need to add parameter detail. It adds no extra semantic value beyond 'do projeto', consistent with the high schema coverage baseline.

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 exact operation ('Lista'), the resource ('repositórios'), and the scope ('do projeto'), which is enough to distinguish it from sibling tools like project_list and pr_list. The explicit read-only label reinforces its role.

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: call it to read a project's repositories. It names no alternatives or exclusion criteria, so the agent must infer when to choose this over project_list or pr_list.

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

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

The description discloses that this is a write operation requiring confirmation ('Escrita: write + confirm'), which is behavior beyond the schema. It also mentions the upload and AttachedFile relationship. However, with no annotations, it leaves out side effects, permission details, and irreversibility, so it only partially carries the burden.

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 minimal and front-loaded: one sentence states the core purpose, followed by a short tag for the write/confirm behavior. There is no filler or redundant content.

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

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

For a write operation with five parameters, two required, and no output schema, this description is too sparse. It omits rationale for the confirm flag, project allowlisting implications, return values, and enough parameter detail to ensure correct invocation.

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

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

Schema description coverage is only 40%, and the tool description does not explain the id, comment, confirm, or project parameters. It only indirectly mentions 'confirm' and 'upload' (implying filePath), failing to compensate for the large undocumented portion of 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 a specific action ('attaches a local file to a work item') and resource ('work item'), and even explains the mechanism ('upload + AttachedFile relationship'). This distinguishes it from sibling tools like wit_link or wit_create.

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 wit_link or wit_create. It does not state prerequisites, when not to use it, or any exclusion conditions. An agent would have to infer usage solely from the tool 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?

With no annotations, the description carries the burden of disclosing behavior. It does disclose that this is a write operation requiring confirmation ('Escrita: write + confirm') and that it falls back to System.History. But it omits side effects, permission needs, idempotency, and failure behavior beyond the fallback.

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 compact: one action sentence plus a short confirmation flag. There is no filler, and the core purpose is front-loaded.

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

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

For a write tool with no annotations and no output schema, the description provides the essential action, the API fallback, and the confirmation requirement. Still, an agent is left without a description of the response, return value, or exact failure semantics, 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 only 25%, but the prose adds meaning by clarifying that 'confirm' gates the write operation. The 'id' and 'text' parameters are self-explanatory from their names, yet the description adds no constraints such as text length or formatting. The project parameter's default and allowlist requirement are already in the schema.

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

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

The description states a specific action and resource: 'Publica comentário na discussão do work item' (publishes a comment in the work item discussion). It also names the underlying API and fallback, which helps distinguish it from read-oriented siblings like wit_comments and from pr_comment.

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 to post work item comments rather than PR comments. However, there is no explicit when-to-use or when-not-to-use guidance, nor does it compare itself with alternatives such as wit_update or pr_comment.

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 no annotations provided, the description carries the behavioral disclosure burden. It explicitly signals a safe read-only operation with 'Leitura' and hints at the response content (author, date, text). However, it omits pagination, ordering, and any auth or rate-limit context, making the disclosure only partially complete.

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 and front-loaded: it opens with the verb and object, then adds an explicit read-only label. Every word contributes; the slight redundancy between 'Lê' and 'Leitura' is acceptable because it adds an unambiguous safety signal.

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 tool, the description covers the main action and some return fields, but it does not explain the semantics of `top` or distinguish this tool from its siblings. Since there is no output schema, the author/date/text hint partially compensates but does not fully complete the picture.

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 only documents `project` (33% coverage), and the description does not explain `id` or `top`. The phrase 'work item' loosely ties `id` to the resource, and the read intent hints that `top` is a limit, but this is implicit rather than explicit. The description under-compensates for the schema coverage 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 action and resource: 'Lê a discussão de um work item' ('reads a work item's discussion') and reinforces its read-only nature with 'Leitura.' It does not explicitly differentiate from siblings like wit_comment or wit_get, so it does not reach a 5.

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

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

No guidance is given about when to use this tool over wit_comment, wit_get, or wit_query. The description only implies a discussion-reading use case and offers no exclusions, prerequisites, or alternative routing conditions.

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 no annotations, the description carries the burden of behavioral disclosure. It does disclose that the tool performs a write and requires a confirmation flag, which is valuable. Still, it does not mention what happens on success, whether creation is atomic, or potential side effects such as generated links or validation failures.

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 compact sentence that front-loads the core action and then adds the essential write-mode requirement. No filler or redundant restatement of the schema.

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

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

Given the tool's complexity (10 parameters, nested relations, no output schema, no annotations), the description covers the core purpose and a key prerequisite but leaves out important behavioral context like return value, error behavior, and creation semantics. The schema fills some gaps, but the description alone is not fully sufficient.

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

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

Schema coverage is only 40%, but the description maps several parameters to plain concepts: 'campos, tags, área, iteração, pai e links' correspond to fields, tags, areaPath, iterationPath, parentId, and relations. This adds some meaning, but confirm, title, and tags semantics remain unexplained, so compensation is only partial.

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

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

The description begins with a clear verb ('Cria') and resource ('work item'), enumerating the item types and the main action dimensions (fields, tags, area, iteration, parent, links). It is immediately distinguishable from sibling tools like wit_update, wit_link, and wit_query.

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 explicitly states that this is a write operation and requires ADO_MODE=write and confirm:true, giving the agent actionable invocation conditions. However, it does not explicitly contrast with alternatives such as wit_update or wit_link, so it stops short of full when-to-use/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?

With no annotations, the description carries the behavioral burden, and it does add a clear read-only signal ('Leitura'). However, it does not mention response shape, limits (max 200 ids), historical asOf semantics, or the project allowlist requirement, leaving much of the behavior implicit.

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 carry the core message with no filler, and the most important information (details by ID) is front-loaded. 'Leitura' is a worthwhile standalone addition given the absence 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?

The schema supplies strong parameter documentation, and the description adds the read-only scope and the optionality of fields/relations. No output schema exists, but the only meaningful missing context for invocation is an explicit statement of return shape; the core calling contract is otherwise discoverable.

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 80%, so the schema already explains most parameters. The description adds only the general idea that fields and relationships are optional, which is helpful but does not materially extend the schema's own descriptions of expand, fields, asOf, and project.

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 ('Detalha'), a concrete resource ('work items'), and the selection key ('por id'), while also noting optional fields and relations. This distinguishes wit_get from siblings like wit_query (search) and wit_tree (hierarchy), and 'Leitura' separates it from create/update 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 the tool is for reading a known work item by ID and optionally expanding fields/relations, which gives an agent a hint of when to call it. It does not explicitly name alternatives such as wit_query for searching or wit_history for historical changes, nor does it state when not to use wit_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?

With no annotations, the description carries the burden of disclosing behavior. It does state 'Leitura' (read-only), which is valuable, and 'campo a campo' indicates per-field history granularity. However, it does not disclose output shape, ordering, or pagination behavior.

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

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

The text is very short and front-loaded with the action and resource. The final 'Leitura.' is slightly redundant with 'Lê', but it usefully reinforces the read-only nature.

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?

There is no output schema, yet the description does not explain return values, revision order, or how 'top' interacts with paging. For a history tool, this leaves the agent without enough context to anticipate the result.

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

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

Schema coverage is only 33%, and the description does not compensate. It does not explain that 'id' is the work item identifier or that 'top' caps the number of returned revisions; only 'project' is described in the schema.

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

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

The description states a specific verb and resource: reads the revision history of a work item, field by field. This distinguishes it from siblings like wit_get or wit_comments, though it does not explicitly name an alternative.

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

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

No guidance is given on when to use this tool instead of wit_get, wit_comments, or other siblings. The usage context is only implied by the word 'histórico'.

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 no annotations, the description carries the behavioral disclosure burden. It does state 'Escrita: write + confirm', signaling a mutating operation that expects a confirmation flag—useful safety context. However, it does not mention whether existing links are appended or replaced, permission requirements, or side effects, so the disclosure is only partial.

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 clauses: it front-loads the operation and resource, enumerates the link types, and ends with a behavioral note. There is 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?

This tool has 10 parameters, no annotations, and no output schema, yet the description is only a high-level summary. It does not explain how rel interacts with targetId, url, artifactValue, or repo, nor does it mention the project allowlist rule or the exact confirmation workflow. An agent would have to rely heavily on the schema and inference to call this tool correctly.

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

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

Schema description coverage is 60%, leaving four parameters without descriptions. The tool description adds semantic grouping to the rel values (e.g., hierarchy, related, dependency) and names the artifact categories, which helps interpret the schema. Yet it contributes no meaning for the undocumented parameters like expectedRev or comment, so compensation 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 has a clear verb ('Cria link') and resource ('em um work item') and lists the full range of link types (hierarchy, related, dependency, duplicate, hyperlink, code artifacts). This immediately differentiates wit_link from wit_unlink, wit_create, and wit_update, so an agent knows exactly what this tool does.

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

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

The description implies usage through the link-type enumeration, but it does not state when to prefer this tool over alternatives like wit_unlink for removing links or wit_create for creating work items. No explicit exclusion or alternative routing is provided, leaving usage to inference.

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

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

There are no annotations, so the description carries the full behavioral burden. It explicitly states 'Leitura' (reading), clearly signaling a non-mutating, safe operation. It also implies the tool returns metadata rather than performing work-item changes, which is valuable 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 compact and front-loaded: it states the resource, lists the supported kinds, gives a concrete usage directive, and notes read-only behavior in just two sentences. There is minimal waste, even though the kind list partially duplicates the schema enum.

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 metadata lookup with four parameters, the description provides the essential information: what kinds of metadata exist, when to call it, and that it is safe. There is no output schema, but the return value is reasonably inferable from the requested kind. A minor gap is the lack of detail about what each kind returns.

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

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

Schema description coverage is 75% and all parameters have useful descriptions or enums in the schema itself. The description adds little beyond repeating the kind enum, but because the schema already documents parameters well, a baseline 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 identifies the resource as process metadata and enumerates the supported kinds ('types | states | fields | categories | relationtypes | areas | iterations | tags'). It also states the intended role ('Use antes de criar/atualizar para descobrir tipos, estados e campos válidos'), making it distinguishable from the query/get/create 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 gives explicit usage context: 'Use antes de criar/atualizar para descobrir tipos, estados e campos válidos.' This tells an agent when to call the tool. It does not name alternatives or exclusions, but for a metadata lookup the primary routing cue is the before-create/update 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?

With no annotations, the description carries the full burden; 'Leitura' is a useful read-only signal. It does not, however, mention output shape, pagination behavior, project allowlist requirements, or any other runtime behavior beyond read-only.

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 compact sentence plus the two-word safety qualifier 'Leitura.' It is front-loaded and every word contributes 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?

The description gives enough to understand the tool's core purpose and read-only nature, and the schema covers parameters. Still, with no output schema and no annotations, an agent is left without guidance on return defaults, pagination, or project restrictions when selecting 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 71%, so the schema already explains most parameters. The description groups wiql, preset, and queryId into three mutually exclusive query modes, which adds a little semantic structure, but it adds no detail for top, expand, fields, or project.

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 the specific verb 'Busca' (searches) with the resource 'work items' and lists three concrete query mechanisms (WIQL, preset, saved query). 'Leitura' clarifies this is a read operation, but no sibling tool is named, so differentiation is implicit rather than 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 intended use is implied: it is for searching work items through WIQL, presets, or saved queries. However, the description never says when to prefer this over wit_get, wit_tree, or other sibling tools, nor does it state 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?

No annotations are provided, so the description carries the full burden. It explicitly states 'Leitura' (read-only), which is the key behavioral trait for this tool, and it describes the returned object as a tree. It does not mention auth, rate limits, or error behavior, but for a simple read-only query tool the disclosure is adequate.

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 that front-loads the action and resource, states the return shape, and closes with the read-only note. Every element earns its place with no redundancy.

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

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

For a tool with one required parameter and no output schema, the description gives the purpose, return shape, and read-only behavior. It leaves exact output formatting to inference, but the core information needed to select and call the tool is present.

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 50%, and the description adds useful meaning for 'wiql' by emphasizing hierarchy and the epic → feature → item result. However, it does not compensate for 'top' or 'fields', whose semantics are only implied by their names and schema types.

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

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

The description states a specific verb and resource: 'Executa WIQL de hierarquia (FROM WorkItemLinks)' and names the exact return shape, 'árvore epic → feature → item'. This clearly distinguishes wit_tree from siblings like wit_query, which would handle flat WIQL executions.

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 makes the usage context explicit: this tool is for hierarchical WIQL queries over WorkItemLinks and returns a tree. It does not name alternatives or state when not to use it, so it stops short of a 5, but the context is unambiguous.

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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It does disclose that this is a write operation requiring confirmation ('Escrita: write + confirm') and that the relationship index is resolved at write time. However, it does not explain side effects, permissions, reversibility, or what confirmation actually entails, leaving significant behavioral gaps.

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

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

The description is very short and front-loaded with the primary action. The second sentence is compact and adds relevant write/confirm context, though 'Escrita: write + confirm' is cryptic enough that it may confuse rather than clarify. Still, there is no wasted 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?

For a 7-parameter write tool with no annotations and no output schema, this description is under-specified. It does not explain how the target link is identified (via url, targetId, or rel), what confirm means in practice, what expectedRev controls, or what the agent should expect after success. The only non-obvious context is the relationship-index resolution note, which is itself vague.

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

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

Schema description coverage is only 29%, so the description must compensate, but it barely does. The phrase 'resolvendo o índice da relação' gives some meaning to relationship resolution, and 'write + confirm' touches on confirm, but id, url, targetId, and expectedRev are left unexplained. Required parameters like id and rel are not semantically elaborated beyond their raw schema definitions.

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 opens with a specific verb and resource: 'Remove um link de um work item' (remove a link from a work item), so the core action is unmistakable. It is distinguishable from sibling tools like wit_link and wit_update, though it does not explicitly name them. The extra phrase about resolving the relationship index adds nuance but does not obscure the purpose.

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

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

The description clearly communicates the context for use: an agent should call this when a link needs to be removed from a work item. It does not explicitly compare itself to wit_link or state exclusions, so it falls short of a 5, but the intended usage is directly inferable from the verb and object.

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 no annotations, the description itself must disclose behavioral traits. It does label the operation as a write requiring confirmation ('Escrita: write + confirm') and notes batch capability, but it does not describe what confirm does, whether updates merge or replace existing fields/tags, or how expectedRev affects writes.

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 operation; there is no filler. The second fragment 'Escrita: write + confirm' is cryptic and mixed-language, so the structure is efficient but slightly unclear.

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 8 parameters, nested objects, batch behavior, and no output schema or annotations, this description is underspecified. An agent lacks enough information to safely construct a call, especially around confirm semantics, id/ids selection, and tag/field update behavior.

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

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

Schema description coverage is only 38%, so the description needs to compensate. It names the updated entities (fields, state, tags) and hints that confirm is part of the write, but it leaves key semantics unexplained: singular id vs ids, nested tags add/remove behavior, and what confirm=true/false actually does.

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

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

The description states a clear action ('Atualiza') and a specific resource ('campos, estado e tags de um ou mais work items'), so an agent knows what the tool changes and that it supports single or batch targets. It does not explicitly contrast with sibling mutators like wit_link or wit_create, so it stops short of full sibling differentiation.

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

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

No guidance is given for when to prefer this tool over wit_query, wit_create, wit_link, or other siblings. The only contextual hint, 'Escrita: write + confirm', alludes to confirmation but does not state conditions or alternatives.

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