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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action (approve/reject) but does not mention side effects, reversibility, permission requirements, or what happens to the request after the action, leaving significant behavioral ambiguity for an agent.

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

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

The description is a single, compact sentence with no filler or redundancy. The key action and target are front-loaded, and every word earns its place.

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

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

The tool has simple parameters with a well-described schema, but the lack of annotations, output schema, and any mention of side effects or prerequisites leaves notable gaps. The description is minimally viable for selecting the tool but not fully complete for understanding the broader context of invoking it.

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

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

The schema already provides 100% coverage of parameter descriptions, including the enum for action. The description adds minimal context beyond the schema, only implying that the request is pending. This meets the baseline for high schema coverage but does not add extra parameter meaning.

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

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

The description uses a specific verb ('Approve or reject') with a clear resource ('pending approval request'), which immediately distinguishes it from other approval tools like bulk_approve or update_approval. It fully captures the tool's primary function.

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 'pending approval request' implies when to use the tool, but there is no explicit guidance on when not to use it or how it differs from alternatives such as passgage_bulk_approve or passgage_update_approval. Usage context is only implied, not clearly articulated.

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

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

With no annotations, the description alone carries the burden of disclosure. It states the action but does not mention side effects, idempotency, conflict handling, permissions, or response behavior. This is a significant gap for a mutation tool.

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

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

The description is a single concise sentence with no fluff. It is appropriately front-loaded, though extremely brief.

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

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

This is a mutation tool with no annotations and no output schema, so the description needs to explain behavioral context. It does not address success/failure responses, optional parameters, or potential conflicts, leaving it incomplete for an agent.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning 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 assigns a user to a shift, using a specific verb and resource. It does not explicitly differentiate from sibling tools like create_user_shift or update_user_shift, but the action is obvious.

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, no prerequisites, and no exclusions. The description implies usage but does not articulate context or decision criteria.

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

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

There are no annotations, so the description carries the full burden. 'Check' implies a read-only operation, and listing the three outputs adds value. However, it does not disclose potential error conditions, whether authentication is required to call this endpoint, or the return format, which leaves behavioral gaps.

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

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

The description is a single, front-loaded sentence that is concise and free of waste. Every word contributes meaning, listing exactly what the tool checks.

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

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

For a simple no-parameter status check with no output schema or annotations, the description adequately conveys the core return values (status, mode, methods). It lacks explicit detail on edge cases or error behavior, but the simplicity of the tool keeps this from being a major deficiency.

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

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

The tool has zero parameters, so the baseline is 4. There is no parameter information needed, and the description appropriately focuses on output rather than input.

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 ('Check') with a clear resource ('authentication status') and lists three concrete aspects: status, current mode, and available authentication methods. This distinguishes it from sibling tools like passgage_get_auth_modes, which likely only lists modes without the current state.

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 it is for checking authentication state, giving some usage context. However, it does not explicitly mention when to use this tool versus siblings like passgage_get_auth_modes or passgage_login, nor does it state any exclusions or prerequisites.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It merely states the action without explaining partial failure behavior, permission requirements, reversibility, or response format—significant gaps 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 sentence with no unnecessary words, directly stating the action and scope. It is front-loaded and appropriately sized for the information it conveys.

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 bulk mutation tool with no annotations and no output schema, this description is too sparse. It fails to clarify whether 'at once' implies atomicity, how notes apply to all decisions, or what the outcome/response will be.

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

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

Schema description coverage is 100%, so the schema fully documents all three parameters (approval_ids, action, notes). The description adds no extra parameter semantics, so the baseline of 3 applies.

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

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

The description clearly states the specific verb (approve/reject) and resource (multiple approval requests), and 'at once' effectively distinguishes this bulk action from singular approval tools like passgage_approve_request.

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 bulk usage but does not explicitly mention when to use this tool versus the singular approval tool or provide exclusions. It lacks guidance on prerequisites or conditions.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It simply says 'Create a new access_zone,' which only restates the tool's name without detailing side effects, required permissions, id generation, or response behavior. For a mutation tool, this is insufficient.

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

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

The description is a single concise sentence with no filler or redundancy, making it easy to parse. However, it is so minimal that it borders on under-specification, though it does clearly state the core 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 has a nested open data object, no annotations, and no output schema, making substantial context necessary. The description fails to explain the data object's structure, constraints, or invocation context, leaving a critical gap for an agent trying to construct a valid call.

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

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

The schema describes the only parameter 'data' as 'The data for creating the access_zone,' which is circular and unhelpful. The tool description adds no information about the required fields within the data object, and because additionalProperties is true, the agent has no structural guidance for constructing valid input.

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 'Create a new access_zone' uses a specific verb and resource, clearly stating what the tool does. Although it does not explicitly differentiate from sibling create_* tools, the resource name is unambiguous and the action is distinct from list/get/update/delete siblings.

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

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

No guidance is provided on when to use this tool versus alternatives such as update_access_zone or delete_access_zone. The description omits any context about prerequisites, use cases, or exclusions, leaving the agent to infer usage purely from the name.

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

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

No annotations are provided, and the description offers no behavioral details beyond the name. It does not disclose side effects, required authentication, data validation rules, or any constraints. The description is entirely tautological, providing zero value beyond the tool name.

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

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

The description is extremely concise with no filler words. However, it is so terse that it sacrifices utility; a single short sentence earns its place but provides minimal information to the 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?

This is a create operation with a complex nested object parameter and no output schema or annotations. The description gives no context about what an approval is, what fields are expected, how it relates to other resources, or any constraints. It is completely inadequate for an agent to invoke correctly.

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

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

The schema has a single 'data' parameter with a description ('The data for creating the approval') that essentially mirrors the tool description. Schema coverage is 100% so baseline is 3, but the description and schema both fail to specify the expected structure or required fields within the data object, limiting practical use.

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 ('Create') and the resource ('a new approval'), providing a specific verb+resource statement. However, it does not differentiate from sibling tools like passgage_approve_request or passgage_update_approval, which could be confused with creating an approval.

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

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

No guidance is given on when to use this tool versus alternatives. The description does not mention prerequisites, typical scenarios, or relationships to other approval-related operations, leaving the agent without context for selection.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It merely states 'Create' without any details on side effects, required permissions, reversibility, or response format. This is a write operation, but the description offers no insight into the consequences or behavior beyond the verb, making it effectively uninformative.

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, immediately stating the action and resource. It is concise and front-loaded with no fluff. However, it is so minimal that it borders on under-specification, though for a simple tool definition, this level of brevity is not inherently poor.

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 annotations and output schema, and the presence of many sibling CRUD tools, the description is too sparse to be complete. It does not explain what data is needed, what the created approval_flow represents, or any related usage context. The tool is a basic create operation, but even basic tools benefit from at least a sentence about required fields or typical 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?

The schema has one parameter 'data' with a description that is tautological ('The data for creating the approval_flow') and an object type with additionalProperties true, giving no field-level detail. The tool description adds no insight into what fields are expected. Even though schema coverage is 100%, the content is empty, so the description fails to provide meaningful 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 action ('Create') and the resource ('approval_flow'), which is sufficient to distinguish it from sibling tools like 'create_approval' or 'update_approval_flow'. However, it does not elaborate on what an approval_flow is or differentiate it beyond the resource name, so it stops short of a top score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not specify prerequisites, context, or exclusions. The user is left to infer that creation is appropriate whenever a new approval_flow is needed, but there is no explicit or implicit comparison to other tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the action 'Create' without mentioning side effects, authentication needs, idempotency, or what happens on success or failure. Minimal behavioral information is conveyed.

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 is front-loaded with the action and object. Every word earns its place, 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 has a free-form 'data' object with no specified sub-fields, and no output schema is present. The description does not explain what an assignment_request is, what data structure is expected, or what the response will be. This leaves a significant gap for the agent 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?

