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

No annotations are provided, so the description carries full burden. It discloses key behaviors: creates if not exists, updates if exists, never deletes. No mention of side effects or auth, but sufficient for a config 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 clear structure. No unnecessary words.

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

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

Given no output schema and no annotations, the description is minimal. It does not explain return values, error handling, or prerequisites for using the config file, which is lacking for a moderately complex 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 baseline is 3. The description adds no extra parameter details beyond what the schema already 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 clearly states the tool applies an exported configuration to a destination instance with create/update semantics and never deletes. It distinguishes from siblings like 'b24_compare_configs' and 'b24_read_full_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 does not provide explicit guidance on when to use this tool vs. alternatives. It mentions behavioral traits (never deletes) but lacks context on prerequisites or scenarios.

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

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

No se proporcionan anotaciones, por lo que la descripción debe cubrir el comportamiento. Solo menciona el encadenamiento, pero omite detalles importantes como límites de request, manejo de errores, o qué sucede si una llamada falla. Para una herramienta de lotes, 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?

Dos oraciones concisas y directas. La primera oración expresa el propósito principal, y la segunda añade la característica clave de encadenamiento. Sin redundancia.

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?

Aunque la descripción cubre la funcionalidad central y el encadenamiento, carece de detalles sobre el formato de salida, límites de uso o errores. Dada la complejidad de una herramienta de lotes, sería beneficioso incluir más contexto.

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 descripción añade significado sobre cómo usar $result para encadenar resultados, lo cual va más allá del esquema. Aunque la cobertura del esquema es del 50%, la descripción mejora la comprensión del parámetro 'calls' y su uso.

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 establece claramente que ejecuta múltiples llamadas a la API de Bitrix24 en una sola request HTTP, y menciona la característica única de encadenamiento con $result. Se distingue de las herramientas hermanas que realizan operaciones individuales.

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 implica su uso para ejecutar varias llamadas de forma agrupada, pero no proporciona exclusiones explícitas ni alternativas. Sin embargo, el contexto es claro en comparación con las herramientas hermanas de operaciones únicas.

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 behavioral disclosure burden. It usefully discloses that only active instances are returned and the verb 'Lista' implies a read operation, but it omits any statement about read-only guarantees, pagination, error behavior, authentication, or output shape.

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

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

The description is a single front-loaded sentence with no filler. It states the action, the resource, and the filtering dimensions efficiently.

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

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

The tool has no output schema and no annotations, so the description should compensate by explaining return values and operational context. It leaves webhook_url unexplained and does not describe the structure of the returned instances, pagination, or any call prerequisites.

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 67%: entity and entity_id have descriptions, while webhook_url does not. The description reinforces that entity and entity_id act as filters, but it does not clarify webhook_url's role or the optionality/combination rules for the 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 ('Lista') and resource ('instancias de procesos de negocio activas'), and it states the filtering dimensions. It is clear enough to distinguish from b24_bizproc_start, though it does not explicitly differentiate itself from sibling tools.

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

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

The description implies when to use the tool: to list active business process instances, optionally filtered by entity or record. However, it provides no explicit guidance on when not to use it or what alternatives exist, such as b24_bizproc_start for starting processes.

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 full behavioral burden. It only states 'starts a business process' without disclosing side effects, permissions required, idempotency, return value, or error behavior. This is insufficient for safe tool invocation.

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

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

A single sentence of 12 words that immediately conveys the core purpose. No redundant phrases, well front-loaded, and every word is essential.

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

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

Despite having 4 parameters and no output schema, the description provides minimal context. It does not explain the return value, error conditions, or how to construct the document_id, which is crucial given the nested object example. The tool is complex but the description is too brief.

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 provides descriptions for 3 of 4 parameters (75% coverage), and the description adds no additional semantics beyond the schema. The baseline is 3 per guidelines; the description does not improve or contradict 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 action ('inicia' = starts) and the resource ('proceso de negocio sobre un documento o registro CRM'), making it obvious what the tool does. It distinguishes itself from siblings like b24_bizproc_list by focusing on starting 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?

No guidance on when to use this tool versus alternatives, such as prerequisites for template_id or document_id, or when not to use it. The description lacks context on selecting the right template or handling errors.

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, and the description only states 'creates an event'. It does not disclose behavioral traits such as required permissions, side effects (e.g., overwriting), idempotency, or error handling. The description carries the full burden but falls short.

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

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

A single sentence that is front-loaded with the tool's purpose. It contains no superfluous words and is efficient in delivery.

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

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

Given 10 parameters, 3 required, no output schema, and no annotations, the description is too brief. It omits usage context, parameter constraints, return values, and behavioral details, making it insufficient for a complex tool.

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

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

With schema description coverage at 50%, the description does not add meaning beyond summarizing three parameter categories (participants, location, reminders). It fails to explain parameters like type, owner_id, description, or webhook_url, leaving gaps.

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

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

The description clearly states the action (creates a calendar event) and specifies key features (participants, location, reminders). It distinguishes from the sibling tool b24_calendar_list, which is for listing events.

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

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

No guidance is provided on when to use this tool versus alternatives such as b24_calendar_list or other creation tools. There are no prerequisites, exclusions, or context for appropriate usage.

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 burden. It does not disclose that this is a read operation, nor any side effects, authorization needs, or return format. Only the basic listing function is mentioned.

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

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

The description is a single clear sentence that front-loads the core purpose. No wasted words.

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

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

Given no output schema and moderate complexity (5 parameters, no required fields), the description adequately covers the input purpose but lacks information about return values or pagination. Schema fills many 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 80% (4 of 5 parameters have descriptions). The overall description adds minimal extra meaning: it frames the operation as a list with date filtering, which is already implied by the parameter names and 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 lists calendar events with date filters and specifies the calendar types (personal, group, company). It distinguishes from sibling tools like b24_calendar_create.

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

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

