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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It communicates that the tool modifies integration configuration but omits key behavioral traits such as whether the config object is merged or replaced, whether the integration must already exist, whether the operation is idempotent, or whether any authorization is required. This is a significant transparency gap for a mutation tool.

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

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

The description is a single, front-loaded Spanish sentence that states the core action and examples with no filler. Every word contributes to meaning, making it highly efficient for an agent to parse.

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

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

With no output schema and no annotations, the description leaves the return value and side-effect severity unspecified. For an operation that can update sensitive integration credentials like tokens and endpoints, the lack of any statement about overwrite vs. merge behavior or success/error outcomes leaves an agent uncertain about the consequences of 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 input schema provides 100% parameter description coverage, so the schema fully documents tree_id, integration_key, enabled, and config. The tool-level description adds no extra parameter-specific meaning, matching the baseline score for high schema coverage.

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

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

The description uses specific verbs ('Activa, desactiva o actualiza') and clearly identifies the resource: configuration of an external channel/integration, with concrete examples (whatsapp, telegram, webchat). This inherently distinguishes it from the read-only sibling tool treeflow_list_integrations.

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

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

The description implies when to use the tool—when a channel/integration needs to be activated, deactivated, or reconfigured—but it does not explicitly state when not to use it or mention alternatives such as treeflow_list_integrations for reading current configurations. Usage guidance is present only by 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It usefully reveals that the backup includes intents, canvas, and configuration, but it does not mention side effects, authentication needs, asynchronous behavior, retention, or whether an existing backup is overwritten. Some behavior is disclosed, but not all.

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

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

One sentence, front-loaded with the action, and every part earns its place: the verb, resource, scope, and timing condition. No redundant or filler 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?

Overall the description is largely complete for a simple two-parameter creation tool: it explains what is captured, why, and when to use it. However, it does not mention what the call returns, how to verify the backup, or that backups can later be found via treeflow_list_backups. These are minor gaps, not critical for invoking the tool correctly.

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

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

Schema description coverage is 100%, so the parameters are already well documented. The description does not add meaning beyond the schema; the parenthetical content refers to what is backed up, not to the parameters. The relationship between 'bot actual' and the required tree_id could be clearer but is inferable.

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 ('Crea') and a clear resource ('respaldo/snapshot completo del bot actual'), and further specifies scope with the parenthetical '(intents, canvas, configuración)'. This clearly distinguishes the tool from sibling CRUD and 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 explicitly states when to use the tool: 'antes de realizar cambios masivos'. It does not name alternatives or exclusions, but the intended trigger is clear and sufficient for an agent to decide when this backup tool is appropriate.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden. It says 'creates' but does not disclose what is returned, whether uniqueness or naming rules apply, what happens on duplicate names, or if any side effects occur in the canvas/tree.

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, front-loaded sentence communicates the core purpose with zero filler. It is appropriately concise for a simple create operation.

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 input schema fully documents parameters, and the tool is simple, but the description lacks usage guidance, return-value expectations, and behavioral caveats. It is minimally viable but leaves several gaps an agent would need to handle.

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 100%, so the baseline is 3. The description does not add parameter-level meaning beyond the schema; the only addition is clarifying that a branch is a canvas flow, which is minor context.

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

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

The description states a specific verb ('Crea') and resource ('nueva rama / flujo del canvas') with the context 'dentro de un bot'. This clearly distinguishes it from sibling update, delete, and list branch 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 no guidance on when to use this tool versus alternatives, nor any prerequisites or constraints. It only states what the tool does, leaving usage decisions 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action and the three entity types but says nothing about side effects (e.g., whether entity creation triggers retraining, which matters given a separate treeflow_trigger_training sibling), duplicate-name behavior, 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?

A single front-loaded sentence that names the verb and resource first, then adds the type enumeration in a parenthetical. It is efficient with no filler, though the parenthetical slightly crowds the sentence; a bulleted breakdown of the three modes could have been clearer without being longer.

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 type-dependent parameter requirements (regex needs pattern; simple/composite need values), no output schema, and no annotations, yet the description does not explain these conditional requirements, the return value, or post-creation behavior like retraining. The schema partially compensates, but for an NLU creation tool with conditional validation, the description leaves meaningful 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 100%, so the schema already documents all five parameters, including the type enum with default and the role of pattern and values/synonyms. The description adds only a light synthesis (simple maps to synonyms, regex maps to pattern) rather than new parameter meaning, matching the high-coverage baseline of 3.

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: 'Crea una nueva entidad NLU' (creates a new NLU entity). It further enumerates the three supported kinds — simple with synonyms, composite, or regex — which clearly distinguishes it from siblings like treeflow_update_entity, treeflow_delete_entity, and treeflow_list_entities.

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 use case is implied by the verb 'create' and the resource 'entity', and the surrounding CRUD sibling set makes the create-vs-update-vs-delete distinction inferable by naming convention. However, the description never explicitly says when to use this tool instead of treeflow_update_entity or treeflow_create_intent, and it gives no exclusions or 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?

No annotations are provided, so the description carries the full behavioral disclosure burden. It only says 'creates or adds' and does not mention whether calls are idempotent, whether a valid tree_id is required beforehand, what side effects occur, or what happens on duplicate creation. This is a meaningful gap for a mutating tool.

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

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

The description is a single concise sentence with the key action and resource front-loaded. It is efficient, but the redundant 'nueva ... adicional' and the slash-separated 'herramienta / fertilizante' create slight ambiguity.

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 required parameters, a nested config object, no annotations, and no output schema. The description does not explain return values, validation rules, the necessity of an existing tree, or how the config object should be structured beyond generic hints. This is incomplete for a creation tool with non-trivial inputs.

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 100%, so the baseline is 3. The description adds minimal extra parameter meaning beyond repeating the fertilizer_type examples already present in the schema; it does not explain config structure beyond what the schema provides.

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 clear action ('Crea o agrega') and resource ('herramienta / fertilizante') and gives concrete examples of fertilizer types, so an agent can tell this creates a fertilizer resource. It loses a point because the synonym 'herramienta / fertilizante' is slightly ambiguous and could overlap conceptually with the sibling integration 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 usage context is implied: this tool is for adding a new fertilizer/automation/external_api/knowledge_base. However, it never explicitly states when to prefer this over alternatives like treeflow_configure_integration or treeflow_create_* tools, and there are no exclusions or when-not-to-use 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?

No annotations are provided, so the description bears the full burden. It states it creates an intent with patterns and slots, but does not disclose important behavior such as whether the intent is immediately active, whether unique names are enforced, whether referenced entities must already exist, or whether training must be triggered separately. For a write operation, this is a notable 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 a single, focused sentence that front-loads the core action ('Crea una nueva intención NLU') and then adds the key components (patterns and slots). There is no fluff or wasted wording.

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 basic purpose and key concepts, and the schema covers all parameters. However, because there is no output schema and no annotations, important contextual details are missing: what happens after creation, whether training is needed to activate the intent, and how uniqueness or validation is handled. The sibling tools for training suggest this context is relevant.

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 100%, so the parameter descriptions already document tree_id, name, type, patterns, and entities. The tool description adds illustrative examples of slot values (fecha, cantidad, tipo_habitacion) and clarifies that patterns means training phrases, but it does not add substantially more meaning beyond the schema.

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

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