The schema has one parameter 'data' with a description and 100% coverage, so the baseline is 3. The tool description adds no additional parameter semantics, but since the schema already covers the parameter, this is acceptable.

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 'Create a new assignment_request' uses a specific verb and resource, clearly stating the tool's purpose. It distinguishes itself from sibling tools that perform list, get, update, or delete operations on the same resource.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as when to use update or delete instead. There are no prerequisites, exclusions, or context about the use case, leaving the agent to infer solely from the tool name.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'Create a new branche,' which implies a mutation but does not disclose required permissions, idempotency, side effects, return values, or validation behavior. This falls short of meaningful transparency.

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

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

The description is a single short sentence, making it concise and front-loaded. However, it largely restates the tool name (passgage_create_branche) and adds no additional context, so it does not fully earn its place in terms of informative value.

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 a single generic 'data' object parameter, no annotations, and no output schema, the description is severely incomplete. An agent has no idea what fields to include in 'data', whether authentication is required, or what the response looks like. This is inadequate for a create operation.

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

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

The input schema has one parameter 'data' with 100% coverage, but its description is generic ('The data for creating the branche') and additionalProperties allows anything. The tool description adds nothing about the required structure or fields. Since schema coverage is high, the baseline is 3, and the description does not exceed it.

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 ('Create') and the resource ('a new branche'), which distinguishes it from sibling tools like passgage_list_branches, passgage_get_branche, and passgage_update_branche. However, the typo 'branche' and lack of detail about what a branche is prevent a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It merely states the action, without mentioning prerequisites, exclusions, or when to prefer other tools such as update or delete. This is effectively no usage guidance beyond the obvious implication from the verb 'create'.

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

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

With no annotations and a description that merely restates the tool's name, there is zero disclosure about behavioral traits. The agent is not informed about required data structure, idempotency, permissions, or response behavior. The description adds no value beyond the tool name.

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

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

The description is a single short sentence, but it is under-specified to the point of being a restatement of the tool name. While brevity is valued, this sacrifices essential information and is better characterized as missing specification rather than true 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?

The tool has a complex input (an unrestricted object), no output schema, no annotations, and a description that says nothing about data shape, return values, or error handling. For a create operation with significant ambiguity, this is severely incomplete and would prevent correct invocation.

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

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

Although schema description coverage is 100%, the only parameter 'data' is described as 'The data for creating the branch_group'—a tautology. It provides no structural information, required fields, or examples. The tool description also lacks parameter context, leaving the agent completely in the dark about what to pass.

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 'Create a new branch_group' explicitly states the action and resource, clearly distinguishing it from sibling operations like update, delete, get, and list for branch groups. The verb and noun are 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?

There is no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., existing parent resources), when to prefer update over create, or any exclusion criteria. The description is purely declarative with no selection assistance.

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

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

With no annotations, the description must carry all behavioral disclosure. It only states the core action but omits side effects, return values, permissions, idempotency, or required data shape. For a mutation tool, this is a significant gap.

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

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

The description is appropriately short and front-loaded, but it is under-specified rather than concise. Every word is informative yet insufficient for a tool with complex input, warranting a mid-range score.

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

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

The tool has a nested object parameter with arbitrary properties and no output schema or annotations. The description does not clarify the card data structure, required fields, or operation context, making it inadequate for correct invocation.

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

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

The schema has high coverage for the single 'data' parameter, but both the schema description and the tool description are tautological ('The data for creating the card'). No subfields, examples, or structure hints are provided, so the agent gains no meaningful understanding beyond the parameter name.

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 'Create a new card' uses a specific verb and resource, clearly indicating the action. It distinguishes from update/delete/get/list card siblings, though it doesn't differentiate among the many create_* tools (e.g., create_user, create_approval) beyond the resource name.

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

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

No guidance is provided on when to use this tool versus update_card or other create_* tools. There is no mention of prerequisites, alternatives, or conditions that warrant creating a card instead of updating one.

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 not mention authentication requirements, potential side effects, required permissions, or response format. For a mutation tool, this lack of behavioral context is a significant gap.

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

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

The description is a single, efficient sentence that avoids redundancy or filler. It is concise and to the point, with 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?

This is a create operation with no annotations, no output schema, and an opaque 'data' parameter. The description does not explain what the department object should contain, how the API behaves, or what the response looks like. Given the potential complexity of the data payload, the description is incomplete 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?

The input schema has one parameter, 'data', with a description ('The data for creating the department') and additionalProperties set to true. Since schema description coverage is 100%, the baseline is 3. The tool description adds no additional 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 'Create a new department' uses a specific verb ('create') and resource ('department'), clearly distinguishing it from sibling tools that list, get, update, or delete departments. It is unambiguous and directly states the tool's function.

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

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

The description provides no guidance on when to use this tool versus alternatives like passgage_update_department or passgage_delete_department. There is no mention of prerequisites, context, or exclusions, so the usage is only implied by the verb 'create'.

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

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

No annotations are provided, so the description carries full responsibility for disclosing behavioral traits. It only states 'Create a new device' and does not mention required data, permissions, side effects, idempotency, or return 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?

While the description is extremely short (one sentence), it is under-specified rather than appropriately concise. It lacks any structural elements like usage context or parameter guidance, making it closer to a tautology than a useful tool description.

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

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

Given the tool's complexity (an opaque 'data' object with additionalProperties allowed, no output schema, and no annotations), the description is far too brief to be complete. It fails to explain what a 'device' is, what fields are required, or what successful creation entails.

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

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

The sole parameter 'data' has a schema description that is circular ('The data for creating the device'), adding no real meaning. The tool description similarly provides no insight into the expected structure, required fields, or examples for this opaque parameter.

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

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

The description clearly states the tool's action ('Create') and resource ('a new device'), making its purpose unmistakable. It aligns well with the tool name and distinguishes it from sibling tools like passgage_list_devices, passgage_get_device, passgage_update_device, and passgage_delete_device.

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

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

The description provides no information about when to use this tool versus alternatives, nor any prerequisites or context. It simply states the action without addressing usage scenarios or relationships to other tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Create a new entrance,' which implies a mutation but does not disclose side effects, required permissions, idempotency, or return behavior. This is a severe transparency gap.

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

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

The description is extremely concise—a single sentence with no fluff. However, it is under-specified to the point of being terse, making it not 'appropriately sized' for a tool that likely requires more context to be used correctly.

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 a loose schema (additionalProperties true), no output schema, and no annotations. The description offers no details about what constitutes an 'entrance,' what fields are expected, or any constraints. This is inadequate for an agent to invoke the tool confidently.

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

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

The input schema has one parameter 'data' with a description ('The data for creating the entrance') and additionalProperties true, giving 100% schema coverage. The tool description adds no extra meaning beyond the schema, so the baseline 3 applies.

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

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

The description clearly states the action ('Create') and the resource ('a new entrance'), which is specific enough to convey the basic purpose. However, it does not distinguish this tool from sibling tools like passgage_update_entrance or passgage_track_entrance, so it falls short of a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives such as passgage_update_entrance or passgage_track_entrance. There is no mention of prerequisites, context, or exclusions, leaving the agent without direction.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not mention any side effects, permissions, or error conditions. Apart from implying a write operation, it reveals nothing about how the tool behaves.

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

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

The description is extremely concise, using a single sentence with zero wasted words. However, it is so brief that it borders on under-specification, lacking even a hint of the data structure, but the text itself is well-structured 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?

Given the tool has an unconstrained nested data parameter, no output schema, and no annotations, this description is wholly inadequate. It does not explain what constitutes a holiday, what data fields are needed, or what the tool returns. An agent would struggle to invoke it correctly.

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

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