The description implies usage for listing events with date filters but does not provide explicit guidance on when to use versus alternatives or any exclusions. Sibling tools exist but are not referenced.

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

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

No annotations are provided, so the description carries the full burden. It mentions that it calls any REST method but does not disclose behavioral traits such as potential side effects (e.g., destructive operations like task updates), authentication requirements, or rate limits. The external reference partially compensates but the description itself is minimal.

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

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

Three concise sentences that convey purpose, usage guideline, and reference. No unnecessary words; every sentence earns its place.

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

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

Despite no output schema, the description directs agents to the full API documentation for return values. For a generic tool that covers many methods, this is reasonable. It could mention that results vary by method, but the external reference mitigates 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 coverage is 100%, so the JSON schema already adequately describes the parameters (method, params, webhook_url). The description adds a usage context but does not significantly enhance parameter semantics 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 explicitly states it can call ANY REST method of the Bitrix24 API, which is a very specific verb+resource pair, and it distinguishes itself from siblings by being the generic fallback tool to use when no specific tool exists.

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

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

The description provides explicit usage guidance: 'Úsalo cuando no exista un tool específico' (use it when no specific tool exists). It also includes a link to the full API reference, which is a strong resource for proper usage.

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 provided, and the description fails to disclose behavioral traits such as authentication requirements, rate limits, whether the message is sent immediately or queued, or any side effects. This is a significant gap for a write 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 sentence, which is concise and front-loaded. However, it sacrifices important details; brevity should not come at the cost of completeness.

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

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

Given the lack of annotations and output schema, the description should provide more context about expected response, error handling, and whether messages support rich formatting or attachments. The current description is insufficient for a reliable agent 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 description adds minimal value beyond the input schema. It mentions 'private or group chat' which is already implied by the dialog_id parameter. The webhook_url parameter lacks any explanation, and the description does not clarify how it is used or if it's required for authentication.

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

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

Description clearly states the tool sends a message to a private or group chat in Bitrix24 IM, specifying both verb and resource. However, it does not differentiate itself from siblings like b24_notify_send or b24_feed_post, which also send messages but in different contexts.

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

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

No explicit guidance on when to use this tool vs alternatives. It does not mention prerequisites, restrictions (e.g., only text messages), or situations where other tools like b24_notify_send might 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?

No annotations are provided, so the description must carry the full burden. It discloses the basic behavior (comparison and reporting differences) but lacks details like whether the comparison is deep, what happens with invalid JSON, or the output format. Important behavioral traits are missing.

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 conveys the core functionality with no wasted words. It is front-loaded with the verb and resource.

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 no output schema, the description covers the main purpose and output. However, it omits error handling, expected input validity, and the report's structure, leaving gaps for an AI 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% with clear descriptions for both parameters. The tool description does not add additional semantics beyond what the schema already provides, so baseline score of 3 is appropriate.

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

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

The description clearly states the action ('compara dos archivos JSON de configuración') and the result ('informa qué existe en origen y no en destino, y viceversa'), with a specific verb and resource. It distinguishes from sibling tools like b24_read_full_config and b24_apply_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 implies usage for comparing configuration files but does not explicitly state when to use it versus alternatives or when not to use it. No exclusions or prerequisites are mentioned.

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

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

With no annotations, the description must disclose behavioral traits, but it only states 'creates a new record' without mentioning permissions, side effects, rate limits, or what happens on failure. The mutation nature is implied but not elaborated.

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 single-sentence description is concise but lacks structure. It front-loads the purpose but omits important details, making it minimally adequate.

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

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

Given the complexity (5 parameters, nested objects, no output schema, low coverage), the description is insufficient. It fails to explain parameter relationships, usage of 'entity_type_id', or behavior of 'params' and 'webhook_url'.

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 40% (only 'fields' and 'params' have descriptions). The description lists entity types but does not explain how to use the 'entity' or 'entity_type_id' parameters. It adds marginal value beyond the schema.

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

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

The description clearly states the tool creates a new CRM record and lists six specific types (deal, contact, company, lead, quote, SPA item), distinguishing it from siblings like b24_crm_update or b24_crm_delete.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., b24_crm_update for updates, b24_crm_get for retrieval). There are no exclusions or prerequisites mentioned.

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

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

Without annotations, the description should disclose behavioral traits like permanence, cascading effects, or authorization needs. It only states the basic operation, leaving critical behavior unspecified.

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 without fluff. However, it lacks structure (e.g., bullet points) that could aid readability, but the conciseness is appropriate for a simple 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?

Given four parameters, no output schema, and no annotations, the description is severely incomplete. It fails to explain parameter roles, return values, or side effects, making the tool risky for autonomous use.

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

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

Schema description coverage is 0%, and the description adds no meaning to parameters (entity, entity_type_id, webhook_url). The agent must guess what these fields represent.

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

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

The description clearly states the action (delete) and the resource (CRM record) via a specific identifier (ID), distinguishing it from sibling tools like create, update, or get.

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

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

No guidance on when to use this tool versus alternatives, nor any prerequisites, permissions, or exclusions. The agent must infer context from the tool name alone.

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

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