The description clearly states the tool's action: creating a new NLU intent with training phrases (patterns) and required parameter slots. It distinguishes the intent-creation tool from sibling tools like treeflow_create_batch or treeflow_create_leaf by specifying the exact resource type.

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 tool's context obvious: it is for creating an intent, as opposed to listing, updating, or deleting intents. While it does not explicitly mention alternatives, the clear creation scope and resource-specific language provide enough contextual 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?

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It reveals that the operation creates a new node, but it does not disclose side effects, prerequisites like existence of the branch, validation behavior, or return/error semantics. For a mutating tool this is a noticeable gap beyond the basic create action.

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

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

The description is a single concise sentence that front-loads the core operation and the list of supported types. There is no filler or redundant content that detracts from 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?

The schema already documents all parameters, and the description establishes the core purpose and supported types. However, with no output schema and no behavioral annotations, the agent is left to guess about return values, errors, or any side effects. This is moderately complete for a simple create operation but misses some 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?

The input schema provides descriptions for all four parameters, giving 100% schema coverage, so the baseline is 3. The description only repeats the leaf_type values already present in the schema and adds no extra meaning for config or canvas_position. It does not compensate beyond the schema.

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

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

The description states a specific action ('rea un novevo nodo') and a specific resource ('leaf dentro de una rama'), and it lists supported leaf types. This clearly distinguishes it from sibling tools like create_branch, update_leaf, or delete_leaf. An agent can understand exactly what the tool does witout opening the schema.

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 purpose statement makes it clear that this tool is for creating a new leaf node inside a branch, so its usage context is implied. However, it does not explicitly contrast it with alternatives such as update_leaf or list_leafs, and it does not mention when not to use it. The guidance is adequate but left 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?

Without annotations, the description carries the full burden of behavioral disclosure, but it only states that the tool creates a template. It does not mention side effects, required ownership of tree_id, validation behavior, idempotency, or what happens after creation (e.g., whether the template is immediately available). This is minimal for a mutation tool.

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

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

The description is a single, concise sentence with no filler or repetition. It front-loads the primary action and resource, then adds relevant detail about the kinds of messages supported. It earns its place and remains 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?

Given that there is no output schema and no annotations, the description is thin for a tool with five parameters and a complex nested responses structure. It lacks guidance on expected return values, required parameter relationships (e.g., whether tree_id is validated), or common pitfalls. The schema covers parameter names, but the overall context for using the tool correctly is incomplete.

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

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

Schema description coverage is 100%, so the schema already documents all parameters, including detailed examples for the responses array. The description adds little beyond a high-level mention of rich formats, which is redundant with the schema. The baseline of 3 applies because the structured schema handles parameter semantics well.

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

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

The description clearly states the verb 'Crea' (creates) and the resource 'plantilla de mensaje (MessageTemplate)', making the tool's purpose obvious. It also hints at the tool's scope by listing supported rich response types (texto plano, botones, tarjetas, carruseles, audios), which helps distinguish it from other creation tools like create_tree or create_leaf.

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 use when creating a new message template, but it does not provide explicit guidance on when to use this tool versus update_message_template, list_message_templates, or delete_message_template. There is no exclusionary language or mention of alternatives, leaving the agent to infer when this tool is appropriate.

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

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

No annotations exist, so the description carries the full burden. It clearly states the write action (creates) and the target scope, but discloses no behavioral context such as whether a root structure is created, duplicate-name handling, required permissions, or what the call returns. Minimal side-effect 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?

A single, front-loaded sentence with no filler; every word contributes. It is appropriately compact, though it sacrifices behavioral nuance 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 simple create tool with all parameters documented, the description is minimally sufficient for invocation, but without an output schema or annotations it omits return-value and side-effect information and any operational caveats. It is adequate but has clear gaps.

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

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

The input schema covers 100% of parameters with per-field descriptions, including the default for primary_language and allowed purpose values. The description itself adds no parameter-level meaning beyond the schema, so the baseline score of 3 applies.

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

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

The description uses the verb 'Crea' with a clear resource 'nuevo bot (árbol)' and scopes it to the Treeflow workspace. This clearly distinguishes it from sibling create tools like create_branch or create_leaf by explicitly naming the top-level bot/tree entity.

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

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

No explicit when-to-use or when-not-to-use guidance is provided; the distinction from alternatives is only implied by the parenthetical '(árbol)' and sibling names. It does not direct the agent away from update_tree, create_branch, or other create tools when conditions differ.

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 present, so the description carries the full burden of behavioral disclosure. It states the side effect of creating or inviting a user and constrains the role, but it does not describe whether an invitation is sent, whether existing usernames/emails cause errors, whether the action is reversible, or what response to expect. The 'or' ambiguity further obscures the actual behavior.

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

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

The description is a single focused sentence with no unnecessary filler. It loses one point because the ambiguous 'invita o crea' phrasing packs two possible behaviors into one short sentence, reducing clarity despite the concise length.

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

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

For a simple four-parameter creation tool with full schema coverage, the description provides a usable minimum: what is created, where, and with which roles. However, because there is no output schema and no annotations, important operational details such as invite-versus-create behavior, response format, and error handling are left unspecified.

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 already covers all four parameters with descriptions, and the description essentially echoes the role values while adding workspace context. This meets the baseline for full schema coverage but adds little semantic 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 identifies the resource (user) and the action (invite or create) within a workspace, and it specifies the allowed roles. It is distinguishable from sibling tools like treeflow_update_user and treeflow_list_users, though the dual phrasing 'invita o crea' introduces some ambiguity about which operation actually occurs.

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 this tool when a new workspace user needs to be added. However, it does not explicitly contrast this with treeflow_update_user, nor does it explain when 'invite' behavior applies versus 'create' behavior.

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 behavioral disclosure burden. It does reveal a key non-obvious behavior: deletion is cascading, removing all associated nodes. This is valuable context for a destructive tool, though it does not explicitly mention irreversibility or any authorization requirements.

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

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

The description is a single, short, front-loaded sentence. It states the action verb first and uses every word to convey the operation and its scope, with no filler or redundant 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 two-parameter destructive tool with no output schema, the description is largely complete: it identifies the resource, the action, and the cascading effect. It falls slightly short by not clarifying whether the deletion is permanent or what exactly counts as 'nodos asociados', but it is sufficient for an agent to select and invoke the tool correctly.

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

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

Input schema coverage is 100%, with clear descriptions for tree_id ('ID del bot/árbol') and branch_id ('ID de la rama a eliminar'). The tool description adds no additional parameter meaning beyond what the schema already provides, so the baseline score of 3 applies.

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

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

The description 'Elimina una rama y todos sus nodos asociados' clearly identifies a specific verb (elimina), a resource (rama), and the scope of the action (all associated nodes). This distinguishes it from sibling delete tools like delete_leaf or delete_intent, and from branch create/update/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?