The input schema documents a single 'data' parameter with a generic description and allows arbitrary properties. The description 'Create a new holiday' adds no information about what fields are required inside the data object. Since the schema effectively provides no structural constraints, the description offers insufficient meaning for correct invocation.

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 'Create a new holiday' clearly states the verb and resource, distinguishing it from get/update/delete/list siblings. However, it does not provide any additional differentiation or context beyond the generic create pattern, so it falls short of a top score.

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 update_holiday for modifying existing holidays. The intended usage is only implied by the verb 'create', with no exclusions, prerequisites, or context 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 of behavioral disclosure. It only states 'Create a new job_position', revealing that it is a mutation but omitting auth requirements, side effects, response format, or validation behavior.

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

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

The description is a single, front-loaded sentence with no fluff. It is appropriately sized for a CRUD creation tool and every word earns its place.

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

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

With no annotations, no output schema, and a permissive 'data' object (additionalProperties true), the description does not explain what fields are needed for a job_position or what to expect on success. This is insufficient for a create operation.

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

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

The schema has 100% description coverage for its single 'data' parameter, but that description is generic ('The data for creating the job_position'). The tool description adds no parameter-level meaning beyond what the schema already provides, so the baseline of 3 applies.

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

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

The description uses a specific verb and resource: 'Create a new job_position'. This clearly distinguishes it from sibling tools for listing, getting, updating, and deleting job positions.

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 creating a job_position, but provides no explicit context on when to choose this over alternatives or any prerequisites/exclusions. It relies entirely on the tool name and sibling naming conventions.

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 of behavioral disclosure. It only states the action ('Create a new leave') but does not disclose side effects, auth requirements, data validations, return values, or consequences of creation. This is a minimal mutation description with no additional behavioral context, similar to the update_drive example that scored 2.

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 with no unnecessary words. However, it essentially restates the tool name (passgage_create_leave) and adds no additional value beyond what the name already conveys. It is concise but not particularly informative, earning a middle score.

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

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

Given the tool has a nested free-form data object, no output schema, and no annotations, the description is far too sparse. It does not explain what a leave is, what fields are required, what the response structure looks like, or any constraints. This is inadequate for a create operation with a non-trivial payload, similar to the update_drive example that scored 2.

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

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

Schema description coverage is 100% (the single 'data' parameter has a description), so the baseline is 3. The tool description adds no extra parameter meaning, and the schema description itself is vague ('The data for creating the leave' with additionalProperties true). While the description doesn't help, the schema coverage meets the baseline threshold.

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 'Create a new leave' clearly states the verb (create) and the resource (leave), making the tool's purpose unambiguous. It distinguishes from sibling tools by naming the specific resource, though it doesn't elaborate on what a 'leave' entails. This is comparable to the 'Update shared drive settings' example, which received a 4.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention prerequisites, typical scenarios, or exclude cases (e.g., when to use update_leave instead). With sibling tools like list_leaves, get_leave, update_leave, and delete_leave, the lack of usage context is a clear gap.

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

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

With no annotations, the description carries the full burden. It only says 'Create a new leave_rule', which implies a write operation but provides no details about required authentication, side effects, idempotency, or response 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, efficiently worded sentence that is easy to parse. However, it is under-specified, so it does not fully earn its place, though it is not verbose.

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

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

The tool has an unstructured data parameter, no output schema, and no annotations. The description provides no information about required fields, expected response, or operational prerequisites. This is inadequate for an agent 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 100% for the single 'data' parameter, so the baseline is 3. The description adds no parameter details, and the schema itself is vague (open object with additionalProperties true), but the high coverage prevents a lower score.

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

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

The description states the action 'Create' and the resource 'leave_rule', which clearly indicates the tool's purpose and distinguishes it from list, get, update, and delete siblings. However, it is minimal and essentially restates the tool name without adding further context.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., update_leave_rule) or any prerequisites. The description simply repeats the create action without contextual instructions.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'Create a new leave_type', which implies a mutating operation but offers no details on side effects, idempotency, validation requirements, or return values. This is a significant gap for a create 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 is efficient and easy to parse. However, it is overly minimal and sacrifices useful detail; it is concise but not necessarily appropriately sized given the tool's complexity.

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 an output schema and annotations, and with a vague free-form object parameter, the description is not complete enough. It fails to explain what a leave_type requires, what the response will look like, or any constraints, leaving the agent under-informed for successful invocation.

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

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

The input schema's 'data' parameter has a generic description ('The data for creating the leave_type') and allows additional properties, providing high schema coverage. The tool description adds no further meaning about the expected structure or required fields, so it stays at the baseline of 3.

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

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

The description 'Create a new leave_type' clearly states the action (create) and resource (leave_type), distinguishing it from the list/get/update/delete siblings for the same resource. However, it does not provide any additional context about what a leave_type is, making it somewhat generic compared to more descriptive tool definitions.

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 creating a leave rule or creating a leave. There are no mentions of prerequisites, permissions, or exclusions, so an agent cannot determine appropriate usage beyond the obvious intent implied by the name.

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

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

No annotations are provided, and the description offers no behavioral details such as required permissions, side effects, or validation rules. It merely states the action without disclosing any operational behavior.

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

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

One short sentence, no redundancy, and the key action is front-loaded. Efficiently sized for the limited information it conveys.

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

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

Given the tool's complexity (nested data object, no output schema, no annotations), the description is incomplete. It doesn't explain the structure of 'data' or what constitutes a night_work, leaving significant gaps for an agent.

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

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

The input schema provides 100% coverage for the single 'data' parameter, so the baseline is 3. The description adds no parameter-level detail, and the schema's own description is generic, but the baseline holds given the high coverage.

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

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

The description 'Create a new night_work' clearly states the action and resource, distinguishing it from sibling create tools by resource name. However, it doesn't explain what a night_work is, relying on the tool name for domain context.

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

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

No guidance is given on when to use this tool versus alternatives. It doesn't mention related night_work operations (get/update/delete) or any prerequisites, leaving the intended usage implied but not explicit.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It only states 'Create a new organization_unit', which merely repeats the tool name. It does not mention side effects, required data fields, authentication needs, or response behavior, making it inadequate for an agent to anticipate consequences.

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 unnecessary words. It is front-loaded and concise, earning a perfect score for brevity and structure.

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

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

This tool has no output schema and no annotations, and the description fails to explain what an organization_unit is, what data structure is expected in the 'data' object, or what response to expect. For a create operation with an open-ended object parameter, the description is critically incomplete for an agent to invoke correctly.

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

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

Schema description coverage is 100% because the sole 'data' parameter has a description, though it is generic ('The data for creating the organization_unit'). The tool description adds no further parameter guidance, so baseline 3 is appropriate. However, the schema's additionalProperties:true and lack of field details mean the description could have compensated but did not.

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

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

The description 'Create a new organization_unit' uses a specific verb (Create) and a clear resource (organization_unit), distinguishing it from sibling tools like update, get, delete, and list. It directly states the tool's primary action.

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

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

The description provides no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. It is not misleading, but it offers zero context for selection or invocation.

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 only says 'Create a new payroll', which just restates the tool's name, without mentioning required permissions, side effects, data validation, or expected response format.

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

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

The description is a single concise sentence with no redundant words. However, its extreme brevity borders on under-specification, but that is more a completeness issue than a conciseness one.

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 is far too minimal for a create operation with a nested, flexible data object. It does not describe the payroll structure, required fields, potential errors, or return value, leaving the agent with almost no context to invoke the tool correctly.

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

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

The schema has one 'data' parameter with a generic description, and the tool description adds no additional meaning. The parameter allows additionalProperties true, so the agent has no idea what structure the 'data' object should have, making the semantics effectively undefined.

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

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

The description uses a specific verb ('Create') and resource ('payroll'), clearly distinguishing it from sibling payroll tools like update_payroll, get_payroll, and delete_payroll. It directly states what the tool does.

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

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