With no annotations, the description carries the behavioral disclosure burden. It does communicate that this is a read-only listing operation and describes the content returned (standard + custom fields, types, labels, configuration). However, it does not disclose webhook/auth requirements, the effect of passing no parameters, or how entity_type_id and webhook_url affect the call.

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 wasted words. The core action and resource are front-loaded, and the additional details (standard + custom, types, labels, configuration) are presented 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 metadata-listing tool, the description covers the key output content and read-only nature, which is important because there is no output schema. However, it leaves the webhook_url parameter unexplained and does not clarify invocation behavior when optional parameters are omitted, making it adequate but 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 only 67%, and the description adds little parameter-level meaning. The 'entity' parameter is already described in the schema, but 'webhook_url' has no description at all and 'entity_type_id' is described cryptically as 'ID de SPA'. The description does not clarify the relationship between entity, entity_type_id, and webhook_url.

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 ('campos disponibles de una entidad CRM'), and specifies that it includes both standard and custom fields with their types, labels, and configuration. It clearly distinguishes itself from the sibling b24_read_custom_fields by explicitly covering standard fields as well.

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 like b24_crm_list, b24_crm_get, or b24_read_custom_fields. It does not mention exclusions, prerequisites, or the conditions under which this tool is preferred. Usage must be inferred entirely from the purpose statement.

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 behavioral burden. It does disclose that the operation is a read ('Obtiene') and that it returns a 'complete' record across several entity types. However, it does not mention error behavior, authorization requirements, or whether optional parameters alter 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?

A single, dense sentence that immediately leads with the verb and object. Every word adds value, and the supported entity list is compactly attached. No filler or repetition.

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

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

For a tool with four parameters, no output schema, and no annotations, this description is too thin. It leaves the meaning and necessity of 'entity', 'webhook_url', and 'entity_type_id' open, does not clarify how to choose between CRM entity types, and offers no guidance on expected response shape or failure modes.

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

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

Schema description coverage is only 25%, so the description must compensate. It adds useful context by naming the entity types, which likely correspond to the 'entity' parameter, but it never explicitly maps them to parameters. 'webhook_url' and 'entity_type_id' remain entirely unexplained, leaving most parameters semantically empty.

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 ('Obtiene un registro CRM completo por ID') and explicitly names the supported record types (deal, contact, company, lead, SPA item), which distinguishes it from list/create/update/delete siblings. An agent can tell this is the single-record-by-ID retriever without opening schemas.

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 'por ID' implies this is the tool for fetching one specific record rather than listing or creating, but no explicit alternatives or when-not-to-use guidance is given. With siblings like b24_crm_list and b24_tasks_get nearby, the agent must infer the separation rather than being told.

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 discloses key behaviors: supports filters, field selection, and automatic pagination. It is clear it is a read operation, though it does not explicitly state read-only or discuss rate limits.

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

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

The description is two concise sentences in Spanish, front-loading the primary purpose and key capabilities with no redundant information.

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

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

Given the tool complexity (7 params, nested objects) and high schema coverage, the description covers core functionality (entity types, filtering, selection, pagination) but omits ordering and webhook_url, which are in schema.

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

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

Schema coverage is 86%, and the description merely summarizes entity types and features without adding meaning beyond the schema's descriptions (e.g., for filter, select, all_pages).

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

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

The description clearly states the tool lists CRM records, enumerating specific entity types (deals, contacts, companies, leads, quotes, SPA items), which distinguishes it from sibling tools like b24_crm_get (single record) or b24_crm_create.

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

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

The description implies listing use cases by listing entities, but does not explicitly contrast with alternatives (e.g., b24_crm_get for single records) or provide when-not-to-use guidance.

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

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

No annotations are provided, so the description must disclose behavioral traits. It does not mention whether the operation is destructive, idempotent, or requires specific permissions. The description only states the action without elaborating on side effects.

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

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

The description is a single concise sentence that efficiently conveys the core purpose. It is not overly verbose, though slightly more detail could be added without sacrificing conciseness.

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

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

Given the absence of output schema and the relatively simple parameter set, the description misses essential context such as return values, permissions, or behavior when the timeline entry fails. It feels incomplete for a mutation tool.

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

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

Schema descriptions cover 3 of 4 parameters with clear meanings. The description adds no extra insight beyond the schema. Although webhook_url lacks a description, the schema provides format hint. 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 clearly states the tool's action ('adds a comment or activity') and the resource ('timeline of a CRM record'). It uniquely identifies the tool among siblings as the only timeline-related operation.

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

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

No guidance on when to use this tool versus alternatives, such as other CRM mutation tools (e.g., b24_crm_update) or conditions under which it should be avoided. The description lacks contextual hints.

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 full burden. It indicates mutation but fails to disclose partial update behavior, permission requirements, side effects, or idempotency. Minimal behavioral context.

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

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

The single sentence is concise and to the point, with no redundant information. However, it lacks any structural formatting (e.g., sections) that might aid scanning.

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

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

For a tool with 6 parameters, no output schema, and no annotations, the description is far too brief. Missing details about return values, error handling, parameter roles, and when to use webhook_url. Incomplete for effective agent use.

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

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

Schema description coverage is only 17% (only fields has a description). The description does not explain the remaining 5 parameters (entity, entity_type_id, params, webhook_url), nor does it add meaning beyond the schema's minimal annotation.

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

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

The description clearly states it updates fields of an existing CRM record, distinguishing it from create, delete, get, and list siblings. However, it lacks specificity about CRM entity types (e.g., leads, deals), which are hinted by the entity parameter.

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

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

No guidance on when to use this tool versus alternatives like b24_crm_create (for new records) or b24_crm_delete. Does not mention prerequisites or conditions for updating records.

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, and the description does not disclose behavioral traits such as read-only nature, pagination, error handling, or authentication requirements. The description only states what is listed without safety or side-effect 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?

Single sentence description is concise and front-loaded with the core purpose. However, it could be more structured to include brief usage or return info without adding 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?

Given the complexity (nested object parameter, no output schema, no annotations), the description is minimal. It lacks details on return format, pagination, error handling, or how hierarchy and responsables are represented.

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 50%: filter parameter has a description with example, but webhook_url has no description. The tool description adds no extra meaning for webhook_url and does not clarify its purpose or usage, leaving ambiguity.

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

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

Description clearly states the tool lists departments with hierarchy and responsible parties, using a specific verb and resource. It distinguishes from sibling tools like b24_groups_list or b24_users_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?