No explicit when-to-use guidance or alternative tools are mentioned. The phrase 'todos sus nodos asociados' implies this is the cascading delete for a branch, but the description does not state when to choose it over delete_leaf or warn against misuse. The intended use is inferable from the name and context, but not explicit.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It only states the delete action and does not disclose whether deletion is permanent, whether it cascades to dependent intents or conversations, or whether it triggers retraining. For a destructive operation, this is a significant 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 one short sentence with no filler and gets directly to the action and object. That is an appropriately concise structure for a simple deletion tool, even though the content is thin.

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 and no annotations, the description is too minimal for a destructive operation: it does not explain success/error behavior, side effects, or whether deletion is reversible. The only reason it is not a 1 is that the schema fully documents the two required 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?

The input schema already describes both parameters clearly (tree_id as 'ID del bot/árbol' and entity_id as 'ID de la entidad a eliminar'), and schema coverage is 100%. The description adds no extra parameter-level detail about entity_id format, validation, or how to find valid values, so it does not go 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 uses a specific verb ('Elimina') and a specific resource ('entidad NLU'), so it is not a tautology. It also distinguishes this from sibling delete tools for branches, leafs, intents, message templates, and fertilizers by naming the entity resource. However, it does not clarify the operational scope (e.g., deletion within a particular tree) or how it differs from create/update/list_entity.

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 this tool should be chosen over create_entity, update_entity, list_entities, or the other delete tools. It also omits prerequisites such as obtaining a valid entity_id or checking whether deletion could break references. The intended usage is only implied by the tool name and the one-line desc.

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 of behavioral disclosure. 'Elimina' clearly implies a destructive action, but the description does not state whether deletion is permanent, whether it cascades, whether it requires special permissions, or what happens after deletion. This is a meaningful gap for a delete operation.

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

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

The description is a single active sentence with no filler or redundant content. The core action, resource, and identifier mechanism are all front-loaded. Nothing could be removed without losing information.

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

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

For a simple two-parameter tool with fully described schema parameters, the description plus schema is mostly sufficient to invoke the tool. However, no output schema or annotations exist, and the description omits edge behavior such as what happens if the fertilizer_id does not exist or is not associated with the tree. It is adequate but not richly 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 100%, and both parameters have meaningful descriptions in the schema. The description only adds 'por su ID' and the 'herramienta o fertilizante' label, which does not materially improve on the schema. A baseline of 3 is appropriate because the schema already documents the parameters well.

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 ('Elimina') and names the resource ('herramienta o fertilizante adicional') plus the deletion method ('por su ID'). The resource type is distinct from sibling delete tools (branch, leaf, intent, entity, message template), so it is distinguishable. However, the phrasing 'herramienta o fertilizante' introduces slight ambiguity about what the tool actually deletes.

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, no mention of prerequisites such as needing an existing tree_id and fertilizer_id, and no indication of when this tool should not be used. The agent is left to infer usage from the name and parameters.

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

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

With no annotations, the description carries the full burden of behavior disclosure. 'Elimina' clearly signals a destructive action, but it does not specify whether deletion is permanent, what happens to references to the intent, or if any other side effects occur. It is transparent about the core operation but lacks safety caveats.

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 with no wasted words. It front-loads the action and states the object and scope succinctly. For a simple two-parameter delete operation, this level of conciseness is ideal.

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

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

Given the low complexity (two simple required parameters, full schema coverage, no nested objects, no output schema), the description covers the basics needed to select and invoke the tool. The missing context is mostly about consequences or obtaining the intent_id, which would improve completeness but is not critical for a straightforward delete call.

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

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

Schema coverage is 100%, and both 'tree_id' and 'intent_id' already have descriptive meanings. The description adds no additional parameter context beyond repeating that an intent is being deleted. The schema does the necessary work, so a baseline 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 states a specific action ('Elimina'), the exact resource ('intención NLU'), and its scope ('de un bot'). It clearly differentiates from sibling delete tools like delete_branch, delete_leaf, or delete_entity. An agent can confidently know this tool is for deleting intents.

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 such as treeflow_update_intent or treeflow_list_intents. There is no mention of prerequisites, such as retrieving the intent_id firstvia treeflow_list_intents, or any exclusions. Usage is only implied by the verb 'Elimina'.

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 of behavioral disclosure. It states the destructive action but does not mention reversibility, cascading effects, permissions, or what happens after the deletion, which is important context for a delete operation.

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

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

A single front-loaded sentence communicates the action and the object with no redundant filler. The parenthetical clarification 'leaf' is compact and valuable.

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 one-parameter leaf-delete operation, the purpose and parameter are sufficiently covered for basic invocation. However, with no annotations and no output schema, the description does not disclose the operation's effects or return behavior, 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?

The schema already covers 100% of the single parameter with a description ('ID del nodo a eliminar'), and the tool description adds no additional meaning beyond the schema. Baseline 3 is appropriate given full schema coverage.

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

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

The description uses a specific action verb ('Elimina') and a clear resource ('nodo (leaf) del canvas'), making the tool's function unmistakable. The parenthetical '(leaf)' also helps distinguish it from sibling deletion tools like treeflow_delete_branch.

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 tool type and the word 'leaf' imply when it should be used, and the delete operation is self-explanatory once a leaf_id is available. However, there is no explicit guidance about when not to use it or how it differs from deleting a branch, intent, or other resource.

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 of behavioral disclosure. The description only restates the destructive action ('Elimina') without adding context about irreversibility, side effects on associated resources, or error cases. It adds no behavioral detail beyond what the tool name already implies.

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 short, clear sentence that immediately conveys the operation. It is efficiently front-loaded and contains no unnecessary words or repetition, making it 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?

For a destructive operation with no annotations and no output schema, this description is too sparse. It does not mention consequences, success/failure indicators, dependencies, or any usage context, leaving the agent without enough information to invoke it confidently in a real scenario.

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 100% and the template_id parameter is already described as 'ID de la plantilla a eliminar'. The description does not add any additional parameter semantics, but the schema fully covers it, so the baseline 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 'Elimina una plantilla de mensaje' uses a specific verb (eliminar) and resource (plantilla de mensaje), clearly stating the operation. It distinguishes from sibling tools like list/create/update message templates by the destructive verb, so an agent can identify its purpose without opening the schema.

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 or when to prefer an alternative. The description simply states the action, with no prerequisites, no mention of idempotency, no warnings about when deletion is appropriate. Nothing is provided to help choose between this and related template 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?

No hay anotaciones, así que la descripcion es la única fuente de transparencia. Comunica que la operación es de lectura y que devuelve detalles y turnos, pero no informa sobre formato de respuesta, paginación, orden, manejo de errores ni requerimientos de autenticación. Es suficiente para un getter simple pero no añade contexto conductual rico.

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?

Una sola oración, sin informacion redudante y con el propósito principal al frente. Cada palabra aporta; es concisa y bien estructurada.

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

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

Para un tool de consulta simple con dos parámetros obligatorios y sin esquema de salida, la descripcion indica qué devuelve (detalles completos y todos los turnos) y cómo se identifica la conversación. Faltaría describir el formato exacto de respuesta o el comportamiento cuando no existe la sesión, pero no son vacíos críticos para un getter de este tipo.

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?

La cobertura de descripcion del esquema es 100% y ambos parámetros ya tienen descripciones claras ('ID del bot/árbol' y 'ID de la sesión de conversación'). La descripcion del tool no añade valor semántico más allá del esquema, por lo que se mantiene el nivel base.

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?