No guidance is given on when to use this tool versus alternatives, such as updating an existing payroll or prerequisites for creating one. The only implied usage is the literal meaning of 'create', which is not sufficient.

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

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

With no annotations and a description that only restates the action, there is zero disclosure of behavioral traits such as permissions, side effects, uniqueness constraints, or what happens on success. The description fails to provide any context beyond what the tool name implies.

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

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

The description is a single, concise sentence with no filler. However, given the opaque 'data' object and lack of any other documentation, it is too terse to be genuinely useful. It earns a mid score for brevity but loses points for under-specification.

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 a complex nested object parameter and no output schema, yet the description provides no information about the structure of the shift data, required fields, or expected response. This is incomplete for an agent to invoke the tool correctly in a real scenario.

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

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

The input schema has one parameter 'data' described as 'The data for creating the shift', but this is vague and offers no field-level information. The tool description adds no further meaning, leaving the agent without any clue about what properties are required to define a shift. Despite 100% schema description coverage, the description quality is insufficient.

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 'Create a new shift' uses a specific verb and resource, making it clear that this tool creates a shift entity. It distinguishes itself from sibling create tools by naming the resource, though it lacks additional scope or context about what a shift is.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention whether to use this for creating new shifts as opposed to updating or listing, nor does it provide prerequisite conditions or context about the shift lifecycle.

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, and the description offers no behavioral context beyond the basic 'create' action. It doesn't mention side effects, required data, permissions, or what happens on success/failure, leaving the agent with no useful safety or execution insights.

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 directly states the tool's purpose. It avoids any unnecessary fluff, though it may be too sparse for complex usage.

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

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

Despite the simplicity of the tool (one data object), the description fails to convey what a shift_setting is or what fields the data object should contain. With no output schema and no annotations, an agent cannot construct a valid create request confidently, making the description inadequate for effective use.

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

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

Schema description coverage is 100% for the single parameter 'data', but the description is generic ('The data for creating the shift_setting') and the object allows arbitrary properties. The tool description adds no field-level guidance, so it stays at the baseline for high schema coverage.

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

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

Description clearly states the action ('Create') and the resource ('shift_setting'), distinguishing it from sibling tools like update, delete, get, and list for the same resource.

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

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

No guidance is provided on when to use this tool versus alternatives, prerequisites, or typical use cases. The name implies creating a new shift_setting, but there is no explicit context or exclusion.

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 must carry the full burden of disclosing behavioral traits. It does not mention side effects, required permissions, validation, defaults, or the structure of a successful response. The agent gets no insight into what 'creating a slack' entails.

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, so it is concise in word count. However, it lacks essential content, making it under-specified rather than appropriately concise. It earns a mid-range score because it is not verbose but also does not adequately inform.

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 nested object parameter with no meaningful schema, no output schema, and no annotations, this description is severely incomplete. It does not explain what 'slack' is, what fields the 'data' object should contain, or what the expected outcome is. The tool cannot be reliably used based on this description alone.

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

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

The schema has one parameter 'data' with the description 'The data for creating the slack', which is tautological and uninformative. Although schema description coverage is 100%, the tool description adds no parameter meaning, and the schema's own description does not clarify what fields are needed. The agent remains clueless about how to construct a valid request.

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

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

The description uses the specific verb 'Create' and identifies the resource as 'a new slack'. While 'slack' is not defined, the sibling tools list_slacks, get_slack, update_slack, and delete_slack clearly indicate it is a distinct resource type. This differentiates it from sibling CRUD actions.

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

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

The description provides no guidance on when to use this tool versus its alternatives (e.g., update_slack or delete_slack). It also lacks any prerequisites, context, or scenarios where creation is appropriate. 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?

There are no annotations, and the description carries the full burden of behavioral disclosure. It merely restates the action 'create' without mentioning side effects, required permissions, potential errors, or any operational caveats, offering zero transparency beyond what the tool name implies.

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

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

The description is a single, front-loaded sentence that is extremely concise. It earns points for brevity, though the lack of any additional structure or elaboration makes it feel under-specified rather than efficiently comprehensive.

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

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

For a create tool with a generic data object, no output schema, and no annotations, the description provides no context about required input structure, return values, or error handling. It is inadequate for an agent to understand what constitutes a valid request, offering only the most basic intent.

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

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

The schema has a single 'data' object with additionalProperties true, and both the schema and description are tautological ('data for creating the sub_companie'). The description adds no field-level semantics, no required fields, nor examples, so it fails to compensate for the schema's vagueness despite having 100% coverage.

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

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

The description 'Create a new sub_companie' uses a clear verb and resource, accurately indicating a create operation. It is unambiguous when compared to sibling tools like list/get/update/delete, but it does not elaborate on what a sub_companie is or how this differs from other create tools.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives (e.g., update, delete). While the verb 'create' implies a new entity, there is no mention of prerequisites, conditions, or contrasting with sibling operations.

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

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

With no annotations provided, the description carries full responsibility for disclosing behavioral traits. It gives no information about side effects (e.g., creating a user may trigger emails, audits, or permissions), required authentication, potential errors, or reversibility. The simple statement 'Create a new user' is entirely opaque.

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

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

The description is extremely brief, but this is under-specification rather than appropriate conciseness. It consists of a single sentence that merely restates the tool's name without adding any informative content. There is no detail about input, output, or constraints, making it an inadequate description despite its brevity.

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

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

The tool has one parameters object with arbitrary properties, no output schema, and no annotations, so the description must provide sufficient context for correct use. The description 'Create a new user' is grossly insufficient; it fails to explain required data fields, validation rules, response format, or any operational context needed for an agent to invoke the tool correctly.

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

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

The input schema describes the single 'data' parameter as 'The data for creating the user' with additionalProperties allowed, giving 100% schema description coverage. However, the tool description adds no meaning beyond the schema, leaving the actual required fields and structure of 'data' completely unspecified. The baseline of 3 applies because the schema covers the parameter, but the description offers no additional semantic help.

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 'Create a new user' is a direct restatement of the tool name 'passgage_create_user', adding no additional detail or context. It does not specify any scoping, special behavior, or distinguish this tool from the many other create_* sibling tools.

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

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

The description provides no guidance on when to use this tool versus alternatives such as passgage_update_user or passgage_list_users. There are no prerequisites, no notes on authentication, and no mention of how this relates to other user management operations.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only states 'Create a new user_extra_work,' implying mutation but omitting any information about permissions, side effects, validation rules, or return values. This is a significant transparency gap for a create 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, front-loaded sentence with no redundant words. It is highly concise but perhaps too sparse to be genuinely helpful; nevertheless, structure and brevity are appropriate.

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

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

For a create tool with a free-form 'data' object, no output schema, and no annotations, the description is insufficient. It does not explain what fields are expected, what the response will be, or any business rules. The agent would have to rely on external knowledge to use this tool correctly.

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

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

Schema coverage is 100% with a single 'data' parameter that has a description. The description adds no additional meaning about the parameter contents or structure. Per the rubric, baseline is 3 when schema coverage is high and description does not compensate for the vague free-form object.

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

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

The description clearly states the action ('Create') and the target resource ('user_extra_work'), which is a specific verb+resource pair. It distinguishes this from sibling tools like list/get/update/delete for the same resource, though it lacks any additional context about what a user_extra_work is.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, conditional use cases, or related tools such as update/delete for user_extra_work, so the AI agent receives no direction on tool selection.

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

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

With no annotations provided, the description must disclose behavioral traits, but it only states 'Create a new user_rate.' It implies a write operation but fails to mention side effects, required permissions, error conditions, or response behavior. This is a significant gap for a mutation tool.

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

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