No guidance on when to use this tool versus alternatives, no exclusion criteria, and no explanation of when to apply the filter parameter for hierarchy or name search.

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 disclose behavior. It states 'gets information' implying read-only but does not mention permissions, side effects, rate limits, or what information is returned beyond the URL. The webhook_url parameter's effect is unexplained.

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. However, it could be restructured to list key information points.

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

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

No output schema is present, and the description does not specify what fields the returned info contains. This leaves the agent uncertain about the response structure.

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 50%: file_id has a description, but webhook_url lacks one. The description adds no meaning beyond the schema, leaving the purpose of webhook_url unclear.

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

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

The description clearly states that the tool retrieves file information including download URL, specifying the verb 'gets information' and the resource 'file'. This distinguishes it from sibling tools like upload, folder list, and storages.

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

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

No guidance is given on when to use this tool over siblings, prerequisites, or context. The description does not explain when the optional webhook_url parameter should be used.

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 should disclose behavioral traits like overwrite behavior, size limits, or required authentication. It only states 'uploads a file' and omits critical details such as the need for a valid webhook_url parameter, leaving the agent unaware of side effects or constraints.

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 efficiently conveys the core action without any superfluous words. The key verb is front-loaded, making it immediately clear.

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

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

Given the lack of output schema and the presence of a critical parameter (webhook_url) with no explanation, the description is incomplete. It fails to cover return values, error states, authentication requirements, or file size limits, leaving the agent with significant gaps for effective use.

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

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

Schema description coverage is 75%, so the schema already documents most parameters. The description adds no extra meaning beyond what the schema provides. For the undocumented webhook_url parameter, no clarification is offered, but baseline is adequate.

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 'sube' (upload) and the resource 'archivo' (file) to a 'carpeta' (folder), directly differentiating from sibling tools like b24_disk_file_get (get file) and b24_disk_folder_list (list folders). It is specific and unambiguous.

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

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

No guidance is provided on when to use this tool versus alternatives, nor any prerequisites (e.g., folder existence, authentication via webhook_url) or exclusions. The description only states the action without context for decision-making.

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

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

No annotations are provided, so the description carries the full burden. It does not disclose behaviors like handling missing folder_id (defaults to root as per schema), error cases, or output format. Minimal 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, clear sentence with no wasted words. It is appropriately sized and 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?

The tool has 3 parameters and no output schema. The description does not mention the return format (list of files/folders) or any pagination, which leaves the agent underinformed for a list operation.

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

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

Schema description coverage is 67% (folder_id and filter have descriptions). The tool description adds no extra meaning beyond what the schema already provides, so 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 clearly states the verb 'Lista' and resource 'contenido de una carpeta en el Disk de Bitrix24'. It distinguishes the tool from siblings like b24_disk_file_get and b24_disk_storages.

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

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

The description implies usage for listing folder contents but provides no explicit guidance on when to use this tool versus alternatives or when not to use it.

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

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

The description signals a read-only listing operation through the verb 'Lista', but annotations are absent, so the description carries the full behavioral burden. It does not disclose whether authentication via webhook_url is needed, what the response looks like, or any pagination/access limitations. The operation's basic side-effect-free nature is clear, but deeper behavioral context is missing.

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

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

The description is a single, front-loaded sentence with no filler. It states the action, the resource, and the storage scopes efficiently, 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 list tool, the description is adequate, but it leaves gaps: the role of webhook_url is unexplained, there is no differentiation from b24_disk_folder_list, and with no output schema, the agent gets no hints about the structure or content of the returned storage list. It is minimally viable but not fully complete for confident invocation.

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

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

The only parameter, webhook_url, has no schema description (0% coverage), and the tool description does not mention it at all. While the parameter name and uri format hint at its purpose, the description fails to compensate for the missing schema documentation by explaining how or when it should be provided.

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 ('todos los storages disponibles'), with a parenthetical enumerating the storage scopes. This distinguishes it from sibling disk tools like b24_disk_folder_list and b24_disk_file_get, which operate at the folder/file level rather than the storage level.

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

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

The description states what the tool does but gives no guidance on when to prefer it over other disk-related tools or what conditions make it the right choice. There are no exclusions, prerequisites, or alternative comparisons, so the agent must infer usage purely from the tool name and sibling 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 must cover behavioral traits. It only mentions the action and BB-code support. It does not disclose authentication needs, rate limits, side effects, or error behavior. This is insufficient 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 sentence that conveys the core purpose and feature. No extraneous information.

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

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

Given the 6 parameters and no output schema, the description is somewhat complete for the basic action but lacks context on expected responses, error states, or how the tool integrates with other Bitrix24 operations. It could benefit from a note on return value or confirmation.

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 description coverage is high (83%). The description adds minimal meaning beyond the schema, reiterating BB-code support already described in the 'message' parameter. It does not explain the destination format or files encoding 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 clearly states the action ('Publica un mensaje'), the target resource ('feed de actividad / Live Feed'), and a key feature ('soporte BB-code'). It distinguishes this tool from siblings like b24_crm_create or b24_tasks_create, which target different 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 description does not explicitly state when to use this tool or provide alternatives. While the sibling tools cover other areas (CRM, tasks, etc.), the description lacks guidance on prerequisites, context, or when not to use it.

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

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

No annotations provided, so description must carry the burden. It only states it lists with filters, implying a read operation, but does not disclose permissions, rate limits, return format, or any side effects. Lacks depth.

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

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

Single sentence with no redundant information. Action and resource are front-loaded. Every word serves a 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?

No output schema exists, yet description does not explain return values or pagination. For a list tool, this is a significant gap. Does not cover all parameter behaviors or usage 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?