La descripción identifica un verbo específico ('Obtiene'), un recurso claro ('detalles completos y todos los turnos de mensaje') y el alcance ('una conversación específica'). Se distingue claramente de herramientas hermanas como treeflow_list_conversations, que listarían conversaciones en lugar de recuperar una en detalle.

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?

El uso queda implícito al indicar que es para una conversación específica, lo que sugiere que debe usarse cuando se necesita el detalle completo en lugar del listado. Sin embargo, no se mencionan exclusiones ni alternativas explícitas como treeflow_list_conversations para el caso de listado.

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. 'Consulta' conveys a read-only intent and the description reveals returned content (status and metrics), but it does not discuss side effects, authentication needs, or behavior when no training exists. This is adequate but not deeply transparent.

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

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

A single, front-loaded sentence with no filler. It states the action, the resource, and the possible output types efficiently.

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

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

For a simple one-parameter read tool with no output schema, the description adequately conveys purpose, required input, and response content. It leaves alternative routing and edge cases implicit, but nothing essential for correctly invoking the tool 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 already covers the sole parameter tree_id at 100% with 'ID del bot/árbol', so the baseline is 3. The description adds only the NLU-training context and does not provide additional format, constraints, or examples 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 uses a specific verb 'Consulta' plus a specific resource 'estado actual del entrenamiento NLU de un bot' and enumerates expected output (en progreso, completado, métricas). This clearly distinguishes it from sibling tools like treeflow_trigger_training (starts training) and treeflow_list_training_history (historical record).

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 word 'actual' implies this is for checking current training status rather than history, but the description does not explicitly state when to use this tool versus alternatives or name any exclusions. Usage context is present but only implied, not directly stated.

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

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

No annotations are provided, so the description carries the burden. The verb 'Obtiene' makes clear this is a read-only retrieval operation, and it specifies what is returned (details, configuration, purpose). It does not mention error cases, permissions, or response shape, but for a simple get-by-ID these are relatively minor omissions.

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

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

The description is a single, concise sentence with no filler. It front-loads the action, resource, returned content, and identifier in a clear and compact way.

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 low-complexity one-parameter tool with no output schema, the description provides a useful high-level summary of the return content and the required ID. It would be stronger if it explicitly differentiated from 'treeflow_get_tree_data' and stated read-only behavior, but it is sufficient for a basic call.

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

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

The only parameter, tree_id, is fully documented in the schema as 'ID único del bot/árbol (UUID)' with 100percent coverage. The description merely restates 'por su ID' and adds no extra meaning about format, constraints, or behavior, so the 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 uses a specific verb ('Obtiene') and resource ('bot/árbol'), and clearly states what is returned: complete details, configuration, and purpose by ID. However, it does not explicitly distinguish itself from the sibling 'treeflow_get_tree_data', so an agent could be unsure which get-tree tool to choose.

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 this tool when you need a tree's complete details, configuration, or purpose by its ID. There is no explicit when-not-to-use guidance or mention of alternatives, and the existence of 'treeflow_get_tree_data' makes some routing guidance desirable.

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. It reveals the read-only nature through 'Obtiene' and notes the aggregate behavior of one call returning complete data. However, it doesn't disclose potential payload size, exact return structure, latency implications, or any authorization requirements, which would be valuable for an unannotated tool.

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

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

The description is a concise single sentence with the key benefit front-loaded ('estructura COMPLETA ... en un solo llamado') followed by a parenthetical list of included components. The 'Ideal para...' phrase is slightly redundant but adds a useful usage cue.

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 adequately conveys what will be returned and when to use it. But without an output schema or annotations, it should provide more explicit return-shape or caveats, such as whether the full structure is paginated or potentially very large. It is sufficient for tool selection but not fully complete for response handling.

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 100%, with tree_id documented as 'ID del bot/árbol'. The description adds no additional meaning to the parameter, so the 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?

States the verb 'Obtiene', the resource 'estructura COMPLETA del bot', and the scope: basic info, all branches, nodes, intents, entities, and message templates. The phrase 'en un solo llamado' and 'todo el bot de una vez' clearly distinguish it from the list_* siblings that cover single resource types, and emphasize its completeness relative to a basic get_tree.

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?

'Ideal para entender todo el bot de una vez' provides a clear when-to-use signal: when the agent wants the full bot structure in a single call. It does not explicitly name alternatives or exclusions, but the context is strong enough for routing.

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 burden of disclosing behavior. It does indicate this is a read operation ('Obtiene') and enumerates the returned configuration fields. It does not mention error conditions, authorization requirements, or the absence of side effects, but for a simple config getter the core behavior is reasonably transparent.

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

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

The description is a single, focused sentence that front-loads the main purpose and then lists the specific configuration details. Every element adds useful information, with no tautology, filler, or repetition of the schema.

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

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

Given the tool's simplicity, one required parameter, and no output schema, the description provides sufficient context: it identifies the operation, the target resource, and the expected return contents. It could be slightly richer by explicitly noting the result is per tree_id beyond the schema, but for a straightforward getter this is essentially 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 100%, with tree_id described as 'ID del bot/árbol'. The tool description adds minimal semantic value beyond the schema, though it does implicitly connect the parameter to the bot whose voice configuration is being retrieved. This matches the baseline for well-documented 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 operation ('Obtiene la configuración de voz del bot') and the specific resource: the bot's voice configuration. It further details the contents (STT/TTS status, model, language, voice, speed), making its purpose unambiguous and easily distinguishable from sibling tools like treeflow_update_voice_config.

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 read-only nature of the tool evident, and the sibling list includes treeflow_update_voice_config, which implies when to use the update counterpart. However, it does not explicitly state conditions for use or contrast itself with the update tool, leaving the agent to infer the appropriate 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?

No annotations are provided, so the description carries the full behavioral disclosure burden. The verb 'Lista' implies a read-only operation, which is helpful, but the description does not disclose additional traits such as whether backups are scoped to a tree, whether any side effects occur, or how results are ordered or 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 sentence with no wasted words. It immediately states the action and the resource, making it easy for an agent 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?

For a simple one-parameter list tool with no output schema, the description and schema provide enough to invoke the tool correctly. It lacks explicit usage context and richer behavioral detail, but the operation is straightforward, so this is a minor gap.

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

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

Schema description coverage is 100%, so the schema already documents tree_id as 'ID del bot/árbol'. The description does not add extra meaning about this parameter, which is acceptable given the schema handles it, but it also does not enhance the agent's understanding of how tree_id filters backups.

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 ('Lista') and a clear resource ('respaldos y snapshots de seguridad del bot'), making the tool's function unambiguous. It also naturally distinguishes this tool from its many sibling list tools by naming backups as the target.

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 this tool should be used when the agent needs to see existing backups, but it does not explicitly state when to use it over alternatives or mention that it is only for reading backups. No when-not-to-use guidance or sibling comparison is 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 no annotations provided, the description is the only source of behavioral information. It clearly indicates a read-only listing operation scoped by tree_id, but it does not disclose return format, ordering, pagination, or any permissions required. This is acceptable but minimal for a simple list tool.

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

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