The description is one short sentence and is front-loaded, but it is under-specified. It is concise in length but conveys almost no useful information, so it does not earn its place as a valuable description.

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 a single generic data object. The description fails to explain what a user_rate is, what fields are expected, or what the outcome of creation is. This is inadequate for a CRUD create 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% for the single 'data' parameter, so the baseline of 3 applies. However, the description adds no meaning beyond the schema, and the schema itself is generic with additionalProperties true, offering little guidance on what the data should contain.

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 'Create a new user_rate' essentially restates the tool name without providing any additional insight into what a user_rate is or how this tool differs from other create tools. It specifies a verb and resource but adds no new information, making it nearly a tautology.

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

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

No guidance is given on when to use this tool versus alternatives such as passgage_create_user or other create operations. There is no mention of prerequisites, context, or exclusions, leaving the agent without direction on tool selection.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only restates the tool's name. It does not mention auth requirements, side effects, idempotency, or response format, leaving the agent uninformed about the operation's 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 extremely concise, consisting of a single short sentence with no redundant words. However, its brevity comes at the cost of omitting crucial contextual information, so it is concise but overly sparse.

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

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

Given the tool's complexity (an open 'data' object with additionalProperties true), the absence of an output schema, and the large set of sibling tools, the description is severely incomplete. It does not explain what a user_shift is, what fields to provide, or what to expect in 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 input schema has a single 'data' parameter described as 'The data for creating the user_shift', and schema coverage is 100%. The description adds no additional parameter details, so it meets the baseline for high schema coverage but does not enhance understanding of the data object's structure.

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 ('Create') and the resource ('user_shift'), making the tool's purpose immediately clear. However, it does not elaborate on what a user_shift is or how it differs from related tools beyond the name, so it stops short of a 5.

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

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

The description provides no guidance on when to use this tool versus the many sibling create/update tools, nor does it mention prerequisites or related operations like assign_user_to_shift. There is no context for when this is the appropriate choice.

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 merely says 'Create a new working_day' without mentioning side effects, required authentication, return format, or any consequences of misuse. This is a mutation tool, so the lack of transparency is a serious gap.

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

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

The description is one sentence and front-loaded, but it is under-specified rather than concise. It omits critical information, so its brevity is counterproductive. An agent would need far more detail to invoke the tool correctly.

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

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

For a create operation with no output schema, no annotations, and an opaque parameter object, the description is severely incomplete. It does not explain what a working_day is, what data to provide, or what will happen. The agent cannot reliably use this tool based on the information given.

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 'data' is described as 'The data for creating the working_day', which is essentially circular and adds no meaning beyond the schema's placeholder. The schema allows arbitrary additional properties, but neither the schema nor the description explains what fields are expected. The description fails to compensate for this 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?

The description states 'Create a new working_day', which is a direct restatement of the tool name and adds no new information. It does not distinguish this tool from the many other create_* sibling tools, so it functions as a tautology rather than a meaningful purpose statement.

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

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

No guidance is given on when to use this tool versus alternatives. There is no mention of context, prerequisites, or why an agent might choose this over related tools. The description leaves the agent without any decision-making information.

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 fully disclose behavior. It only states the delete action, but does not mention irreversibility, permission requirements, cascade effects, or return value.

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

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

The description is a single, clear sentence with no filler. It is concise and gets to the point.

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

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

Given the low complexity (one param, no output schema), the description covers the basic action, but it misses important context about expected response, error handling, or side effects that an agent would need.

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 fully documents the id parameter (100% coverage) with description 'The UUID of the access_zone to delete'. The description merely echoes this, adding no additional meaning about parameter constraints, formats, or examples.

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 (access_zone) and specifies the key identifier (by ID). This distinguishes it from sibling tools that delete other resources.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. It simply 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?

With no annotations provided, the description carries full responsibility for behavioral transparency. It states the action (delete) but does not disclose whether deletion is permanent, whether it has cascading effects on related data, or whether special permissions are required. This is a significant gap for a destructive 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, front-loaded sentence with no filler words. It immediately states the action and resource. Despite a minor grammar error, it is highly concise and well-structured.

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

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

The tool is very simple (one parameter, no output schema), so the description covers the core invocation details. However, it omits any mention of deletion semantics (permanence, cascading effects) and the expected return value, leaving the agent without full context for a destructive operation. This meets the minimum viable level but leaves clear gaps.

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

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

The input schema fully documents the only parameter (`id` as the UUID of the approval), so the description's 'by ID' adds little new information. With 100% schema coverage, a baseline score of 3 is appropriate.

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

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

The description uses a specific verb 'Delete' and specifies the resource 'approval' with the method 'by ID', clearly distinguishing it from sibling tools like passgage_delete_approval_flow and passgage_delete_user. The grammar error ('a approval') is minor and does not obscure meaning.

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

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

The description provides no explicit when-to-use or when-not-to-use guidance. Usage is implied by the tool name and the CRUD pattern visible in sibling tools, but there is no mention of alternatives (e.g., if deleting an approval flow, use a different tool). This meets the minimum viable threshold for implied 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 for disclosing behavioral traits. It only says 'Delete' and 'by ID' without mentioning permanence, authorization needs, cascading effects, or error behavior. This provides minimal transparency beyond the action itself.

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 communicates the core purpose with no wasted words. It is front-loaded and efficient, though it lacks expansion on usage.

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

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

Given this is a simple one-parameter delete operation, but with no annotations, no output schema, and minimal behavioral detail, the description is insufficient for an agent to fully understand the tool's side effects or expected response. It needs at least notification that deletion is permanent or confirmation behavior.

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

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

The schema already documents the 'id' parameter with a description, and the description mentions 'by ID' without adding new meaning. Since schema coverage is 100%, the description does not need to elaborate further.

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'), the target resource ('approval_flow'), and the method ('by ID'). This distinguishes it from sibling tools like passgage_delete_approval, which targets a different resource.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. It simply states what it does, so usage is implied rather than explicitly defined.

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

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

With no annotations, the description must carry the full burden. It states the delete operation but does not disclose that deletion is permanent, whether there are side effects like cascading deletes, or any permission requirements. This is a minimal disclosure for a destructive 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 with no unnecessary words, making it concise and front-loaded. However, it contains a minor grammatical issue ('a assignment_request' instead of 'an assignment_request') and is slightly too terse to convey any safety or usage nuance.

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 delete tool with one fully described parameter, the description is technically sufficient to invoke the tool. However, the lack of annotation and absence of behavior details (e.g., permanence or error handling) leaves the agent without full context. Given the simplicity of the tool, a score of 3 seems fair.

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

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

The input schema covers 100% of the parameters, with the property description 'The UUID of the assignment_request to delete' already explaining the id parameter. The tool description adds no additional meaning beyond the schema, so the baseline score of 3 applies.

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

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

The description 'Delete a assignment_request by ID' clearly states the action (delete), the resource (assignment_request), and the identifier used (ID). This distinguishes it from sibling tools like create, update, and get assignment_request.

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: use this tool when you need to delete an assignment_request by its ID. However, it provides no explicit guidance on prerequisites, when not to use it, or alternatives (e.g., if a soft-delete is needed).

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only states 'delete' and does not mention permanence, side effects, authorization requirements, or response 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 sentence with no wasted words. It is front-loaded with the verb and directly states the essential information.

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

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

The tool is simple (one required parameter, no output schema, no annotations) and the description covers the core action and target. However, it lacks any mention of return values or broader behavioral context, making it minimal but acceptable.

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 fully describes the single 'id' parameter as 'The UUID of the branche to delete' (100% coverage). The description adds no extra semantic detail, but the schema already provides the necessary meaning, so baseline 3 applies.

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

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

Description clearly states the delete action and the target resource (branche) by ID. This distinguishes it from sibling get/create/update/list branch tools.

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

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