Description adds meaning for the 'filter' parameter by mentioning 'filtros por estado y visibilidad', but does not explain 'select' or 'webhook_url'. Schema coverage is 33%, so description partially compensates.

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

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

Description clearly states the verb 'Lista' (lists) and the resource 'grupos de trabajo (workgroups y proyectos)', and mentions filtering by status and visibility. This distinguishes it from sibling tools like b24_users_list or b24_departments_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?

No guidance on when to use this tool versus alternatives like b24_departments_list or b24_tasks_list. Does not specify context, prerequisites, or when not to use.

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 must fully disclose behavioral traits. It only states the action (send) without revealing side effects, required permissions, rate limits, or what happens on failure. The description is insufficient 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, short sentence (6 words in Spanish) with no fluff. It is front-loaded and efficient, though arguably too brief for full 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?

With 5 parameters, no output schema, and no annotations, the description lacks completeness. It omits return value, error handling, success indicators, and any behavioral nuances, leaving the agent underinformed.

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

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

Schema description coverage is 80%, so the schema already explains most parameters. The description adds no extra meaning beyond what is in the schema, meeting the baseline. It does not elaborate on parameter usage or constraints.

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

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

The description clearly states the tool sends a personal notification to a user in Bitrix24, using a specific verb and resource. However, it does not differentiate from sibling tools like b24_chat_send or b24_feed_post, which could cause confusion in selection.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., chat or feed posting). There is no mention of prerequisites, appropriate contexts, or exclusions.

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

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

No annotations provided; description only states creation without disclosing side effects, default values, error behavior, or authentication needs, which are critical for a creation 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?

Main description is a single clear sentence; inline schema description is appropriately structured. No redundant information, but could be slightly more detailed without losing conciseness.

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

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

Given no output schema and no annotations, the description fails to explain return values, error handling, or validation rules. The nested 'fields' parameter's additionalProperties is not explained, leaving ambiguity about allowed keys.

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?

Description within schema lists required (NAME) and optional fields, adding minimal clarity beyond schema properties. With 50% schema description coverage, the description partially compensates but lacks details on formats or constraints for fields like PRICE or CURRENCY_ID.

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 'Crea un nuevo producto en el catálogo' clearly specifies the verb (create) and resource (product in catalog), distinguishing it from sibling tools like b24_products_list, b24_products_get, b24_products_update.

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

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

No guidance on when to use this tool versus alternatives, no prerequisites, no context about required permissions or typical workflow scenarios.

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

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

With no annotations provided, the description carries the full burden. 'Obtiene el detalle completo' makes the read-only intent and the response scope reasonably clear, but it does not disclose error behavior, auth requirements, or any side effects.

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

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

The description is a single, well-structured sentence with no filler. It front-loads the action and resource, then states the distinguishing condition ('por ID').

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 getter with a single required parameter, the core invocation is covered. However, there is no output schema and no annotation, so 'detalle completo' is vague about the return shape, and the optional webhook_url remains unexplained.

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

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

Schema description coverage is only 50%: 'id' is documented, but 'webhook_url' has no schema description. The tool description merely restates the ID relationship and does nothing to explain the webhook_url parameter, leaving a meaningful gap for the agent.

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

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

The description states a specific verb ('Obtiene'), a specific resource ('un producto'), and the key access pattern ('por ID'). This clearly distinguishes it from sibling tools like b24_products_list, b24_products_create, and b24_products_update.

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

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

The phrase 'por ID' implies the tool should be used when you have a product ID and need full detail, so usage is inferable. However, there is no explicit guidance about when to choose this over b24_products_list or when not to use it.

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

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

With no annotations provided, the description fails to disclose behavioral traits such as read-only nature, pagination behavior, or data volume limits. The all_pages parameter hints at pagination but is not explained. The agent lacks understanding of side effects or constraints.

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

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

The description is concise at one sentence, front-loading the purpose. However, it is minimal and does not include structured details like pagination or async callback (webhook). It earns its place but could be more informative.

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

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

The description lacks completeness for a tool with 4 parameters and no output schema. It does not explain pagination (all_pages), async callback (webhook_url), or return format. For a list tool, the agent needs to know how to iterate pages and what data is returned. The description is insufficient.

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

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

The description provides general context that the tool filters by section, price, active status, which aligns with the filter parameter. However, it does not explain the all_pages and webhook_url parameters, leaving gaps. Schema coverage is 50%, and the description partially compensates for the filter parameter but not for the other two.

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

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

The description clearly states it lists products from the catalog with filters by section, price, active status, etc. This distinguishes it from sibling tools like b24_products_get (single product retrieval) and b24_products_create (creation).

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

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

The description implies usage for listing products with filters, but does not explicitly state when to use this tool versus alternatives like b24_products_get for single product retrieval. No when-not or alternative guidance 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?

No annotations are present, so the description carries full burden. It does not disclose any behavioral traits such as read-only nature, authentication needs, or side effects. Minimal disclosure.

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

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

The description is concise (one sentence) but lacks structure or front-loading of key information. It is not overly verbose, but could be more informative.

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 no output schema and two parameters, yet the description fails to explain the purpose of webhook_url, what sections/categories are returned, or how catalog_id influences results. Several gaps remain.

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 50%, with catalog_id described but webhook_url lacking any description. The description does not elaborate on either parameter, adding no 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 lists sections/categories of the product catalog, using a specific verb and resource. It distinguishes from siblings like b24_products_list (lists products) and b24_products_get (gets single product).

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

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

No guidance is provided on when to use this tool versus alternatives, prerequisites, or when not to use it. The description only states the action without 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 provided. The description only says 'Updates a product' without disclosing behavior such as whether it performs partial updates, side effects, idempotency, or authorization needs. Given the absence of annotations, the description should provide more behavioral context.

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

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

The description is a single short sentence, which is concise and front-loaded. However, it sacrifices completeness for brevity, missing important details.

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

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