The description is a single, compact sentence with no filler. It front-loads the core action and object, and the parenthetical clarification earns its place by resolving ambiguity about what 'ramas' means.

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 one-parameter list tool with no output schema, the description adequately defines the resource scope and identifies the required input. It does not describe the output shape, but that is a minor gap for such a simple listing operation.

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

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

Schema description coverage is 100%, so the schema already documents tree_id as 'ID del bot/árbol'. The description adds only a slight contextual hint by referring to 'un bot', but no significant meaning beyond the schema.

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

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

The description uses a specific verb ('Lista') with a clear resource ('ramas... de un bot en Treeflow') and clarifies that branches are canvas flow blocks, which distinguishes it from tree-level and leaf-level tools in the sibling 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 makes it clear the tool lists branches for a given bot, but it does not explicitly state when to choose it over alternatives like treeflow_get_tree_data or treeflow_list_leafs. The usage context is inferable but not directly stated.

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

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

With no annotations provided, the description carries the full burden. It clearly indicates the operation is read-only through 'Obtiene' and outlines the data shape (actor, modified object, timestamp). However, it does not disclose ordering, pagination behavior beyond the limit parameter, or any other operational details, leaving some 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 a single sentence that front-loads the action and target, then expands with the key output dimensions. There is no redundant wording and every part 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 simple two-parameter listing tool, the description plus complete schema is sufficient for correct invocation: pass tree_id, optionally limit, and expect audit records with who/what/when. It could mention ordering explicitly, but this is a minor omission rather than a critical gap.

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

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

The input schema already covers 100% of parameters with clear descriptions: tree_id is the bot/tree ID and limit has a default of 50. The description adds no additional parameter semantics beyond broadly referring to 'del bot', which aligns with tree_id, so the 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 uses a specific verb ('Obtiene') and a precise resource ('historial de auditoría de cambios del bot'), and details the returned information: who modified which node, intent, configuration, or entity, and when. This clearly distinguishes it from siblings like treeflow_list_training_history, which focuses on training history rather than audit 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 implies the tool should be used when an agent needs an audit trail of bot changes, but it does not explicitly state when to use it versus alternatives such as treeflow_list_training_history. There is no misleading guidance, but the routing must be inferred from the phrase 'historial de auditoría'.

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 of behavioral disclosure. It only says 'lists the most recent conversations' without explaining ordering, pagination, response format, side effects, or what 'recent' means. This is minimal behavioral 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, focused sentence with no wasted words. The core action is stated upfront and there is no redundant information. It is appropriately concise for a simple list tool.

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

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

The tool is simple (one parameter, no output schema, no annotations), and the description gives a basic understanding of the action. However, it does not explain what the response contains, how 'most recent' is determined, or that the tree_id is a required filter. These gaps make it minimally adequate rather than 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 coverage is 100% and the parameter 'tree_id' is described as 'ID del bot/árbol'. The description does not add any meaning beyond the schema, so the baseline 3 applies. It slightly reinforces the connection to 'this bot' but provides no additional parameter detail.

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

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

The description states a specific verb ('Lista') and resource ('las conversaciones'), clearly indicating that the tool lists conversations. It is distinct enough from sibling 'get_conversation' which implies retrieving one conversation, though it does not explicitly name that 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?

The phrase 'más recientes' (most recent) gives implied usage context: use this to fetch recent conversations. However, there is no explicit when-to-use guidance, no mention of alternatives, and no exclusions. The usage is implicitly clear but not explicitly stated.

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

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

With no annotations provided, the description carries the full behavioral burden. It clearly indicates a read-only listing operation scoped to the workspace and implies the return content (configured AI providers) and its purpose (checking availability). It does not describe 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?

A single concise sentence that front-loads the verb and resource, immediately states the scope, gives examples, and ends with the intended use. There is no redundant or filler 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 zero-parameter, no-output-schema list tool, the description is largely complete: it names the resource, scope, examples, and purpose. It could optionally mention the exact response shape, but the verb 'Lista' and availability-check purpose make the expected behavior clear enough.

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 no parameter-level detail is needed. The description adds context about what is being listed, which compensates for the empty 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 uses a specific verb ('Lista'), a clear resource ('proveedores de IA configurados en el workspace'), and concrete examples (OpenAI, Gemini, Groq, Twilio, Meta) which distinguish it from siblings like list_integrations and list_users. The stated purpose, 'verificar disponibilidad', further clarifies what the tool accomplishes.

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 'para verificar disponibilidad' gives a clear context for when to use the tool. It does not explicitly mention exclusions or alternatives, but the resource scope is specific enough that an agent can infer when it applies.

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 of behavioral disclosure. It conveys a read-only listing intent and describes the kind of content returned, but it does not mention response format, pagination, or whether hidden/system entities are included. This is adequate for a simple list operation but not deeply transparent.

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

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

The description is a single, dense sentence with no filler. Every element contributes: the action, the resource, the scope, and a clarifying parenthetical definition.

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 tool with one required parameter and no output schema. The description tells the agent what will be listed and for which bot, which is sufficient for invoking the tool correctly. It could mention response shape, but for this complexity level the gap is minor.

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 already documents tree_id as 'ID del bot/árbol' with 100% coverage. The description only reinforces the bot relationship and adds no extra details about format, examples, or constraints, so the 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 names a precise action ('Lista') and resource ('entidades'), and clarifies what counts as an entity with the parenthetical '(valores, sinónimos, expresiones regulares)'. It also scopes the operation to a bot, which distinguishes it from sibling list tools for branches, intents, leafs, and other resources.

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 usage is implied by the resource name and the singular required parameter tree_id, but there is no explicit guidance about when to choose this tool over sibling list tools or when not to use it. An agent can infer the context, but the description does not state exclusions or alternatives.

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

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

No annotations are provided, so the description carries the full burden. 'Lista' clearly indicates a non-mutating enumeration, but the description does not disclose output format, pagination, behavior on invalid tree_id, or any prerequisites. For a simple list operation this is minimally 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 a single concise sentence, front-loaded with the operation and followed by the resource categories. Every phrase contributes meaning and there is no redundancy 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?

Given the low complexity—one required parameter, no output schema, and no annotations—the description provides enough to understand the tool's purpose and scope. It could clarify what the returned list looks like or define 'fertilizantes' further, but the parenthetical and the verb 'Lista' make the core behavior understandable.

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 100% description coverage for tree_id ('ID del bot/árbol'). The description adds no additional parameter-level semantics, examples, or constraints, so it meets the baseline but does not go beyond the schema.

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

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

The description states a specific verb ('Lista') and a specific resource category: additional tools/fertilizers, custom scripts, and Knowledge Base (RAG) configurations for a bot. This distinguishes it from sibling list tools such as treeflow_list_branches or treeflow_list_tegrations, though the 'fertilizantes' metaphor is slightly ambiguous without extra 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 context of the tool is clear: use it to enumerate a bot's additional tools/scripts/RAG settings. However, there is no explicit when-to-use guidance, no mention of alternatives, and no exclusions, so the agent must infer the appropriate situation from the description and sibling names.

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 burden of behavioral disclosure. 'Lista' implies a read-only status retrieval and the examples clarify scope, but the description does not explicitly state that it does not modify anything, what 'estado' includes, or whether any permissions are required.

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 redundant words. The main action and resource are front-loaded, and the parenthetical examples add useful specificity without bloating the text.

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 one-parameter, read-only listing tool, the description provides sufficient context to understand what is returned at a high level: statuses of channels and integrations. It could be richer by describing the output format or the meaning of 'estado', but the low complexity and clear parameter make the tool reasonably complete.

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

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