Usage is implied by the delete verb and resource name, but there is no explicit statement about when to use it versus alternatives, nor any prerequisites or exclusions. For a simple CRUD delete, the context is inferable but not explicitly 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 simply says 'Delete a branch_group by ID' without mentioning whether the deletion is permanent, if there are any side effects, authorization requirements, or what happens if the branch_group does not exist. This is a significant gap for a destructive 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 that directly states the operation and target. It is appropriately concise with no wasted words, making it easy to parse and understand 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 delete operation with one parameter and no output schema, the description is minimally adequate. It states what the tool does, but it lacks context about the consequences of deletion, any dependencies, or return values. Since no annotations compensate, the description could do more to fully inform the agent.

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

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

The input schema already provides 100% coverage for the single parameter, including a description of 'id' as the UUID. The description adds no additional meaning beyond 'by ID', so it meets the baseline for full schema coverage without adding extra context.

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

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

The description 'Delete a branch_group by ID' clearly states the verb (Delete) and the resource (branch_group), and it distinguishes this tool from siblings like get_branch_group, create_branch_group, and update_branch_group by specifying the delete action and the ID 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?

The intended use is implied by the tool name and description: to delete a specific branch_group. However, the description does not explicitly state when to use this tool versus alternatives, nor does it provide any prerequisites or exclusion criteria.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It simply states 'Delete a card by ID' without mentioning whether deletion is permanent, whether it requires specific permissions, whether it has cascading effects, or how errors are handled. This is minimal and leaves the agent unaware of important consequences.

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, succinct sentence that immediately conveys the action and scope. No filler or redundant information.

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

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

While the tool is simple with one parameter, the absence of annotations and an output schema places the burden on the description to provide context. It fails to mention side effects, success/error behavior, or when deletion is appropriate, leaving a substantial gap for an irreversible operation.

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

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

The schema already fully documents the single 'id' parameter with description 'The UUID of the card to delete' (100% coverage). The description adds no additional semantic meaning beyond restating that the deletion is by ID, so it does not exceed the baseline.

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

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

The description clearly states the action (delete) and the target resource (card) with the required identifier (by ID). It distinguishes from sibling delete tools by naming the card resource, and adds the specific detail that deletion is by ID.

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

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

No guidance is provided about when to use this tool versus alternatives such as update_card or other delete tools. The usage is only implied by the tool name, but there are no explicit conditions, prerequisites, or exclusions.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It states the destructive action but does not mention potential consequences like cascading deletes, irreversibility, or error behavior. This is a significant gap for a delete operation.

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

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

The description is a single clear sentence with no filler or redundant information. 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?

Given that this is a destructive tool with no annotations, output schema, or additional context, the description is underspecified. It fails to inform the agent about likely side effects, required permissions, or the expected response, which could lead to misuse.

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 describes the only parameter 'id' fully with format (UUID), achieving 100% schema description coverage. The description adds no extra meaning beyond 'by ID', so it does not compensate beyond the schema baseline.

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

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

The description uses a specific verb ('Delete') and resource ('department') with an identifier, making the action unambiguous. It clearly distinguishes from sibling tools like list, get, create, and update department.

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

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

The description clearly implies use when a department must be removed by ID, providing sufficient context. It does not explicitly list alternatives or exclusions, but the purpose and naming convention already differentiate it from other operations.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'Delete' which implies destruction, but does not state that deletion is permanent, whether it requires authentication, or what happens if the device is not found.

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

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

The description is a single, clear sentence with no extraneous words. It is appropriately front-loaded and conveys the essential information 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 description is minimal, providing no information about return values, side effects, or prerequisites. For a delete operation with no annotations or output schema, this is insufficient context for an agent to fully understand the tool's implications.

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

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

The schema already provides a clear description for the only parameter 'id'. The description's 'by ID' adds no new semantic information beyond the schema, so it meets the baseline but does not exceed it.

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), the resource (device), and the method (by ID). It distinguishes itself from sibling tools like passgage_get_device or passgage_update_device by specifying the delete operation for this particular entity.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor any prerequisites or context. It simply restates the action implied by the name, leaving the agent to infer that deletion is the intended 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?

The description only repeats the verb 'Delete' which is already in the tool name. With no annotations provided, the description carries the full burden of disclosing behavioral traits like permanence, permissions, or side effects, but it fails to provide any additional context. This leaves the agent unaware of the destructive consequences.

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

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

The description is a single concise sentence, front-loaded with the verb 'Delete' and the target resource. It contains no unnecessary words and is easy to parse.

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

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

For a simple one-parameter delete tool, the description provides the essential action and target, but it lacks critical context such as irreversibility or side effects. Without annotations, this leaves a moderate gap in understanding, making it minimally viable but not thorough.

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

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

The input schema already fully describes the single 'id' parameter as 'The UUID of the entrance to delete', covering 100% of parameter semantics. The description aligns by saying 'by ID' but adds no new meaning beyond the schema.

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

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

The description uses the specific verb 'Delete' with the resource 'entrance' and method 'by ID', clearly distinguishing it from sibling tools like get_entrance, create_entrance, update_entrance, and track_entrance. Despite a minor grammatical error ('a entrance'), it unambiguously states the tool's function.

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 update_entrance or soft-delete options. The description simply states the action without any context, not mentioning that deletion is likely irreversible or that it should be used only when an entrance is permanently no longer needed.

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 only states the delete action but does not mention whether deletion is permanent, any cascading effects, or what the response contains.

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 is front-loaded with the action and resource. No redundant information is present.

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 an output schema and annotations, the description should explain the deletion outcome or any side effects. It does not mention whether the operation is idempotent, what happens on non-existent ID, or the return value, leaving the agent with insufficient context.

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

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

The schema already describes the 'id' parameter as 'The UUID of the holiday to delete', providing full coverage. The description adds no additional meaning beyond confirming the deletion is by 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 clearly states the action (delete) and the target resource (holiday), with scope 'by ID'. It distinguishes from sibling tools like get_holiday, update_holiday, and list_holidays by specifying the delete operation.

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

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

The usage is implied: use this tool when you want to delete a holiday. However, it provides no explicit guidance on when deletion is appropriate, prerequisites, or alternatives like update_holiday.

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 only states 'Delete a job_position by ID' and does not reveal whether deletion is permanent, irreversible, cascades to related records, requires specific permissions, or what happens if the ID does not exist. This is a significant transparency gap for a mutation 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, front-loaded sentence with no superfluous words. It immediately communicates the action, resource, and method, earning its place without repetition 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?

For a simple one-parameter delete tool, the description is minimally adequate, but it lacks any information about return values, success/error behavior, or side effects. Since there is no output schema and no annotations, the agent must infer these from the tool name alone, leaving notable gaps for a real-world invocation.

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

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

The input schema provides a complete description for the 'id' parameter ('The UUID of the job_position to delete'), giving 100% schema coverage. The description's 'by ID' aligns with the schema but adds no additional meaning beyond what the schema already provides, so the baseline of 3 applies.

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

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

The description 'Delete a job_position by ID' clearly states the specific action (delete), the resource (job_position), and the method (by ID). This unambiguously distinguishes it from sibling tools like create, update, get, and list for the same resource.

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

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

The description implies when to use the tool (when deleting a job_position by ID) but provides no explicit guidance on when not to use it, such as alternatives like deactivating via update or checking for dependencies. The sibling tool names make the primary use case obvious, but no exclusions or prerequisites are stated.

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

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

No annotations are provided, so the description carries the full burden. It states 'Delete' which implies destructive behavior, but it does not disclose consequences like irreversibility, cascading effects, or permission requirements beyond what 'delete' implies.

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

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

The description is a single concise sentence that conveys the essential purpose without any wasted words. It is perfectly sized for the simplicity of the tool.

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

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