Given the complexity of having 3 parameters (including a nested fields object), no output schema, and no annotations, the description is incomplete. It fails to explain the structure of 'fields', the purpose of 'webhook_url', return values, or error conditions.

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

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

Schema description coverage is only 33% (only 'fields' has a description). The tool description adds no additional meaning beyond what the schema already provides for parameters 'id' and 'webhook_url'. It does not compensate for the lack of schema descriptions.

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

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

The description 'Updates a product in the catalog' clearly states the action (update) and resource (product in catalog). The verb 'update' distinguishes it from sibling tools like b24_products_create (create) or b24_products_get (get). However, it does not explicitly differentiate from similar tools like b24_products_sections.

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

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

No guidance on when to use this tool versus alternatives (e.g., b24_products_create for new products, b24_products_get for retrieval). Lacks prerequisites, context for when not to use, or mention of required permissions.

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 that the operation is a read and that results include conditions and actions, but it does not explain how 'por etapa' maps to the schema, whether results are paginated, or what permissions are needed.

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

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

The description is a single sentence with no filler and the verb is front-loaded. However, 'por etapa con condiciones y acciones' is slightly compressed and could mislead an agent into expecting a stage parameter that the schema does not define.

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

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

For a simple read tool with zero required parameters and no output schema, the description conveys the core resource and content. However, it does not describe the return structure or clarify how entity_type_id relates to stages, leaving minor but relevant 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?

Both parameters are fully documented in the schema (webhook_url and entity_type_id), so the baseline is 3. The description adds no parameter-level meaning and even introduces the term 'etapa', which does not correspond to any schema property.

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 'Lee' (reads), names the resource 'reglas de automatización (robots y triggers)', and adds scope with 'por etapa con condiciones y acciones'. This clearly communicates the tool's function, though it does not explicitly differentiate it from similar siblings like b24_bizproc_list.

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

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

There is no guidance on when to use this tool versus alternatives such as b24_bizproc_list or b24_read_entity_types. The verb 'Lee' implies a read operation, but no prerequisites, exclusions, or selection context are provided.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose the read-only nature and the broad scope across all CRM entities, which is useful. However, it does not describe the response structure, pagination behavior, authentication expectations, or what 'configuración completa' concretely includes.

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 concise sentence with no filler. The action and object are front-loaded, and every word contributes to understanding 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?

The tool is relatively simple, has zero required parameters, and the schema covers both optional parameters, so a brief description is partially acceptable. However, with no output schema and no annotations, the description leaves the concrete shape of the returned custom-field configuration unspecified, requiring the agent to infer what 'configuración completa' means in practice.

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 itself adds no parameter-specific meaning beyond the schema; for example, it does not mention that entity_type_id can filter results, but the schema already documents this clearly.

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

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

The description clearly states the action ('Lee' / reads), the resource ('campos personalizados de todas las entidades CRM'), and the expected content ('configuración completa'). It is specific enough to understand what the tool returns, but it does not explicitly differentiate it from siblings like b24_crm_fields or b24_read_entity_types.

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 custom field definitions for CRM entities are needed, and the read-only nature is implicit. However, it provides no explicit guidance about when to prefer this tool over alternatives, nor does it mention exclusions, prerequisites, or cases where another sibling tool would be more appropriate.

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

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

No hay anotaciones, por lo que la descripción carga con la transparencia conductual. Dice que es una lectura y que incluye atributos, pero no informa sobre permisos, formato de respuesta, paginación, limitaciones ni efectos secundarios (aunque sea de solo lectura).

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 relleno, con el verbo y el alcance al frente. Es eficiente y fácil de procesar para un agente.

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 solo lectura con un parámetro opcional, la descripción cubre lo esencial. Sin embargo, al no existir output schema ni anotaciones, sería útil indicar qué tipo de estructura devuelve y cómo se diferencia de b24_crm_fields o b24_read_custom_fields; la frase actual es suficiente pero no completa.

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 100% y el único parámetro, webhook_url, ya tiene descripción en el schema. La descripción de la herramienta no añade información adicional sobre ese parámetro, así que se mantiene la línea base de 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?

La descripción usa el verbo específico 'Lee' y define el recurso: 'todos los tipos de entidad CRM y SPA (Smart Process Automation) con sus atributos'. Esto la distingue de la mayoría de los hermanos, aunque no desambigua explícitamente contra b24_crm_fields o b24_read_custom_fields.

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 se indica cuándo usar esta herramienta frente a alternativas como b24_read_custom_fields, b24_read_pipelines o b24_crm_fields. Tampoco se mencionan prerequisitos ni exclusiones; el contexto de uso solo queda implícito por el nombre y la acción 'Lee'.

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 must disclose behavioral traits. It does not confirm read-only nature, mention side effects, authentication needs, or performance implications. The verb 'Lee' suggests reading, but lacks explicit assurances.

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

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

The description is a single sentence that efficiently lists the scope and export format. It is concise and prioritizes key information, though it could be slightly more structured with separate sentences for scope and export.

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 annotations, output schema, and 3 parameters, the description lacks completeness. It does not clarify return values (if any) beyond exporting to a file, or specify whether the tool returns the JSON in the response. The parameter for verbose is undefined.

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 67%; the description does not add meaning beyond the schema. It mentions export to JSON, which relates to output_file, but provides no details on usage or format of parameters like verbose.

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 reads all structural configuration of the instance, listing key components (entities, pipelines, stages, fields, automations, catalog, users), and specifies it exports to JSON. This differentiates it from sibling tools that read specific subsets.

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 for comprehensive configuration export via 'TODA', but does not explicitly guide when to use this instead of specialized reads (e.g., b24_read_pipelines). No mention of when not to use 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 behavioral burden. It communicates the read-only nature through the verb 'Lee' and enumerates the included data (stages, colors, semantics, order). However, it does not mention return format, pagination, or authentication requirements, which would add useful transparency for a tool with no annotation coverage.

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

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