The input schema already fully describes the only parameter, tree_id, as 'ID del bot/árbol' (100% schema coverage). The description adds no parameter-specific meaning, so the baseline score of 3 applies.

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

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

The description uses a specific verb ('Lista') and a concrete resource ('el estado de los canales e integraciones de terceros'), with clarifying examples. It is clearly distinct from sibling tools like treeflow_configure_integration, which implies configuration rather than listing.

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 this tool when you need the status of channels or third-party integrations. However, the description does not explicitly state when to use it over alternatives, nor does it mention any exclusions or when another tool like treeflow_configure_integration 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 must carry the behavioral burden. It states what is listed and that the result includes training phrases and slots, which is useful. It does not disclose response format, potential pagination, performance implications, or authentication requirements, but for a simple list operation the described behavior is reasonably transparent.

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

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

The description is a single efficient sentence that front-loads the main action and resource, then adds relevant detail about what is included. There is no filler or redundant repetition of the tool name.

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

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

For a low-complexity list tool with one parameter and no output schema, the description adequately communicates what the operation returns. It is missing only perfunctory guidance about usage context, but nothing essential is absent 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 schema already covers the only parameter with a clear description ('ID del bot/árbol'), and schema description coverage is 100%. The description reinforces the 'bot' concept but does not add deeper semantics like format constraints or related terminology.

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 specific action ('Lista') and resource ('intenciones NLU de un bot'), and specifies included details (training phrases and associated parameters/slots). This distinguishes it well from siblings like treeflow_list_entities or treeflow_list_branches.

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 use case is implied: call this when you need all NLU intents of a bot, including training phrases and slots. However, there is no explicit guidance about when not to use it or which alternative to choose, though the tool name and description make the primary purpose fairly 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?

With no annotations provided, the description carries the full burden. It conveys the core behavior (listing leaf nodes within a branch) and implicitly that it is a read-only operation, but does not disclose whether it returns direct descendants only or all nested leaves, nor any error behavior or response format.

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

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

The description is a single, front-loaded sentence with no fluff. Every word contributes meaning, clearly stating the action, object, and scope.

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

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

Given the low complexity of a one-parameter list operation, the description covers the essential purpose. However, with no output schema and no annotations, it lacks details about the return shape and whether nested leaves are included, leaving a moderate information gap for the 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 100% since branch_id has a description ('ID de la rama'). The tool description does not add details beyond the schema, so the baseline of 3 applies because the schema fully documents 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?

The description states a specific verb ('Lista') and resource ('nodos (leafs)') scoped to a branch ('dentro de una rama específica del canvas'). It clearly distinguishes this from sibling list tools like treeflow_list_branches and treeflow_list_trees by naming the leafs and branch scope.

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

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

Usage is implied: call when you need the leaf nodes of a specific branch. However, there is no explicit guidance on when to prefer this tool over alternatives or when not to use it, leaving the agent to infer from 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 provided, the description carries the behavioral disclosure burden. It does add a useful scoping claim: it returns ALL message templates and rich responses configured for the bot, not a filtered subset. However, it doesn't disclose authentication needs, behavior for invalid tree_id, or pagination/return shape. For a simple read-only list operation the burden is moderate, and the scope claim adds real 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?

A single, front-loaded Spanish sentence with zero fluff. The verb comes first and every word contributes either the resource type or the scope. It matches the schema's language, keeping the definition coherent.

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 low-complexity tool (1 required parameter, no enum, no output schema, no nested objects), the description plus schema together give an agent enough to call it correctly: what it returns and the required input. The only minor gaps are return format and pagination details, which are less critical for a simple 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?

Schema description coverage is 100% — tree_id is already documented as 'ID del bot/árbol' in the input schema. The description adds no additional meaning about the parameter, so it meets the baseline 3 without needing compensation.

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?

Identifies a specific operation ('Lista' – list all) and a specific resource (message templates and rich responses) scoped to a Treeflow bot. Among many list_* siblings (list_branches, list_trees, list_intents, list_entities), this clearly targets message templates, and the verb distinguishes it from create/update/delete_message_template.

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

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

Provides no when-to-use guidance or alternatives. The description never states when to choose this over related query tools (e.g., get_tree, list_branches) nor how it relates to the create/update/delete_message_template siblings. Usage must be inferred entirely from the resource 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 has to disclose behavior on its own. It states what data is returned (accuracy, duration, error logs) and 'Obtiene' implies a read-only operation, but it does not mention pagination, ordering, default page size, or any other behavioral constraints, leaving the agent to infer list semantics from the schema.

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

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

The description is one short, front-loaded sentence with no filler. It states the main action and resource immediately and includes relevant output details, earning its place without 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 3-parameter list tool with 100% schema coverage and no annotations, the description conveys the core purpose and result content well. It lacks pagination behavior and a clear tie to the sibling get_training_status, but it is largely sufficient for an agent to select and call the tool correctly.

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

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

Schema description coverage is 100%, so the base rating is 3. The tool description adds no parameter-specific meaning; its detail about metrics, duration, and error logs describes the output, not the input 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 ('Obtiene') and a specific resource ('historial detallado de entrenamientos del bot'), and adds concrete output details (accuracy metrics, duration, error logs). This distinguishes it from training-related siblings like treeflow_get_training_status and treeflow_trigger_training, though the distinction 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 phrase 'historial detallado' implies this tool is for past training runs rather than current status, but there is no explicit when-to-use guidance or mention of alternatives such as treeflow_get_training_status. The agent must infer the choice from the tool name and sibling 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?

With no annotations, the description carries the behavioral burden. It conveys that the operation is a read-only listing of available items in the current workspace, which is useful. It does not disclose return format, pagination, or error behavior, but for a simple list tool this is only a moderate 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?

A single, clear sentence with no filler. The action ('Lista'), object ('todos los bots (árboles)'), and scope ('espacio de trabajo actual') are all front-loaded and immediately understandable.

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 zero-parameter tool with no output schema, the description gives enough to invoke it correctly: it names the resource and workspace scope. Missing details like the exact return structure are minor for a no-input list operation, but would push it to full 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 tool has zero parameters, so the schema provides full coverage and the description does not need to explain inputs. Baseline for a 0-parameter tool is 4, and the description appropriately focuses on the operation rather than parameters.

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

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

The description states a specific verb and resource: 'Lista todos los bots (árboles)', clarifying that 'árboles' means bots. It also scopes the operation to the current Treeflow workspace, which distinguishes it from other list tools for branches, leafs, intents, etc.

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

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

The description implies when to use the tool by naming the resource (trees/bots) and workspace scope, but it does not explicitly state alternatives or when to choose this over sibling list tools. Usage is inferable rather than clearly guided.

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 explaining behavior. It transparently indicates this is a read/list operation and states what is returned (users with roles and statuses). It does not mention response format or any required permissions, but for a zero-parameter list tool the disclosed scope is reasonably 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 a single well-structured sentence that leads with the verb and resource, then adds the useful detail about roles and statuses. There is no filler or redundant repetition of the tool name.

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

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