For a one-parameter delete tool with no output schema, the description is sufficient. It states the action and the required input, and the simplicity of the tool means no additional behavior needs explanation. Lack of notes on idempotency or errors is minor given the straightforward nature.

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

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

The input schema already fully describes the 'id' parameter as 'The UUID of the leave to delete' (100% coverage). The description simply repeats 'by ID' without adding additional semantics, 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 'Delete a leave by ID' clearly states the action (delete) and the resource (leave), with the scope defined by ID. It distinguishes from sibling delete tools by specifying the leave resource.

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

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

No guidance is provided about when to use this tool over alternatives, such as update_leave for modifying instead of deleting, or delete_leave_type for a different entity. The context is implicit from the name.

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

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

The description discloses that the operation is a delete, which is inherently destructive, but it does not mention any consequences such as irreversibility, cascade effects, or permission requirements. With no annotations to supplement, the description falls short of explaining the behavioral implications of the deletion.

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 delivers the essential information with no extraneous words. It is appropriately sized for a simple delete operation with one parameter.

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 straightforward delete operation with one parameter and no output schema, the description is minimally adequate. However, it lacks any notes on permanence, side effects, or typical usage context, which would round out the picture for an agent deciding whether to invoke this tool.

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

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

The schema alone describes the 'id' parameter as 'The UUID of the leave_rule to delete', covering its meaning fully. The description's phrase 'by ID' adds no new information beyond this, so it does not enhance the schema's parameter documentation. Given the high schema coverage, a baseline score of 3 is appropriate.

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

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

The description clearly states the action (Delete), the resource (leave_rule), and the key identifier (by ID). It effectively distinguishes this tool from sibling delete operations by naming the specific resource type, leaving no ambiguity about what it does.

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

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

No guidance is provided on when to use this tool versus alternatives or when not to use it. There is no mention of prerequisites, safety checks, or conditions that should be met before deletion. The usage is only implied by the obvious action described.

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 must carry the burden of behavioral disclosure. It only says 'Delete a leave_type by ID' and does not mention whether deletion is permanent, whether an ID is required to exist, what happens to references, or any authorization needs. The safety profile is entirely opaque.

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

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

The description is a single, front-loaded sentence that immediately conveys the verb and object. It contains no filler or redundant information, making it extremely concise and well-structured.

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

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

Given the simplicity of the tool (one parameter, no output schema), the description provides the minimal information needed to know what the tool does. However, it omits any side effects, return behavior, or conditions for deletion, which leaves some context gaps despite the straightforward nature of the operation.

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

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

The input schema already fully documents the single required parameter 'id' as 'The UUID of the leave_type to delete', so schema coverage is 100%. The description adds no additional parameter meaning beyond restating 'by ID', which warrants the baseline score of 3.

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

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

The description 'Delete a leave_type by ID' clearly states the action (delete) and the resource (leave_type), with the specific scope of deletion by ID. It distinguishes this tool from sibling delete tools by naming the exact resource type.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention prerequisites, consequences (e.g., permanence, cascading effects), or situations where deletion might be disallowed. It only states the basic action.

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 simply states the action but does not disclose that deletion is permanent, whether it requires special permissions, or what happens to related data. The minimal phrase 'Delete a night_work by ID' adds no context beyond the action itself.

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 is front-loaded with the action and resource. Every word earns its place; there is 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?

For a simple single-parameter delete operation with no output schema, the description and schema are sufficient to understand its purpose and required argument. However, the lack of any mention of side effects or irreversibility makes it slightly less complete than ideal, but not critically deficient.

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 provides 100% coverage for the single parameter 'id' with a clear description ('The UUID of the night_work to delete'). The tool description adds no extra parameter information beyond what the schema already states, so the baseline score of 3 is appropriate.

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

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

The description 'Delete a night_work by ID' uses a specific verb (Delete) and resource (night_work) and clearly references the required parameter. It unambiguously distinguishes this from sibling tools like get_night_work or update_night_work.

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 explicit guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or consequences. The agent must infer usage solely from the verb 'Delete' and the resource name, with no exclusions or alternative recommendations.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'Delete' but does not indicate that the operation is permanent, irreversible, or potentially cascading to related data. This lack of detail is a significant gap for a destructive action.

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

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

The description is one short sentence without any superfluous words or information. It is front-loaded and 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?

Although the tool is simple with one well-documented parameter, the description lacks important contextual information about the destructive nature of the operation, such as irreversibility or potential side effects. This is a minimal but not fully complete description for a delete action.

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 single parameter 'id' is described as 'The UUID of the organization_unit to delete'. The description adds no further meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description clearly states the action (Delete), the resource (organization_unit), and the method (by ID). It unambiguously distinguishes this tool from other organization_unit operations like create, get, or 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?

There is no guidance on when to use this tool relative to alternatives, nor any mention of prerequisites or situations where deletion should be avoided. The description simply states the action without contextual usage instructions.

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 the destructive action without disclosing behavioral traits such as irreversibility, cascading deletes, permission requirements, or error handling. The agent gets no information beyond the tool's name.

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

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

The description is a single concise sentence with no redundant information, perfectly sized for the 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?

While the tool is simple, the description lacks critical context such as success/failure responses, irreversibility, and any side effects. No annotations or output schema help, so the description is insufficient for an agent to fully understand the tool's behavior.

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

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

The schema fully documents the single 'id' parameter with type and description, and the description's 'by ID' adds no additional semantic value. Baseline of 3 applies due to 100% schema coverage.

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

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

The description clearly identifies the operation (delete) and the resource (payroll), adding the method 'by ID'. It unambiguously distinguishes it from sibling CRUD tools for other resources.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., update_payroll or delete other resources). The usage is implied by the tool name, but the description offers no explicit context or exclusions.

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

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

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It only states the literal deletion action but does not mention whether deletion is permanent, irreversible, requires authentication, or affects related records. This is a significant gap for a destructive 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 one short sentence, front-loaded with the action and resource, and contains no unnecessary words. It is appropriately concise for a simple delete 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 the simplicity of the tool (one parameter, no output schema), the description adequately explains what it does and how to invoke it. It is complete enough for the basic use case, though it lacks depth in behavioral context, which is already penalized in that dimension.

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

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

The input schema has 100% description coverage for the single parameter 'id' as 'The UUID of the shift to delete'. The description adds no additional meaning beyond the schema, so the baseline of 3 applies.

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

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

The description 'Delete a shift by ID' clearly states the action (delete), the resource (shift), and the method (by ID). It distinguishes from sibling tools like create_shift, update_shift, get_shift, and list_shifts by indicating deletion.

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

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

The description implies when to use the tool (when a shift needs to be deleted), but it does not explicitly state alternatives or conditions such as 'use update_shift to modify instead' or mention prerequisites like existing shift must exist. Context is implied but not detailed.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does not mention that deletion is permanent, any side effects on related data, permission requirements, or error behavior if the ID doesn't exist. It only restates the operation without additional 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 that conveys the core purpose with no wasted words. It is appropriately front-loaded and easy to parse.

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

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

For a destructive operation with no annotations and no output schema, the description is under-specified. It lacks warnings about irreversibility, potential dependencies, or expected return behavior. Although the tool is simple with only one parameter, the description does not provide sufficient context for an agent to fully understand the consequences.

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

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

The input schema already fully describes the 'id' parameter with 100% coverage, stating it is the UUID of the shift_setting to delete. The description adds no extra meaning beyond 'by ID', which is redundant with the schema. Baseline 3 applies 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?

The description clearly states the action (delete), the resource (shift_setting), and the method (by ID). This distinguishes it from sibling tools like passgage_get_shift_setting, passgage_create_shift_setting, and passgage_update_shift_setting.

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

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