The description is a single, front-loaded sentence that starts with the action and resource, then lists the relevant attributes. Every word earns its place 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?

With no output schema, the description names the returned resources and their distinguishing attributes, making the tool's output reasonably clear. The optional parameters and defaults are fully covered by the input schema. Minor gaps like pagination or explicit response structure are acceptable given the tool's simplicity.

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

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

Schema description coverage is 100%, and both parameters are documented with clear optional/default semantics. The tool description adds no additional meaning for webhook_url or entity_type_id, so it does not exceed the schema's baseline contribution.

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 'Lee' (reads) and a specific resource 'pipelines (funnels)'. It further clarifies what is returned: stages with colors, semantics, and order. This clearly distinguishes it from sibling read tools like b24_read_entity_types or b24_read_custom_fields.

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 pipeline/funnel definitions and stages are needed, but it does not provide explicit guidance about when not to use it or how it compares to alternative tools. The resource is clear enough for basic inference, but no exclusions or sibling routing are mentioned.

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

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

The description clearly indicates a read operation ('Lee') but provides no additional behavioral context beyond that. Since no annotations are provided, the description carries the full burden; it doesn't mention response format, whether this is live data or cached configuration, or any access prerequisites. It is adequate but not rich.

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

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

The description is a single, front-loaded sentence that wastes no words and clearly enumerates the contents of the catalog structure with a colon-separated list. It is compact and 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?

For a simple read tool with zero required parameters, the description explains what the tool reads and the main components covered. However, there is no output schema and no mention of return format, pagination, or how this tool differs from b24_products_sections, so an agent may lack full context for evaluating the response.

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 is the optional webhook_url, and the schema describes it fully with 100% coverage. The description does not mention parameters, but because the schema already covers the parameter well, the 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 uses a specific verb ('Lee') and identifies a clear resource: the configuration structure of the product catalog, listing sections, properties, prices, and units. This distinguishes it from product-data siblings like b24_products_list or b24_products_get, which focus on records rather than catalog configuration structure.

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 the agent needs catalog configuration structure rather than product data. However, it does not explicitly mention alternatives or state when not to use it, leaving the agent to infer the distinction from sibling tool 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?

No annotations are provided, and the description does not disclose behavioral traits beyond the basic action. It does not mention whether the output file is overwritten, what happens if the mapping already exists, authentication requirements, or rate limits.

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

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

The description is a single sentence of 13 words, efficiently conveying the core purpose without unnecessary verbose. It is front-loaded with the action.

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

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

Given the simple three-parameter schema and no output schema, the description adequately explains the tool's purpose. It does not detail the output format, but the parameter 'output_file' hints at a JSON file. Sibling tools provide context for automation replication.

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 description adds no additional meaning beyond the parameter descriptions already in the schema. It correctly implies that the mapping is based on user IDs, which aligns with the 'ID' required field.

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

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

The description clearly states the action ('generates and saves'), the resource ('user ID mapping between two instances'), and its purpose ('necessary to replicate automations'). This distinguishes it from sibling tools that focus on CRM, tasks, disk, 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 provides context by stating it is necessary for replicating automations, implying its use in that workflow. However, it does not give explicit guidance on when to use this tool versus alternatives, nor does it mention when not to use it.

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

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

No behavioral details beyond the action are disclosed. Important traits like idempotency, side effects (notifications), or required permissions are omitted. Since annotations are absent, the description should carry the burden, but fails to do so.

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

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

The description is very short (5 words), which is concise but missing necessary context. It is front-loaded but not sufficiently informative for an autonomous agent.

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

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

Given the lack of annotations and output schema, the description is incomplete. It does not address error cases, expected outcomes, or distinctions from similar tools. A more detailed description is needed for reliable tool selection.

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

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

Only 50% of parameters have descriptions in the schema. The description adds no extra meaning for 'id' and does not explain the purpose of 'webhook_url'. The schema's coverage is partial, and the description does not compensate.

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

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

The description clearly states the action ('completar' - complete) and the resource ('tarea' - task). It is specific enough to distinguish from generic update tools like b24_tasks_update.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., b24_tasks_update for other status changes). No prerequisites or exclusions are mentioned.

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

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

No annotations exist, so the description carries full burden. It states the tool creates tasks (mutation) but reveals no side effects, idempotency, authorization needs, or return behavior. Critical details are missing.

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

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

Single sentence, no filler. Efficient but could add small structure 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?

Given the presence of nested parameters and no output schema, the description lacks guidance on required fields (TITLE is required, not mentioned), optional parameters, and response format. The agent may fail without schema inspection.

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 50% but fields has detailed schema description. The description lists a subset of fields (title, description, etc.), adding slight clarity but not significantly beyond schema. The webhook_url parameter is omitted, and enum values are not repeated.

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 'Crea una nueva tarea' clearly indicates the action (create) and resource (task). It lists typical fields, distinguishing it from update or complete siblings.

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

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

The description implies use for creation but provides no explicit guidance on when to use this tool versus alternatives like b24_tasks_update or b24_tasks_complete. The 'new' keyword suggests fresh tasks, but no alternatives are mentioned.

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

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

With no annotations, the description carries the full burden and does disclose the core read behavior and expected result (full task detail). However, it does not mention return shape, error behavior, how the optional 'select' parameter affects the 'detalle completo' promise, or any webhook-related 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, direct, front-loaded sentence with no filler. For a simple getter, this is appropriately concise.

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

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

The tool has no annotations, no output schema, and only 67% parameter coverage, so the description is thinner than ideal. The core action and key parameter are clear enough to make a basic call, but usage alternatives, webhook_url semantics, and return behavior 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?