For a simple, no-parameter list tool with no output schema and no annotations, the description is mostly complete: it states the resource scope and the returned attributes. It could be slightly more explicit about response shape or read-only guarantees, but the core information an agent needs to invoke it correctly 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?

The tool has zero parameters, so there is no parameter ambiguity for the agent to resolve. The description provides the relevant output context by mentioning roles and statuses, satisfying the baseline for tools without 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 a specific action ('Lista') and resource ('todos los usuarios miembros del workspace actual'), and it specifies the included data ('roles y estados'). It is immediately distinguishable from sibling tools like create_user or update_user, since its purpose is enumeration rather than mutation.

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 the list of workspace users, which gives a clear context for use. However, it does not explicitly mention when not to use it or point to alternatives (e.g., create_user or update_user for modifying users). The usage guidance is inferred rather than stated.

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

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

With no annotations provided, the description carries the full disclosure burden and largely meets it: it flags the operation as a test message ('mensaje de prueba'), the session_id parameter describes a simulated chat, and it discloses precisely what is returned — intent with confidence, entities, and the new session state/node. It does not explicitly state whether any persistent side effects occur, a minor gap for a simulation 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?

Two efficiently packed sentences: the first states the action and purpose, the second lists the return values. Since there is no output schema, enumerating the return contract in prose is necessary rather than redundant. There is no filler and the core action 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 moderate-complexity simulation tool with no annotations and no output schema, the description covers the essential contract: what to send, what comes back, and that the session is simulated. Remaining gaps, such as error handling and explicit confirmation of non-persistence, are secondary 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 100%, so all three parameters (message, tree_id, session_id) are already well documented in the input schema. The description adds no param-level meaning beyond what the schema provides, so the baseline of 3 applies.

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

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

The description names a specific action — sending a test message to the bot's console — with an explicit purpose of testing the conversational flow in real time. It also enumerates the return contract (bot response, intent with confidence score, entities, session state), which reinforces what the tool does. None of the sibling tools offer simulation or testing, so it is clearly distinguished from the CRUD operations around 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?

'Para probar en tiempo real el flujo conversacional' provides a clear invocation context: use this when you need to test how a bot conversation behaves. There are no explicit exclusions, but since no sibling tool overlaps with simulation functionality, naming an alternative is less critical; the context alone is sufficient.

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 of behavioral disclosure, and it discloses almost nothing. It doesn't state whether training runs synchronously or asynchronously, whether the call returns immediately or blocks, what happens if a training job is already in progress, or what the caller receives in response. The existence of a get_training_status sibling strongly suggests an async polling workflow, but the description fails to mention it.

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

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

The description is a single, front-loaded sentence with zero wasted words — the action verb 'Inicia' leads, followed by the resource and scope. It earns its place. However, the structure is minimal and could have compactly incorporated behavioral guidance (e.g., async behavior, status polling) without bloat.

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 trigger/mutation tool with no annotations and no output schema, the description must explain what happens after the call, but it does not. The agent is left without knowing whether to expect a job ID, whether to poll treeflow_get_training_status, or how to handle a rejection if training is already running. This is a material gap for a non-trivial operation.

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

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

Schema description coverage is 100%: the only parameter, tree_id, is already documented in the schema as 'ID del bot/árbol a entrenar'. The description adds no additional meaning about the parameter, so the baseline 3 applies. The mention of current intents and entities is behavioral context, not parameter semantics.

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

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

The description states a specific verb and resource: 'Inicia el re-entrenamiento del modelo de Machine Learning y NLU de un bot' — it clearly tells the agent this tool triggers retraining of the bot's ML/NLU model. The scope qualifier 'con las intenciones y entidades actuales' further clarifies what data is used. This distinguishes it cleanly from read-only siblings like treeflow_get_training_status and treeflow_list_training_history.

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

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

The phrase 'con las intenciones y entidades actuales' implicitly suggests the right moment to call it (after intent/entity changes), but the description never names alternatives or gives explicit when-to-use vs when-not-to-use guidance. It doesn't mention, for example, that treeflow_get_training_status should be used to monitor the resulting training, which would help route the agent.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only restates the action. It does not explain that this is a partial update (name and description are individually optional per the schema), whether empty values can clear a field, what happens if neither field is supplied, or what the return behavior is. For a mutation tool, this is a significant transparency 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?

A single Spanish sentence that states the action and affected fields concisely with no filler. It is appropriately front-loaded and efficient, though this brevity comes at the cost of the behavioral and usage detail penalized in other dimensions.

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 no output schema and no annotations, this description is thin. It omits core behavioral facts an agent needs: that it is a partial update, the role of the required tree_id/branch_id identifiers, and what a successful update returns. A simple additional sentence about partial-update semantics would substantially close this gap.

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

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

Schema description coverage is 100%, so the baseline of 3 applies. The description loosely mirrors the schema by mentioning 'name or description' but adds no extra semantics about formats, validation rules, or relationships between parameters. The required identifiers (tree_id, branch_id) are left entirely to 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, 'Actualiza el nombre o descripción de una rama' (Updates the name or description of a branch), uses a specific verb plus a clear resource and ties the update to the specific fields affected. This differentiates it from sibling operations like create_branch, delete_branch, and list_branches, though it relies mostly on the tool name rather than explicit contrast to be 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 given about when to use this tool rather than alternatives such as treeflow_update_tree, treeflow_update_leaf, or treeflow_create_branch. There is no mention of preconditions, required context, or exclusions, leaving an agent to infer the appropriate use case entirely from the name.

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

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

No hay anotaciones disponibles, así que la descripción es la única fuente de transparencia. Indica que la operación es de actualización, pero no aclara si es parcial o total, si reemplaza los valores existentes, si valida el entity_id, ni qué efectos colaterales puede tener. Para una herramienta mutadora, esto es insuficiente.

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?

La descripción es una sola frase directa y sin relleno, con la acción principal al inicio. Comunica el propósito esencial de forma eficiente y no incluye información redundante con el esquema.

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

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

Para una herramienta de actualización con 6 parámetros, sin anotaciones ni esquema de salida, la descripción es demasiado breve. Faltan detalles sobre el comportamiento esperado, el resultado de la operación, el efecto sobre datos existentes y posibles errores. Un agente necesitaría inferir demasiado para invocarla correctamente.

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?

La cobertura del esquema es del 83%, por lo que el esquema ya documenta la mayoría de los parámetros. La descripción añade algo de semántica al listar 'valores, tipo, sinónimos o patrón regex', pero no profundiza en cómo se combinan ni en el significado exacto de las claves dentro del arreglo values. Se mantiene en el nivel base.

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?

La descripción utiliza un verbo específico ('Actualiza') y un recurso claramente identificado ('entidad existente'), y enumera los aspectos modificables: valores, tipo, sinónimos o patrón regex. Se distingue bien de herramientas hermanas como create_entity o delete_entity, aunque omite mencionar el campo 'name' que sí aparece en el esquema.

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?