The usage is implied by the tool name and simple sentence, but there is no explicit guidance on when to use this tool versus alternatives, such as updating instead of deleting, or any prerequisites like existing shift_setting IDs. No exclusions or alternative recommendations 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 only states the delete operation and does not mention whether the delete is permanent, cascading, requires authentication, or returns any confirmation. This is a significant gap for a destructive action.

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

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

The description is a single concise sentence that directly conveys the tool's purpose without any filler. It is appropriately minimal for a simple delete operation with one parameter.

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

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

For a mutation tool with no annotations and no output schema, the description should explain side effects, permissions, or expected response. It does none of these, leaving the agent to guess whether the delete is a hard or soft delete, if it succeeds silently, and what errors may occur.

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 fully documents the only parameter 'id' as 'The UUID of the slack to delete', giving 100% schema coverage. The description's 'by ID' merely restates this, adding no new meaning or context about the parameter's origin, format constraints, or usage nuances.

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 'Delete a slack by ID' clearly states a specific action (delete) on a specific resource (a slack) using a specific identifier (ID). This distinguishes it from sibling tools like create_slack, update_slack, and get_slack, making it unambiguous.

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

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

The description provides no guidance on when to use this tool vs alternatives, such as when to update rather than delete, or any prerequisites like required permissions. The usage is implied by the action but no explicit context, exclusions, or alternative references are given.

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

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

There are no annotations, so the description must bear the full burden of behavioral disclosure. It states the tool deletes a sub_companie, but does not disclose whether the deletion is permanent, cascading, or requires special permissions. This lack of added context 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?

The description is a single, five-word sentence that clearly states the operation. It is appropriately sized and front-loaded with the verb, with 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?

For a simple delete operation with one well-documented parameter, the description covers the essential information: what is deleted and how to identify it. An output schema is not necessary, and no extra context is missing.

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

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

The input schema fully documents the single parameter 'id' with a description that says 'The UUID of the sub_companie to delete'. The tool description adds nothing beyond that, so 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 the imperative verb 'Delete' followed by the specific resource 'sub_companie' and the method 'by ID'. This clearly distinguishes it from sibling tools such as create_sub_companie, update_sub_companie, and get_sub_companie.

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

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

The description clearly indicates the tool is for deleting a sub_companie when you have its ID, but it does not mention when NOT to use it or suggest alternatives. However, the context is unambiguous given the CRUD naming convention.

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 behavioral traits. It only states 'delete' without mentioning irreversibility, cascading effects, permission requirements, or whether it is a hard or soft delete. This is insufficient for a destructive 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 with no unnecessary words. It is front-loaded with the verb and resource, making it extremely concise and easy to parse.

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

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

For a simple single-parameter delete, the description covers the core action. However, it lacks essential context such as whether the deletion is permanent, what the response is, or any side effects. Given no output schema and a minimal schema, this is adequate but not thorough.

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 provides a full description for the only parameter 'id' ('The UUID of the user to delete'), resulting in 100% schema description coverage. The description adds no new semantics beyond re-stating 'by ID', so baseline 3 applies.

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

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

The description clearly states the action (delete) and the resource (user), and identifies the parameter (by ID). It is unambiguous, but does not explicitly distinguish from other delete_* sibling tools, though the resource is self-evident from the tool name.

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

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

No guidance is provided on when to use this tool versus alternatives, nor any prerequisites or consequences. The intended usage is only implied by the action 'delete' and the resource 'user'.

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

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

With no annotations, the description carries the full burden. It only states 'Delete' but does not disclose whether deletion is irreversible, affects related data, requires specific permissions, or returns any confirmation. This is a significant gap for a destructive 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, clear sentence with no filler. It is appropriately sized for a simple one-parameter delete tool and front-loads 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?

For a destructive tool with no annotations and no output schema, the description is too sparse. It does not mention success/failure behavior, return values, or potential side effects. Even though the tool is simple, the missing information could lead to incorrect invocation or misunderstanding.

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

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

Schema coverage is 100% and the parameter's description already explains the ID is the UUID of the entity to delete. The tool description simply restates 'by ID' without adding any extra semantic nuance, so the baseline score of 3 applies.

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

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

The description clearly states a specific verb ('Delete') and a specific resource ('user_extra_work') identifiable by ID. It unambiguously distinguishes this tool from sibling CRUD operations like get, create, and update on the same resource.

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

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

The description implies usage: when you want to permanently remove a user_extra_work by its ID. However, it gives no explicit context, prerequisites, or alternatives, and does not mention when not to use it (e.g., if the record is referenced elsewhere).

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 only says 'Delete,' which implies destruction, but does not specify whether the deletion is permanent, cascading, or requires special permissions. It also doesn't disclose the response format or side effects, leaving critical behavioral traits undocumented.

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

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

The description is a single concise sentence with no filler or repetition. It efficiently conveys the tool's purpose without wasting tokens, 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?

Given the tool's simplicity (one parameter, no output schema), the description is mostly complete. It describes the action and the required ID. However, it omits any mention of the return value or confirmation of deletion, which could be useful for an agent to verify success. Still, for a straightforward delete operation, the description covers the essential context.

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

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

The input schema already describes the 'id' parameter as 'The UUID of the user_rate to delete,' achieving 100% schema description coverage. The description's mention of 'by ID' adds little beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description 'Delete a user_rate by ID' clearly states the action (delete), the resource (user_rate), and the method (by ID). It effectively distinguishes itself from sibling tools like get_user_rate, create_user_rate, and update_user_rate, making the tool's purpose unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives. It merely states the action without mentioning any context, prerequisites, or exclusions. For example, it doesn't clarify whether this should be used instead of update_user_rate for disabling a rate, leaving the agent without decision support.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It explicitly states the destructive action ('Delete') but fails to mention irreversibility, cascading effects, permission requirements, or any return behavior. This is minimal transparency for a deletion 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, clear sentence that efficiently conveys the essential action and target. It is well front-loaded and contains no unnecessary words, though it could include more context without significant cost.

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 delete tool with one well-documented parameter, the description is minimally viable. It covers the basic 'what' but lacks any behavioral caveats, usage context, or mention of side effects. Given the absence of annotations and output schema, more detail would improve completeness.

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

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

The schema already thoroughly documents the single 'id' parameter with type and description (UUID). The description adds no extra meaning beyond confirming the deletion is by ID. Since schema coverage is 100%, 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 clearly states the specific action (Delete) and the exact resource (user_shift) along with the method (by ID), making the tool's purpose unambiguous. It distinguishes itself from sibling delete tools like delete_user or delete_shift by targeting the user_shift resource directly.

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

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

The description provides no guidance on when to use this tool versus alternatives, no prerequisites, and no context about the deletion process. It only states what the tool does, leaving the agent with no situational cues for selection.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It simply says 'Delete' without conveying irreversibility, potential cascading effects, auth requirements, or any side effects. The verb implies destruction but lacks explicit warning.

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, directly stating the action and target. It contains no filler or redundant information, making it highly efficient.

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

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

For a one-parameter delete tool, the description covers the essential action and resource. However, it omits contextual details like whether the operation is irreversible, what happens if the ID doesn't exist, or any post-deletion effects. Given the simplicity, this is minimally adequate but not richly complete.

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

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

The schema fully documents the only parameter 'id' with a clear description. The description's 'by ID' reinforces the schema but adds no additional semantics beyond what the structured data already provides, so a baseline score of 3 is appropriate.

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

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

The description clearly states the action ('Delete') and the target resource ('working_day') with a specified lookup method ('by ID'). While it doesn't explicitly distinguish from delete operations on other resources, the resource name in the tool name and description makes it 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 regarding when to use this tool versus alternatives (e.g., when not to delete, prerequisites, or recovery options). It only states what it does, not when it should be chosen.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only says 'Export data'. It does not mention whether the operation is read-only, if it returns a file or URL, requires authentication, or has side effects like generating a server-side file.