Schema description coverage is 67%; 'id' and 'select' are already documented in the schema. The description adds only that the task is fetched by ID, which reinforces 'id' but adds nothing about the undocumented 'webhook_url' 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 'Obtiene el detalle completo de una tarea por ID' states a specific verb, resource, and access key. It clearly distinguishes this from siblings like b24_tasks_list (collection), b24_tasks_create, b24_tasks_update, and b24_tasks_complete (mutations).

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 'por ID' phrase implies this is the single-record fetch tool to use when a task ID is already known, which gives some usage context. However, it does not explicitly contrast with b24_tasks_list or state when not to use this tool, leaving selection partly 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 provided, and the description lacks behavioral disclosures such as read-only nature, pagination behavior, or any side effects. The tool likely performs a read operation, but this is not explicitly stated.

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

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

Single, brief sentence that conveys the core function. No unnecessary words or repetition.

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

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

Despite its simplicity, the description omits crucial context: no output schema, no mention of default returned fields, pagination, or rate limits. For a listing tool with nested parameters, more detail is needed to set expectations.

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 parameters, including examples and default values. The description adds general context about filter types but does not significantly enhance meaning beyond the schema. Baseline 3 due to 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?

Description clearly states it lists tasks with filters by common attributes (responsible, group, status, deadline). The verb 'list' and resource 'tasks' are explicit, distinguishing it from sibling tools like b24_tasks_create or b24_tasks_update.

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

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

No guidance on when to use this tool versus alternatives. While it's implied for listing tasks, it does not mention exclusions or alternative tools for specific scenarios (e.g., getting a single task).

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 fully disclose behavior. It only states 'updates fields' without specifying whether updates are merged or overwritten, required permissions, or error handling.

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 without redundancy. However, it lacks structure and additional detail that could fit into a few more sentences.

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 minimal description, the tool definition is incomplete. The agent lacks information on response format, merge vs replace behavior, and error conditions, reducing its ability to use the tool correctly.

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

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

Schema description coverage is only 33% (only 'fields' has a description). The description adds no extra meaning beyond the schema for 'id' or 'webhook_url', leaving the agent without clarity on 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 clearly states the verb 'Actualiza' (updates) and the resource 'campos de una tarea existente' (fields of an existing task). This distinguishes it from sibling tools like create, list, get, and complete.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, context, or when to avoid using it.

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

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

No annotations are present, so the description carries full burden for behavioral disclosure. It does not mention that the tool is read-only, any authentication needs, or performance considerations like pagination. The description only states it lists calls, which is minimal.

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

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

The description is a single concise sentence that front-loads the verb 'Lista' (Lists). It is efficient with no wasted words, though it could benefit from structural elements like bullet points for 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?

Given that there is no output schema and the tool has 3 parameters (including a nested object filter), the description is incomplete. It does not explain the return format, pagination behavior, or how the optional parameters like 'select' and 'webhook_url' affect the output.

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

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

Schema coverage is only 33% (only 'filter' has a description in schema). The tool's description adds meaning by listing filterable fields (CRM entity, user, duration, date), which corresponds to the 'filter' parameter. However, it does not explain 'select' or 'webhook_url' parameters, leaving gaps.

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

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

The description clearly states the tool lists call history with filters by CRM entity, user, duration, and date. This distinguishes it from sibling tool b24_call (which likely makes calls) but not from other listing tools like b24_crm_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?

No guidance on when to use this tool versus alternatives, such as when to use b24_crm_list instead. No when-not or exclusion criteria 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?

No annotations are provided, so the description carries the full burden. It does add behavioral detail beyond a simple 'test connection' by stating that it confirms portal data and user permissions. However, it does not disclose whether the operation is read-only, what happens on failure, or any side effects, leaving the behavioral profile only partially specified.

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 that immediately names the verb and resource. Every word contributes value, with no redundancy 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?

The tool is simple and the schema is minimal, but there is no output schema and no annotations. The description mentions what is confirmed (portal data and permissions) but does not explain the return format, success/failure signals, or error behavior, leaving an agent without full information for interpreting the result.

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

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

Schema description coverage is 100%, and the parameter is already described as an optional webhook URL. The tool description adds no additional meaning about the parameter, so the baseline of 3 applies without extra credit.

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

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

The description clearly states a specific verb ('Verifica'), a concrete resource ('conexión al webhook de Bitrix24'), and extends into what is confirmed (portal data and user permissions). It naturally distinguishes this tool from the sibling CRUD/action tools, as no other sibling is a connection test.

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

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

There is no explicit guidance on when to use this tool or when not to, and no reference to alternatives. The usage is implied because it is the only test/connection tool among siblings, but the description doesn't state that it should be used to validate configuration before other operations or as a health check.

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 must disclose behavior. It does not mention that the default filter includes only active users, that pagination is handled via all_pages, or that webhook_url can be used. The behavior of the 'select' parameter is also not described.

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 efficiently conveys the tool's purpose. While structured additional details would be helpful, the brevity is not detrimental given the tool's simplicity.

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

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

The description lacks important context: it does not explain the return format, pagination behavior, or how to apply custom filters beyond the default. Given that the tool has 4 parameters and no output schema, the description is insufficient for complete agent understanding.

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

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

The schema covers 50% of parameters with descriptions (filter and select). The description adds no information about any parameters. For parameters like all_pages and webhook_url, no meaning is provided beyond the schema definition. The description could have compensated but does not.

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

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

The description clearly states it lists active users with specific fields (name, email, position, department, online status). The verb 'lista' and resource 'usuarios activos' are precise and distinguish from sibling tools like b24_departments_list or b24_groups_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?

No guidance is provided on when to use this tool vs. alternatives such as b24_departments_list or b24_groups_list. The description only says what it does, not when or when not to use it.

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