La descripción no indica cuándo usar esta herramienta frente a alternativas como crear o eliminar entidades, ni menciona prerequisitos. Solo se infiere que debe usarse para actualizar una entidad ya existente, pero no hay orientación explícita sobre condiciones, excepciones o casos de uso.

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 of behavioral disclosure. It only says 'Actualiza' (updates), which is already implied by the tool name, and does not disclose whether updates are partial or full replacements, what happens to unspecified fields, any retraining side effects, or what the return value looks like.

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

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

The description is a single concise sentence that front-loads the action and resource, then lists the modifiable fields. There is no redundant or filler wording.

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 an update tool, the description plus complete schema coverage provides enough to make a valid call: provide tree_id, intent_id, and the fields to update. However, with no annotations and no output schema, it lacks behavioral details like partial-update semantics and side effects, so it is not fully complete.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters. The description adds some conceptual mapping by calling entities 'slots/parámetros' and patterns 'frases de entrenamiento', but it does not add significant new meaning beyond the schema.

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

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

The description uses a specific verb ('Actualiza') and resource ('una intención existente'), and explicitly lists the mutable aspects: nombre, frases de entrenamiento, and slots/parámetros. This clearly distinguishes it from sibling tools like create_intent, delete_intent, and list_intents.

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 'intención existente' implies the tool is for modifying an already-created intent rather than creating one, which provides some usage context. However, it does not explicitly state when to prefer this tool over related alternatives such as update_entity or how it relates to create_intent/delete_intent.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It only states that the tool updates an existing leaf, but does not disclose partial-update semantics, whether at least one mutable field is required, permission requirements, or side effects. This is a significant gap for a mutation tool.

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

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

The description is a single, efficient sentence that front-loads the action and target without unnecessary filler. Every word contributes to the agent's understanding of the tool's purpose.

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

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

For a simple update tool with three parameters and full schema coverage, the description is minimally adequate. However, with no annotations and no output schema, it omits behavioral expectations like whether the node must exist, whether updates are partial or full, 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?

Schema description coverage is 100%, so the schema already documents leaf_id, config, and canvas_position. The description adds a high-level mapping ('contenido, configuración o posición') but does not provide meaningful extra semantics beyond what the input schema already conveys.

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 ('Actualiza') and a clear resource ('nodo (leaf) existente'), and distinguishes the tool from sibling tools like create/delete/list operations by specifying it modifies an existing leaf. The mention of content, configuration, and position makes the scope concrete.

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 this tool is for updating an existing leaf, and the tool name reinforces that. However, it does not explicitly state when to use it over sibling update tools like treeflow_update_user or treeflow_update_voice_config, nor does it provide exclusion 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?

No annotations are present, so the description carries the burden. It discloses that the operation mutates an existing template and can handle plain text or rich blocks, but it does not mention side effects, permission requirements, reversibility, or validation 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?

One short sentence with no filler; the core action and resource are front-loaded. It is concise without being a tautology.

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?

Adequate for a simple CRUD update because all five parameters are documented in the schema. However, the tool has no annotations or output schema, and the description omits usage context and behavioral details, leaving the agent to infer side effects.

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

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

Schema description coverage is 100%, so the baseline is 3. The phrase 'texto plano o bloques enriquecidos' maps to the text and responses parameters, but the schema already labels those as plain fallback text and rich-block arrays.

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 ('Actualiza') and a clear resource ('plantilla de mensaje existente'), and it notes the supported payload forms. 'Existente' separates it from create/delete siblings, though it does not explicitly name the 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?

No guidance is given about when to choose this tool over treeflow_create_message_template or treeflow_delete_message_template; the only implicit signal is 'existente'. There are no prerequisites, exclusions, or alternative recommendations.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It states that this is an update operation but does not mention any side effects, such as whether existing settings are overwritten, whether updates trigger retraining, or whether certain configurations are mutually exclusive. The mention of 'umbrales de confianza' hints at functionality not represented in the schema, adding ambiguity rather than clarity.

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 action verb and lists the key update targets without redundancy or filler. It is appropriately compact for a tool that touches multiple configuration aspects, though it could benefit from a brief structured breakdown given the number of 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?

For an update tool with 10 parameters, one required field, and no output schema or annotations, this description is too thin. It does not state the required tree_id prerequisite, the effect of updates on existing conversations or training data, or what success or failure looks like. An agent would need to inspect the schema and speculate on side effects before calling this tool.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description adds a contextual overview grouping parameters by configuration areas (NLP modes, confidence thresholds, sentiment analysis, purpose), but it does not provide any detail beyond what the schema already conveys. It also references 'umbrales de confianza' which do not map to any visible parameter, creating mild inconsistency.

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 'Actualiza' and clearly identifies the resource ('un bot'), and enumerates the updatable aspects: configuration, NLP modes, confidence thresholds, sentiment analysis, and purpose. It distinguishes itself from sibling update tools (branch, leaf, intent, entity) by targeting bot-level settings, even though it does not name those siblings explicitly.

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 is for updating bot-level settings, and the phrase 'de un bot' provides some context for when this tool is appropriate among the many update siblings. However, it does not explicitly state when to use this tool versus alternatives, nor does it give exclusion criteria or scenarios that would favor a different update 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It identifies what is updated (role or active status) but does not state whether the update is partial or full, what happens if the user_id is missing or invalid, whether permissions are required, or what the response looks like.

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 focused sentence, front-loaded with the resource and the exact fields being updated. There is no wasted wording or unnecessary detail.

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

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

For an unannotated mutation tool with no output schema, the description is too sparse. It omits behavioral expectations such as partial update semantics, error conditions, and response information, and provides no usage guidance beyond the simple action statement.

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 100%, so the schema already documents all three parameters. The description adds a little meaning by explicitly mapping the tool to 'rol' and 'estado activo', but it does not provide additional semantic detail beyond the schema.

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

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

The description states a specific verb and resource: 'Actualiza el rol o estado activo de un usuario existente' (updates the role or active status of an existing user). It clearly names the target resource and the operation, and is distinguishable from siblings like treeflow_create_user and treeflow_list_users, 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?

The phrase 'usuario existente' gives implied usage context: use this for existing users, not for creating or listing users. However, there is no explicit when-to-use or when-not-to-use guidance, nor any mention of alternatives such as treeflow_create_user.

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 disclosure burden. It only states that parameters are updated; it does not reveal side effects, whether the update is partial or full, permission requirements, or impact on active sessions. This is a mutation tool with 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?

A single well-formed sentence that front-loads the action and resource and then compactly lists the key updatable aspects. No wasted words or redundant restatements of the schema.

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

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

With 8 parameters, no output schema, and no annotations, the description should clarify update semantics (partial vs. full), the target requirement (tree_id), and what the response contains. It does none of this, leaving an agent to infer critical invocation 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?

The input schema already describes all 8 properties at 100% coverage, so the baseline is 3. The description adds a useful high-level summary that maps to the parameters, but it does not provide any extra detail beyond what the schema already gives.

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 ('Actualiza' = updates) and a clear resource ('parámetros de voz del bot'), and enumerates the exact capabilities (STT/TTS toggles, voice, language, speed). This makes it immediately distinguishable from the many CRUD siblings and complements the read-only treeflow_get_voice_config.

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 context is implied: use this tool when voice parameters need to be modified. However, it does not explicitly say when not to use it, nor does it reference the alternative get_voice_config for reading current settings. No conditions, prerequisites, 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.