Timix.AI

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

Without annotations, the description discloses key behaviors: the effect (period and time reports transition to Approved) and the preview-vs-execution mode via the confirm flag. It also mentions role restrictions, but does not discuss reversibility or potential failures. This provides solid transparency for the tool's 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 extremely concise: two sentences that front-load the core action and effect, then provide the confirmation signal and role requirement. No redundant words or sentences.

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

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

Given the lack of annotations and output schema, the description covers the core aspects: action, confirmation pattern, role constraint, and parameter sources. It does not detail error conditions or post-approval state transitions, but these are implicitly covered by the description's clarity.

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

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

Schema coverage is 100%, and the description adds meaning beyond the schema by explaining the confirm flag's preview behavior and the source for submission_period_id. The idempotency_key is described in the schema but not elaborated in the description, which is acceptable as the schema covers 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 uses a specific verb 'Approve' and resource 'submitted timesheet period', clearly differentiating it from sibling tools like reject_timesheet, recall_timesheet, and reopen_timesheet.

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 explains when to use the tool (to approve a submitted timesheet), how to confirm the action with confirm=true, and the required role (Manager or Admin/Owner, excluding Finance). It could further clarify when not to use it in favor of alternatives like reject, but the guidelines are clear and actionable.

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

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

No annotations provided. Description mentions fixed organization and privilege constraint but does not disclose consequences of reassignment, error states, or whether action is reversible. For a mutation tool, more transparency is expected.

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

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

Three concise sentences: action, requirements, constraint. Front-loaded with purpose, efficient, no redundant information.

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

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

No output schema. Description does not mention return value or success/error behavior. Lacks note on reversing assignment (sibling remove_user_from_customer exists). Adequate but could be more complete.

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

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

Schema coverage is 100%. Description adds value by clarifying the difference between org_user_id and Firebase user id, and provides discovery methods for org_user_id. Idempotency key is explained in schema but not elaborated 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?

Clear verb 'assign' with specific resource 'organization member to a billing customer' and outcome 'so they can see that customer and all its projects'. Distinguishes from sibling tool 'assign_user_to_project'.

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?

Specifies required parameters and how to discover the org_user_id using get_project_team or get_employee_timesheet. States organization is fixed by context and warns about privilege restrictions (cannot target more privileged user). Lacks explicit alternative for when not to use this tool.

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

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

With no annotations, the description carries the full burden. It discloses the effect (member sees project and logs time) and mentions idempotency_key for retry safety. It also notes the organization is fixed by context. Lacks details on permissions or reversibility, but sufficient for a straightforward assignment.

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

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

Two sentences with essential information front-loaded: purpose first, then parameter guidance. No unnecessary words or repetition.

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

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

Given no output schema or annotations, the description covers the main action, parameter selection, and idempotency. It does not describe return values or error handling, but for a simple assignment tool, this is adequate.

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

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

Despite 100% schema coverage, the description adds significant value: it clarifies that email is preferred over org_user_id, directs to use find_billing_work for project_id, and explains idempotency_key behavior. This goes beyond the schema's descriptions.

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

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

The description clearly states the tool assigns a member to a project, specifying the outcome ('so they can see it and log time against its tasks'). The verb 'assign' and resource 'member to project' are specific and distinguish it from siblings like assign_user_to_customer.

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

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

The description provides explicit guidance on when to use (to give project access and time logging ability), how to identify members (email preferred or org_user_id), and how to get the project_id (via find_billing_work, never ask user). It implies when not to use (e.g., if project_id unknown) but does not explicitly state 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?

Without annotations, the description carries the full burden of behavioral disclosure. It reveals that entries are always attributed to the caller, returns per-item results with partial failures, and specifies constraints like max 50 entries and default start_time. It covers idempotency via the key parameter, though the key's details are in schema. Missing concurrency info but adequate for batch create.

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

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

Three sentences, each earning its place: purpose, what to supply, and behavioral notes (attribution, partial failures, max). Front-loaded and no unnecessary words.

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

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

Given no output schema and no annotations, the description covers all key aspects: purpose, parameters, batch behavior, attribution, idempotency key reference, and constraints. Sufficient for an agent to understand and invoke the tool correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining defaults for 'start_time' (09:00), mentioning the max 50 entries, and describing partial failure behavior. This goes beyond just repeating schema descriptions.

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

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

The description clearly states 'Create multiple time entries in one call', specifying the verb (create), resource (time entries), and batching aspect. It distinguishes from sibling 'create_time_report' (single entry) and 'bulk_update_time_reports' (update).

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

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

The description indicates when to use this tool: for creating multiple entries efficiently in one call. It provides context like maximum batch size (50 entries) and partial failure behavior. However, it does not explicitly contrast with alternatives like 'create_time_report' for single entries.

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?

Discloses that rates are not echoed back and that the adjustment is effective from a date, but does not mention idempotency behavior (despite idempotency_key), whether adjustments are additive or overriding, or any authorization requirements. With no annotations, the description carries full burden but misses several important behavioral traits.

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

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

Two sentences with clear front-loading of purpose and constraints. No redundancy or fluff. Every sentence earns its place.

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

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

For a bulk update tool with no output schema, the description covers main action, parameters, and key constraints. Lacks details on return values (e.g., confirmation or status) and any asynchronous behavior, but is largely complete for selection purposes.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by clarifying mutual exclusivity of fixed_amount and adjustment_percentage, and reinforcing that organization id is never passed. Adds context beyond the schema descriptions.

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

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

Clearly states it applies an organization-wide adjustment to every member's hourly cost rate with a specific verb and resource. Distinct from sibling tools like set_user_cost_rate which operates on individual users.

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?

Explicitly instructs to supply EITHER adjustment_percentage OR fixed_amount, not both, and notes that organization is fixed by context so no id should be passed. Provides clear when-to-use and when-not-to-use guidance.

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

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

With no annotations, the description carries full burden. It discloses that partial failures are reported per-id rather than aborting, and implies a write operation. It could mention idempotency behavior or permissions but still adds meaningful behavioral context beyond the schema.

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

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

Three concise sentences: first states the main action, second lists required inputs with constraints, third explains failure handling. No unnecessary words, front-loaded with 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 no output schema, the description covers the key behavioral detail (per-id results, partial failures). It could mention the return format or idempotency behavior for completeness, but it is adequate for a simple bulk update 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 coverage is 100%, so baseline is 3. The description repeats the purpose of 'ids' and 'text' but adds little beyond schema, such as the ownership constraint for ids. It does not elaborate on 'idempotency_key' behavior. No significant added value for parameters.

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

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

Clearly states the action 'apply a common text description update to multiple of your own time entries'. The verb 'apply' and resource 'time entries' are specific. It distinguishes from siblings like 'update_time_report' (single) and 'bulk_create_time_reports' (create vs update) by highlighting the bulk update nature and ownership scope.

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

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

The description provides clear context for when to use (batch updating own time entries with same description) and the required inputs. However, it does not explicitly state when not to use or suggest alternatives like single-update tools, which is acceptable given sibling names but not excellent.

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 fully discloses behavior. It explains that the action is reversible (email can be re-invited), and describes the preview/confirm pattern with idempotency. This provides clear transparency beyond the schema.

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

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

The description is two sentences long, front-loaded with the core action, and contains no unnecessary information. Every sentence is valuable.

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

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

The description covers purpose, behavior (preview/confirm), and idempotency. Without an output schema, it does not describe return values, but that is acceptable. It could mention edge cases (e.g., cancelling an already cancelled invite), but overall it is complete for the tool's complexity.

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

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

Schema coverage is 100%, so baseline is 3. The description adds context about the preview return and idempotency, which complements the schema but does not significantly exceed what the schema already conveys.

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

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

The description clearly states the tool cancels a pending invitation, making the invite link invalid. It uses specific verb 'cancel' and resource 'invite', and distinguishes from siblings like invite_user and resend_invite by focusing on cancellation.

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 explains the cancellation action and notes that the email can be re-invited later, providing context. It also explains the preview/confirm mechanism. However, it does not explicitly state when to use this tool versus alternatives like resend_invite, though it is implied.

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

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

Discloses the destructive nature ('permanently delete') and the confirm requirement. No annotations are provided, so the description carries full burden; it could mention irreversibility or side effects but does not.

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

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

Two sentences, no superfluous words. The first sentence states the action and resource, the second adds the critical requirement. Front-loaded and 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?

Covers the purpose and the confirm requirement but lacks context on prerequisites (e.g., ownership, permissions), error behavior, and response format. With no output schema, some guidance on the return value 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?

Schema coverage is 100%, so baseline is 3. The description does not add meaning beyond the schema for 'id' or 'idempotency_key', and for 'confirm' it largely repeats the schema description. No additional parameter insight is offered.

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

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

Clearly states the action 'permanently delete' and the resource 'scheduled report definition'. Distinguishes from sibling tools like create_scheduled_report, update_scheduled_report, and list_scheduled_reports.

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

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

Provides a key usage guideline: requires confirm=true to proceed. However, it does not explicitly mention when not to use this tool or compare to other deletion tools, though the name makes the scope clear.

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

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

No annotations provided, so the description carries full burden. It discloses that the timer is discarded, no time entry is created, and elapsed time is lost. This adds behavioral context beyond the input schema.

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

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

The description is extremely concise with two sentences, front-loading the purpose and essential behavioral details. 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 tool with no required parameters and no output schema, the description fully covers the tool's behavior and outcome. The optional parameter is documented in the schema, so no gaps.

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

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

Schema description coverage is 100% for the single optional parameter. The description does not add new meaning beyond the schema; it states 'No arguments needed' which is slightly misleading given the optional idempotency_key, but not incorrect.

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 (cancel), the resource (running timer), and the outcome (no time entry, elapsed time lost). It distinguishes from siblings like stop_timer which presumably creates a time entry.

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 discard a timer without logging time. Though it doesn't explicitly mention when not to use or name alternatives, the context with sibling tools like stop_timer provides differentiation.

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?

Discloses two-step commit, idempotency key behavior, role assignment restrictions, and preview-commit semantics. No annotations exist, so description carries all disclosure burden; it does well.

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

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

Three concise sentences, front-loaded with main action, no redundant 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?

Covers two-step flow, constraints, and parameter details from schema. Lacks error behavior or timeout info, but overall sufficient for a role-change tool with moderate complexity.

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

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

Schema coverage is 100%, so baseline 3. Description adds context about constraints but does not add new parameter-level meaning beyond what schema provides.

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

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

Clearly states it changes a member's role, distinguishes from sibling tools like invite_user or remove_user, and mentions the two-step commit process and restrictions.

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

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

Provides explicit instructions for the preview-commit pattern and constraints (cannot assign Owner, cannot escalate beyond own role). Lacks explicit comparison to sibling tools but gives sufficient guidance for usage.

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

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

No annotations are provided, so the description carries full burden. It mentions the return value but does not disclose whether the operation is read-only, requires authentication, or has side effects. This is insufficient for a check 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 two sentences, no redundant words, and front-loaded with the action and purpose. Every sentence earns its place.

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

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

No output schema, so the description should elaborate on return format. It only says 'whether' and 'a message' without specifics (e.g., boolean, string structure). The description is adequate for a simple check but could be more complete regarding error cases or exact response fields.

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 descriptions for both parameters (sub_task_id and additional_hours) that are clear. The tool description adds no extra meaning beyond what the schema already provides, so baseline score of 3 is appropriate.

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

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

The description clearly states the verb 'Check' against the resource 'budget limits' of a subtask and mentions the return value ('whether the budget is exceeded and a message'). It is distinct from sibling tools like get_budget_alerts or get_budget_health, which serve different purposes.

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 (checking before logging hours) but does not explicitly state when to use it versus alternatives like get_budget_alerts or set_budget_thresholds. No when-not or alternative guidance is provided.

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

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

With no annotations, the description discloses key behaviors: preview mode unless confirm=true, and that closing is not directly reversible (remains in Closed state). This adds value beyond the schema, though it could specify that the frame order must be in Open state.

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

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

Three sentences, each serving a distinct purpose (action, preview behavior, irreversibility). Front-loaded with the primary action, no filler or redundancy.

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

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

Covers purpose, preview/confirm behavior, and irreversibility, but lacks details on prerequisites (e.g., order must be Open), handling of existing invoices, and idempotency. Without an output schema, more context on the preview response would be beneficial.

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

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

Schema coverage is 100%, so baseline is 3. The description clarifies the confirm parameter's role (preview vs. actual action), but adds no extra meaning for frame_order_id or idempotency_key beyond the schema descriptions.

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

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

The description clearly states the action 'Close an Open frame order' with the specific consequence 'so no new invoices may link to it'. It distinguishes from siblings like delete_frame_order (permanent removal) and update_frame_order by specifying a dedicated state transition.

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

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

No explicit guidance on when to use this tool versus alternatives (e.g., delete_frame_order, update_frame_order). The description implies usage for stopping new invoice linking but does not provide exclusion criteria or trade-offs.

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?

Discloses key behaviors: preview mode (no token) vs commit mode (with token and idempotency key), idempotency semantics, and reversibility. No annotations are provided, so description carries full burden and does so well, though could mention error cases.

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

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

Three sentences with no redundant information. First sentence states purpose, second and third explain procedure and reversibility. Efficient 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?

Covers main aspects: purpose, procedure, and reversibility. Lacks mention of required permissions or error handling, but given the tool's moderate complexity and lack of output schema, the description is sufficiently complete.

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

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

Schema coverage is 100% with parameter descriptions, but the description adds value by explaining the role of confirm_token and idempotency_key in the two-step process, and the preview/commit distinction.

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 (close a billing month) and its effect (no further time can be logged or edited). Distinguishes from sibling 'reopen_month' by mentioning reversibility only through reopening.

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?

Describes the two-step procedure (preview then commit) but does not explicitly state when to use the tool (e.g., after month finalization) or when not to use it. Lacks comparison to alternatives beyond mentioning reopen_month.

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 mentions creation of hierarchy but omits important details like destructiveness (e.g., whether existing entries are overwritten), authentication needs, or error states.

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

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

The description is two sentences, very concise, and front-loaded with the main action and a key prerequisite. No unnecessary information.

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

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

Given the tool's complexity (committing a multi-entity import) and no output schema, the description lacks details on return values, idempotency (though hinted by parameter), error handling, and required permissions. Incomplete for a mutation tool.

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

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

Schema coverage is 100%, so baseline is 3. The description adds context for csv_content (must pass validate_import) but repeats the schema's description. It does not add significant new 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 action (commit a bulk-import CSV) and the resource (creating work hierarchy). It also mentions a prerequisite sibling tool (validate_import), which helps distinguish from similar 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?

Explicitly advises calling validate_import first, which gives clear context on when to use this tool vs. alternative. However, it does not mention other conditions or when not to use it.

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

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

No annotations are provided, so the description must carry the burden. It discloses that entries are created as Draft, the source range cannot exceed 31 days, and the weekday offset preservation logic. This is sufficient for a simple copy 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 three sentences, efficiently conveying the purpose, behavioral details, and parameter usage without unnecessary words. It is front-loaded with the main 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?

While there is no output schema, the description covers the input constraints and behavioral details adequately. It does not explain the return value, but for a copy operation, the outcome is implied (creation of draft entries). Could be improved by noting that existing entries in the target range are not overwritten.

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?

All parameters are described in the input schema (100% coverage), and the description adds extra context about the mapping from source_start_date to target_start_date and the weekday offset, which goes beyond the schema's type/format descriptions.

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

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

The description specifies a clear action: copying time entries from a source date range to a target date range, with the added detail of preserving weekday offset. This distinguishes it from siblings like log_time or create_time_report.

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 explains the use case (e.g., 'copy last week to this week') and constraints (31-day max), but does not explicitly state when not to use it or suggest alternative tools.

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

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

With no annotations provided, the description carries the full burden. It discloses the role requirement, which is useful. However, it does not mention that setting 'confirm' to false returns a preview, the idempotency behavior, or any side effects on the invoice status. These are left to the schema, but the description could provide more behavioral context.

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

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

The description is exceptionally concise: two sentences, no superfluous words, front-loaded with the purpose and effect. Every sentence adds 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 the complexity (5 parameters, no output schema, no annotations), the description is minimal. It covers the core action and role requirement but does not explain the preview mode, idempotency, or what happens to the invoice after the note is created. The schema fills some gaps, but the description could be more complete for an agent to use 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 100% coverage, so the baseline is 3. The description does not add any parameter-specific information beyond what the schema already provides (e.g., constraints on credit_amount, purpose of confirm flag). No extra guidance is given.

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), the resource (credit note), the target (against an existing invoice), and the effect (reducing the amount owed). This distinguishes it from sibling tools like issue_invoice or void_invoice.

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

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

The description provides a clear context for when to use the tool: when reducing the amount owed on an invoice. It also specifies a role requirement (Finance role or above). However, it does not explicitly contrast with alternatives like voiding or writing off, which would help the agent choose among siblings.

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

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

No annotations are provided, so the description carries the full burden. It states the tool creates a customer (implies mutation) but does not disclose any behavioral traits such as required permissions, idempotency behavior, rate limits, or what happens on success/failure. The note about not passing organization ID adds some 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 sentence that is front-loaded with the key action and context. It is concise 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?

The description covers the essential purpose but lacks information about return values, error handling, or behavioral context beyond creation. Given the absence of an output schema and annotations, the description could be more complete, but it is minimally adequate.

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

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

Schema description coverage is 100%, so the schema fully documents all parameters. The description adds no extra meaning beyond the schema, except for the note about not passing organization ID (which is not a parameter). Baseline 3 is appropriate.

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

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

The description clearly states the action ('Create'), the resource ('billing customer'), and the scope ('in your organization'). It distinguishes from sibling tools like update_customer, delete_customer, and list_customers.

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

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

The description provides a clear usage note: 'The organization is fixed by your context - never pass an organization id.' This guides proper usage but does not explicitly state when to use this tool versus alternatives, though the context makes it sufficiently clear.

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

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

No annotations provided, but description discloses key behaviors: organization is fixed, ListOfValues requires options, mandatory blocks entity creation. Does not mention idempotency behavior or rate limits, but covers main effects.

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

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

Three concise sentences front-load the purpose, then add essential details. 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?

With 7 parameters and no output schema, the description covers main aspects: entity, field_id, title, type, mandatory, list_of_values. Idempotency key is in schema but not description, but overall sufficient for a creation 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 coverage is 100%, so baseline 3. Description adds value by explaining context (fixed organization), clarifying ListOfValues requirement, and describing mandatory field impact.

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

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

The description clearly states the tool creates a custom field on billing entity types, lists the entities and data types, and distinguishes from sibling tools like update_custom_field and delete_custom_field.

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

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

Provides guidance on usage: do not pass organization id, ListOfValues requires options, mandatory blocks creation. Could explicitly mention alternative tools for updating/deleting, but context is clear.

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

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

No annotations are provided, so the description carries the full burden. It states the tool saves and returns the created favorite, but fails to mention idempotency (despite an idempotency_key parameter), side effects, permissions, or any other behavioral traits.

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

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

Two sentences, front-loaded with the main action. Very concise, but could be slightly more informative without adding much length.

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

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

Without an output schema, the description should explain what the returned favorite contains. It only says 'Returns the created favorite' without details. Also lacks context on prerequisites or error conditions for a tool with 7 parameters.

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

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

Schema coverage is 100% with each parameter already described. The description adds minimal value by summarizing the favorite as a 'time-entry combination', but does not elaborate on any parameter beyond the schema.

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

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

The description clearly states the action ('Save') and the object ('a time-entry combination as a favorite'), with the purpose 'for quick reuse'. This distinguishes it from sibling tools like 'delete_favorite', 'use_favorite', and 'list_favorites'.

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

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

No explicit guidance on when to use this tool vs alternatives like 'use_favorite' or other creation tools. The description implies usage for saving favorites, but does not provide conditions 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?

Discloses that the frame order can be deleted while still Open, but does not cover other behavioral aspects such as whether it returns the created order ID or what happens upon duplicate idempotency keys. With no annotations, more detail on side effects or state would improve 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?

Three sentences: first states purpose, second explains concept, third notes reversibility. No fluff, front-loaded, every sentence adds 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 10 parameters, no output schema, and no annotations, the description explains what the tool does and the core concept, but does not mention the return value or any post-creation behavior. A complete description would include what the tool returns (e.g., the created order's ID).

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

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

Schema covers all 10 parameters with descriptions (100% coverage), so baseline is 3. The tool description does not add additional meaning beyond what is in the schema, so no increment.

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

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

Clearly states the tool creates a new Open frame order, defines it as a blanket PO/commercial envelope, and explains its function of tracking a cap that invoices draw down against. Distinguishes from sibling tools like update_frame_order and close_frame_order.

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?

Implicitly describes when to use (when needing to create a frame order), but does not explicitly mention when not to use or suggest alternatives like update_frame_order. The sibling list is long, but no cross-referencing.

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, so description carries full burden. Discloses save behavior, data source constraints, and confirmation requirement. Lacks mention of error handling or permissions but adequately covers key behavioral traits.

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

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

Two sentences, front-loaded with action and condition. Every sentence adds critical information; 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?

Tool has 7 parameters and no output schema. Description explains key constraints and workflow but does not mention return value or error scenarios. Adequate for 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?

Schema coverage is 100%, so baseline 3. Description adds contextual constraints (e.g., full_day_off behavior, date source) and workflow guidance, exceeding schema documentation.

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

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

Description states verb 'create' and resource 'national-holiday profile' with specificity. Distinguishes from siblings by mentioning 'suggest_holiday_profile' and requiring review.

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?

Explicitly states when to use (after user confirmation), when not to use (never to preview, never invent dates), and references sibling tool for suggestions.

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

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

No annotations provided, so description must cover behavior. Describes idempotency key behavior and create_general_activity default. Lacks details on permissions, destruction, or side effects beyond what is mentioned.

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

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

Two concise sentences plus a note. No wasted words, essential information 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?

Covers purpose, usage, and key parameter behaviors. Missing return value description (no output schema). Also lacks permissions or error conditions. 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?

Adds meaning beyond 100% schema coverage: explains how to find customer_id, clarifies default for create_general_activity, and notes idempotency_key replay behavior. This adds practical guidance not in 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?

Clearly states the action ('create') and resource ('billing project') with context ('under one of your customers'). Distinguishes from sibling tools like create_task, create_time_report, etc.

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

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

Provides specific guidance: fix organization context, discover customer_id via find_billing_work, never ask user for id. Does not explicitly state when not to use, but offers clear context.

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

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

With no annotations, the description carries the burden. It discloses that the report is generated and emailed, but lacks details on idempotency, error handling, permissions, or side effects beyond creation.

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

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

Two sentences, front-loaded with the action, no redundant words. Every sentence adds 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 no output schema, the description covers the basic purpose but omits expected return information (e.g., created report ID) and additional behavioral details needed for full context.

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

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

Schema coverage is 100%, so the description adds little beyond what the schema provides. It mentions 'configured cadence' but does not elaborate on parameter values or constraints.

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

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

The description clearly states the tool creates a new scheduled report definition, specifies the action (generate and email on cadence), and distinguishes itself from siblings like update_scheduled_report and cancel_scheduled_report.

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

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

No explicit guidance on when to use or avoid this tool. It does not mention prerequisites, alternatives, or conditions for use, leaving the agent to infer usage context.

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

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

With no annotations, the description must disclose behavior. It mentions the subtask inherits billing type and that time entries are logged against it, which is helpful. However, it does not discuss return values, error behavior, or permission requirements, leaving 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 three sentences, front-loading the purpose and then adding context. It is efficient but could be slightly improved with bullet points for clarity. No redundant information, earning 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 description does not mention the return value or idempotency behavior, both relevant for a creation tool. Given no output schema, the description should cover what the agent can expect. It provides key facts but is incomplete.

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

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

Schema coverage is 100%, so each parameter has a description. The description adds value by instructing how to obtain the task_id via find_billing_work, which goes beyond the schema. No other parameters are elaborated, but the schema is sufficient.

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 'Create a subtask under a task,' specifying the verb and resource. It distinguishes from siblings like 'create_task' and explains that subtasks are required for time entries, which clarifies their role.

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

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

The description instructs that 'every task needs at least one' subtask for logging time, providing a clear usage context. It also advises to use find_billing_work for IDs, but does not explicitly mention when not to use this tool or list alternatives.

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

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

Discloses inheritance of billing types, but does not mention idempotency (despite idempotency_key parameter) or return behavior. No annotations provided, so description carries burden but could be more thorough.

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

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

Two relevant sentences with no waste. Front-loaded with purpose, followed by important inheritance and discovery hints.

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?

Lacks return value information and does not explain idempotency_key behavior. Given 5 parameters and no output schema, the description is helpful but not fully complete.

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

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

Schema coverage is 100%, baseline 3. Description adds value by explaining the parent project context and directing users to 'find_billing_work' for project_id, which aids understanding beyond schema.

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

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

The description clearly states the verb ('create') and resource ('task under a project'), and distinguishes it from sibling tools like 'create_project' and 'create_subtask' by noting that tasks group subtasks.

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

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

Provides explicit guidance on when to use (creating a task under a project) and how to discover IDs with 'find_billing_work'. Does not explicitly exclude alternatives but is clear enough.

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

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

No annotations provided, so description carries full burden. It discloses that the entry is always attributed to the current user and that start_time defaults to 09:00. However, it omits details about idempotency, return values, or error handling, which are important 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?

Two sentences with no unnecessary words. The first sentence immediately conveys the main action, and the second provides essential parameter details.

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

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

For a simple creation tool with no output schema, the description covers the key constraints and required parameters. It is adequate for an agent to understand the basic operation, though it could mention return values or error cases.

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%, baseline 3. Description adds value by stating the default start_time (09:00) and listing the required parameters, though it does not elaborate on the optional text or idempotency_key parameters.

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

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

Description clearly states 'Create a new time entry on a subtask for the current user', specifying verb, resource, and scope. It distinguishes from siblings like bulk_create_time_reports and start_timer by focusing on a single entry for the current user.

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?

Mentions that entries cannot be created for another user, providing context for when not to use it. However, it does not explicitly compare with similar tools like log_time or start_timer, leaving the agent to infer the appropriate use case.

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 fully discloses the destructive, irreversible nature, immediate client access loss, preview requirement, confirm token expiration (10 min), and idempotency guarantee.

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

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

The description is two sentences, each earning its place. First sentence states the irreversible action, second details the commit process. Front-loaded with the core 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?

Covers the two-step process, token expiration, and idempotency. Could briefly mention the preview return format, but the description is sufficient for correct invocation given the schema.

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

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

Although schema coverage is 100%, the description adds crucial context beyond the parameter descriptions: explains the preview-commit workflow, token purpose, expiration, and idempotency behavior, greatly aiding agent 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 clearly states the tool permanently revokes an Integration API key, a specific verb-resource combination. It distinguishes from sibling deletion tools by focusing on API keys.

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 explains the two-step preview-commit process and that the action is irreversible. While it doesn't mention when not to use, the context is clear and there are no directly competing siblings.

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

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

With no annotations, the description fully discloses the soft-delete nature, hierarchy deletion, recycle bin, admin restore capability, and the preview-versus-confirm behavior. This provides good transparency for a write operation.

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

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

Two sentences, no fluff. Concisely conveys the key behavioral aspects and the confirm toggle without extra words.

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

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

Given the tool's low complexity (3 params, no output schema), the description adequately covers behavior, side effects, and the preview mechanism. It could slightly improve by hinting at the preview's content, but it's sufficient.

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

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

All parameters have complete schema descriptions (100% coverage). The description adds no additional semantics beyond noting the preview behavior, which is already in the confirm parameter description.

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 performs a soft-delete of a billing customer and its entire hierarchy, which distinguishes it from other delete tools (e.g., permanent_delete_entity). The verb 'soft-delete' and resource specification are precise.

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?

While the description implies this tool is for safe, reversible deletion, it does not explicitly guide when to use this over alternatives like permanent_delete_entity. No when-not or context for admin-only restore is 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?

Discloses destructive nature, preview-on-delete behavior, rejection condition, and admin requirement. No annotations provided, so description fully bears the transparency burden. Idempotency key behavior is not mentioned, but schema covers it.

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

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

Three sentences, front-loaded with the main action, no fluff. Every sentence adds 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?

Covers return behavior (preview vs. actual delete) and mandatory field rejection. No output schema, but preview mention suffices. Could mention idempotency_key usage for completeness. Overall adequate for a delete 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 coverage is 100%, baseline 3. Description adds context for confirm parameter but does not elaborate on custom_field_id or idempotency_key beyond what schema provides. Adequate but not exceptional.

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

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

Clearly states it deletes a custom-field definition from the organization, distinguishing it from create_custom_field, update_custom_field, and set_custom_field_value.

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

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

Provides context for when deletion is rejected (mandatory field with values) and preview behavior with confirm parameter. Mentions admin role requirement. Does not explicitly compare to sibling tools, but the description is sufficient for usage guidance.

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

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

Discloses key behavioral traits: permanent deletion, precondition (must be draft), and the preview vs. execution mode controlled by 'confirm' parameter. Transparent about the destructive nature, which is critical 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?

Three sentences, each essential. The first sentence states purpose, the second states important constraint, the third explains the key parameter behavior. No redundancy, well 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?

Covers the essential aspects: what it does, constraints, and behavior of the key parameter. Missing details like error conditions (e.g., what if invoice is not draft or already deleted) and the structure of the preview response. However, for a deletion tool, this is fairly complete. Could benefit from mentioning error handling.

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

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

Schema already covers all parameters with descriptions. The description adds value by explaining the preview/confirm behavior tied to the 'confirm' parameter, which is not fully captured in the schema description alone. Improves the agent's understanding of how to use the parameter.

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

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

Description explicitly states the action (delete) and resource (draft invoice), and distinguishes from issued invoices. The verb 'delete' and qualifier 'draft' are specific and differentiate from related sibling tools like 'void_invoice' or 'issue_invoice'.

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?

Clearly states that only draft invoices can be deleted and that issued invoices are permanent, guiding the agent when to use this tool. Does not explicitly name alternatives for issued invoices (e.g., 'void_invoice'), but the context of sibling tools provides that hint.

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

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

No annotations are present, so the description carries full burden. It mentions 'Requires confirm=true to proceed' but does not elaborate on the preview behavior when confirm is false, nor does it explain side effects like irreversibility or authorization needs. The schema description for confirm is more informative than the tool description.

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

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

The description is very concise with two sentences. It front-loads the action and requirement. However, it could be slightly more informative without losing conciseness, such as mentioning the preview behavior.

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

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

For a tool with 3 parameters and no output schema, the description is incomplete. It does not describe the return value (e.g., success/error messages) or the behavior of the idempotency_key. The preview behavior is implied but not explicitly stated in the description, relying on the schema.

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

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

Schema coverage is 100%, so baseline is 3. The description repeats the requirement for confirm but does not add meaning beyond the schema for favorite_id or idempotency_key. It neither clarifies parameter values nor provides usage 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 ('a saved time-entry favorite'), making the tool's purpose unambiguous. It distinguishes itself from sibling tools like 'create_favorite' or 'use_favorite' 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 description provides no guidance on when to use this tool versus alternatives like other delete tools or when to use it at all. It only mentions a requirement (confirm=true) but no context about prerequisites or competitive tools.

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

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

With no annotations, the description carries full burden. It discloses soft-delete, restorability by Admin, blocking conditions, and preview/confirm behavior. Missing details on auth requirements or error states, but covers the key behavioral traits.

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

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

Three sentences, front-loaded with main action, then condition, then behavior. No filler words. Every sentence adds critical 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?

No output schema, so description should explain return values. It mentions 'Returns a preview' but doesn't specify what the preview contains or the success response format. Also lacks error scenario handling (e.g., order not found). The blocking condition is well-stated, but overall completeness 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?

Schema coverage is 100%, so baseline is 3. Description adds value by explaining the confirm parameter's preview mode and the idempotency behavior. No extra info on frame_order_id beyond schema, but the preview context is useful.

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 ('Soft-delete an Open frame order'), specifies it's restorable by an Admin, and differentiates from other deletion tools like permanent_delete_entity by emphasizing it's a soft-delete. Also distinguishes from close_frame_order by noting it's a 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?

Explicitly states when the tool is blocked (if Issued/Sent/Paid invoices are linked) and provides prerequisite actions (void or unlink them). Also explains preview behavior vs confirmation. Lacks explicit mention of when to use this over permanent_delete_entity or restore_entity, but the soft-delete and admin-restorable context implies it.

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

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

With no annotations, the description carries the full burden. It reveals the preview behavior (returns preview unless confirm=true) and the admin role, adding significant context beyond the schema.

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

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

Three sentences that are direct and informative, with no wasted words. Each sentence earns its place.

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

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

The description covers the main behavioral aspects (preview, admin role) for a delete operation without output schema. Minor gaps on reversibility but sufficient for the complexity.

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

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

Schema coverage is 100%, but the description adds value by explaining the confirm parameter's preview action and the idempotency_key's purpose, going beyond the schema descriptions.

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

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

The description clearly states a specific action ('Delete') and resource ('national-holiday profile'), distinguishing it from siblings like create_holiday_profile or update_holiday_profile.

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 explains the effect on time calculations and mentions the admin role requirement, but doesn't explicitly discuss when not to use or provide alternatives.

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

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

Given no annotations, the description fully discloses behavioral traits: soft-delete, member lockout, hiding the org, restoration by admin, retention window, preview step, token expiry (~10 min), and idempotency key semantics. This is comprehensive 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?

Three concise sentences cover purpose, preview step, and commit step with parameters. No redundant information; every sentence earns its place. Very 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?

Given the tool's complexity (two-step, soft-delete, role requirement, token expiry) and no output schema, the description covers all necessary aspects for correct invocation. The agent understands the workflow completely.

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

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

Schema coverage is 100%, so baseline is 3. The description adds significant meaning: confirm_token is from preview, idempotency_key ensures safe retries. It explains the role of each parameter in the workflow, exceeding the schema's bare descriptions.

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

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

The description clearly states the tool soft-deletes an organization, explaining the lockout and hidden state. It distinguishes from other delete tools like delete_customer and delete_project by specifying the resource and the preview-commit pattern.

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?

Explicitly describes the two-step process: first call without token to preview, then with confirm_token and idempotency_key to commit. It also notes the 'Owner role required' prerequisite. Does not explicitly mention when not to use, but the procedure is clear.

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

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

Without annotations, the description fully discloses key behaviors: soft-delete, hierarchy deletion, recycle bin, admin restore, and preview mode. This provides complete transparency about the tool's effects.

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

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

Two sentences, front-loaded with the primary action. No extraneous information; every word adds clarity.

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

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

Given no output schema, the description hints at return values (preview vs. result), but lacks details on preview structure. Still, it covers the essential context for a delete tool, especially with sibling context showing alternatives.

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%, baseline 3. The description adds value beyond schema for 'confirm' (explains preview/write behavior) and 'idempotency_key' (explains retry semantics). The description for 'project_id' is similar to schema.

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

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

The description clearly states the action (soft-delete), the resource (billing project), and scope (entire task/subtask hierarchy). It distinguishes itself from related tools like permanent_delete_entity and restore_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 explains the preview-then-confirm pattern, guiding the agent on safe usage. It implies when not to use (if permanent delete is needed), but does not explicitly name alternatives.

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

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

With no annotations, the description bears full burden. It discloses soft-delete nature, admin restoration, preview behavior, and confirm flag effect. It does not cover auth or rate limits, but for a delete tool this is transparent enough.

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

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

Two sentences, front-loaded with purpose, no superfluous words. Very 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 no output schema, more burden falls on description. It explains the core action and preview, but does not mention the return format of preview, idempotency key behavior details, or the restore counterpart (restore_entity). Adequate but with gaps.

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

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

Schema coverage is 100%, so baseline is 3. The description does not add new parameter info beyond what the schema's descriptions already provide (e.g., confirm behavior is identical). Thus it meets the baseline but no extra value.

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

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

The description clearly states it is a soft-delete operation ('Soft-delete a billing subtask into the recycle bin'), distinguishes itself from permanent deletion (via sibling 'permanent_delete_entity'), and describes the preview behavior. This provides a specific verb+resource with differentiation.

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

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

The description explains when to use it (soft-delete) and the preview/confirm behavior, which guides usage. It implicitly contrasts with permanent deletion via sibling tool, but does not explicitly mention alternatives or when not to use.

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

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

Despite no annotations, the description discloses the soft-delete behavior and recycle bin recovery, as well as the preview mode for safe interaction. It could be more detailed about restoration permissions or rate limits.

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

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

The description is a single, focused sentence that efficiently conveys the core action and the key behavior (preview vs confirm). 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?

The description covers the essential operation and preview behavior, but lacks details about the return value format since there is no output schema. For a delete tool, this is acceptable but slightly incomplete.

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

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

Schema coverage is 100%, so the description adds minimal value beyond what the schema already provides for parameters. The preview behavior is mentioned but already covered in the confirm parameter description.

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

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

The description clearly states it soft-deletes a billing task and its subtask hierarchy, distinguishing it from permanent delete or individual subtask deletion found in sibling tools like permanent_delete_entity and delete_subtask.

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 explains the preview behavior and the need to set confirm=true to perform the delete, guiding safe usage. However, it does not explicitly contrast with alternative delete tools or specify when not to use this tool.

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

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

No annotations provided, so description carries full burden. It discloses destructive behavior but also mentions a preview mode for safety. Could be improved by explicitly stating irreversibility of confirm=true but is adequate.

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

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

Two sentences, highly concise, front-loaded with the main action. Every sentence adds 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?

No output schema, but description mentions return preview. Covers permissions and preview behavior. Lacks details on preview format, but sufficient for a destructive 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 covers 100% of parameters with descriptions. The tool description repeats the confirm behavior and adds permission context but does not add new semantic details beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the verb 'Delete' and the resource 'a time report entry', distinguishing it from siblings like create_time_report and update_time_report.

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?

Specifies who can use the tool (members vs managers/admins) and hints at when to use confirm=true. However, it lacks explicit mention of alternatives or when not to use this tool.

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

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

Despite no annotations, the description discloses key behaviors: deletion effect, user fallback to default schedule, two-phase commit (preview vs confirm), and admin role requirement. It could mention reversibility or constraints, but overall it is transparent.

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

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

The description is concise with three sentences: purpose, effect, and preview/role info. Information is front-loaded and every sentence adds 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 3 parameters, full schema coverage, no output schema, and moderate complexity, the description covers purpose, side effects, preview/confirm, and required role. It could mention constraints like protecting default schedules, but is largely complete.

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

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

Schema coverage is 100%, so parameters are documented. The description adds meaning by explaining the effect on users (fallback) and clarifying that confirm=true performs the action, enriching the confirm parameter's semantics 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 explicitly states 'Delete a named organization work schedule profile,' using a specific verb and resource. It distinguishes itself from sibling tools like 'manage_user_work_schedule' and other delete operations by clearly targeting work schedules.

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

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

The description provides clear usage guidance by explaining the preview/confirm mechanism and admin role requirement. It does not explicitly mention when not to use the tool or alternatives, but the context is sufficient for correct 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?

Despite no annotations, the description effectively discloses key behaviors: the action is reversible, requires a confirm flag to actually write, returns a preview, and supports an optional reason for auditing. This goes beyond the schema to inform the 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?

Two sentences deliver all essential information without redundancy. Every word serves a purpose, making it highly concise yet complete.

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

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

Given the complexity (4 params, no output schema), the description fully covers the behavior, parameter implications, and safety aspects (preview, reversibility). It leaves no significant gaps for an agent to misinterpret.

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

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

The schema covers all 4 parameters with descriptions. The tool description adds value by explaining how 'confirm' controls preview vs. action and that 'reason' is for audit purposes, complementing the schema details.

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: 'Disable an organization member so they can no longer sign in or use the app.' The verb and resource are specific, and it distinguishes from related siblings like 'enable_user' and 'remove_user'.

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 explains when to use: to disable a user, and notes that it is reversible via the web app. It also clarifies the preview mode vs. actual execution with 'confirm=true'. However, it does not explicitly contrast with alternatives like 'remove_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?

Discloses the write operation (re-enabling) and the privilege constraint. No annotations provided, so description carries the burden. Could mention side effects but sufficient for the 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?

Two sentences, front-loaded with action, 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?

Simple tool, but no output schema. Description doesn't indicate return value or success/failure signaling. Adequate but could mention outcome.

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

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

Description mentions org_user_id but adds little beyond schema (which already describes it). Idempotency_key not mentioned. With 100% schema coverage, 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?

Clearly states the verb 're-enable' and the resource 'organization member', distinguishing from siblings like disable_user. Also specifies the required 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?

Explicitly says when to use (re-enable previously disabled) and when not (cannot target more privileged user). Also instructs not to pass organization id due to fixed context.

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

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

No annotations provided, so description carries full burden. Discloses return format (ids and names only) and filtering behavior. Does not explicitly state it's read-only or safe, but the use case implies it. Good 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?

Two sentences, front-loaded with essential info, zero waste. Every sentence earns its place.

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

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

No output schema, but description includes return info (ids and names). Explains filtering and drilling use. Lacks details on error handling or pagination, but sufficient for usage.

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

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

Schema coverage is 100% with good param descriptions; the description adds 'optionally filtered by a name fragment' which aligns with the query param but doesn't add new meaning. 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?

Purpose is clear: it finds billable projects/tasks/subtasks for time tracking, distinguishing from sibling list/search tools. States specific action (find), resource (billing work), and scope (organization) with optional filter.

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?

Explicitly says 'Use this to locate where to record work', providing clear usage context. Could be more specific about when not to use it, but the guidance is sufficient.

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

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

No annotations are provided, so the description shoulders the full burden of behavioral disclosure. It states that the tool creates a draft invoice that is editable and deletable, which is key. However, it does not describe potential side effects (e.g., whether it marks hours as invoiced), required permissions, or idempotency behavior. The behavioral transparency is adequate but could be enhanced.

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

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

The description is extremely concise: two sentences totaling ~25 words. The first sentence states the core purpose with precise verb and resource ('Generate a DRAFT invoice'), and the second adds critical behavioral context (editable, deletable). Every word contributes meaning; there is no redundancy or filler.

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

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

Given the tool has 8 parameters (3 required) and no output schema, the description covers the primary function and output state. However, it lacks information about return values (e.g., invoice ID or status), error conditions (e.g., missing approved hours), or prerequisites (e.g., customer existence). The description is sufficient for basic understanding but incomplete for full contextual guidance without additional documentation.

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

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

With 100% schema description coverage, the baseline is 3. The description adds context that the invoice is based on 'approved billable hours', which indirectly explains the purpose of parameters like customer_id, period_start, period_end, and grouping. However, it does not elaborate on parameter semantics beyond what the schema provides. The parameter meaning is clear from the schema, so no additional value is added.

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

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

The description clearly states the tool's purpose: generating a DRAFT invoice from approved billable hours over a billing period. It specifies 'draft' to differentiate from final invoice tools like issue_invoice, and explicitly mentions the input source (approved billable hours) and the scope (billing period). This distinguishes it from sibling tools such as create_credit_note or void_invoice.

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 explains that the draft is editable and deletable before issuing, which guides usage post-generation. It does not explicitly state when to use this tool versus alternatives (e.g., issue_invoice), but the context of sibling tools and the focus on 'draft' implies its purpose. The mention of editability and deletability provides clear guidance on the tool's output state.

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 behavioral traits. It only states it retrieves a billing summary, but does not mention permissions, data scope limitations, or whether it is a read-only operation beyond what is implied.

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 conveys the essential purpose efficiently, though a bit more detail on the output would not harm 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?

Without an output schema, the agent needs description hints about the return format. The description omits what the billing summary contains (e.g., charges, taxes, currency). Given the simplicity of the tool, this is a significant gap.

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

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

All three parameters have schema descriptions (100% coverage). The tool description paraphrases the schema without adding new meaning, such as constraints on the date format or hints about customer_id validation. 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 'Get billing summary for a customer over a date range' clearly states the verb (get), resource (billing summary), and scope (customer, date range). Among siblings like get_hours_summary, get_unbilled_time, and get_invoice, this tool's purpose is distinct 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?

The description provides no guidance on when to use this tool versus alternatives such as get_invoice or get_unbilled_time. There is no mention of prerequisites, 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?

No annotations are provided, and the description does not disclose behavioral traits like read-only nature, potential pagination, required permissions, or response format. For a retrieval tool, such details are important for correct invocation.

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

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

The description is a single, focused sentence that conveys the core functionality without extraneous words. It is perfectly concise 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 no parameters and no output schema, the description is minimally complete. However, it lacks details about what constitutes a 'budget alert', the response structure, and how results are ordered or grouped, which could be helpful for an AI agent.

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

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

There are no parameters, so the schema coverage is 100%. The description adds value by clarifying the scope ('organization') and the condition ('over or near budget'), which is not present in the empty schema.

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

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

The description clearly states the tool retrieves 'all budget alerts for the organization' showing projects 'over or near budget'. This specifies a unique verb-resource combination and distinguishes it from sibling tools like 'check_budget_limits' and 'get_budget_health'.

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 prefer 'get_budget_health' or 'check_budget_limits'. There is no mention of prerequisites, limitations, or complementary 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 must carry the full burden. It describes the return contents but does not disclose behavioral traits such as read-only nature, required permissions, or rate limits. However, as a 'get' operation, it is presumably safe, but this is not stated explicitly.

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

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

The description is a single, well-structured sentence that front-loads the purpose ('Get overall budget health summary') and then lists the key components. Every word adds value, with no redundancy.

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

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

Given the absence of an output schema and annotations, the description provides a reasonable level of completeness by enumerating the main data points. However, it could mention if the result is paginated or if any authorization is required, but for a summary tool, it is largely sufficient.

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

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

There are no parameters, so schema coverage is 100%. The description adds meaning by specifying the output fields, which is helpful for understanding what the tool returns without an output schema.

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

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

The description clearly states the tool returns a budget health summary with specific components (project counts by status, remaining hours, active alerts). It distinguishes itself from sibling tools like get_budget_alerts (only alerts) and get_hours_summary (only hours) by providing an overall picture.

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

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

The description implies use as a starting point for budget overview, but does not explicitly state when to use it versus alternatives like check_budget_limits or get_budget_alerts. No exclusions or contextual guidance 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?

No annotations are provided, so the description must carry the full burden. It implies a read-only operation but does not disclose potential side effects, error handling, or data scope. The role requirement is a minimal behavioral disclosure.

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

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

The description is only two sentences, front-loading the purpose and immediately adding the role requirement. Every sentence is meaningful with no fluff.

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

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

For a simple read tool with one parameter and no output schema, the description covers the essentials. However, it could be more complete by hinting at the structure of the history (e.g., array of rates with timestamps) or mentioning that only current organization rates are returned.

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 has 100% coverage for the single parameter, describing it as 'Firebase UID of the user whose cost-rate history to retrieve.' The description adds no additional semantic value beyond the schema.

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

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

The description clearly states the action ('Get'), the resource ('cost-rate history'), and the scope ('for a specific user'). It immediately distinguishes this from write operations like set_user_cost_rate or bulk_update_cost_rates.

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

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

The description mentions 'Requires Finance role or higher,' which provides a condition for use but does not explicitly state when to use this tool versus alternatives or when not to use it. The context of sibling tools is present but not referenced.

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

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

No annotations are provided, so the description carries the full burden. It states the tool 'gets' information, implying a read-only operation, but does not explicitly confirm no side effects, disclose permission requirements, or mention any limits (e.g., rate limiting, data freshness). The behavior is under-specified.

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

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

The description is a single, clear sentence with no extraneous words. It is front-loaded with the core purpose. However, it could be slightly more structured (e.g., bullet points for output fields) without losing conciseness.

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

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

Given the lack of output schema, the description partially fills the gap by mentioning 'health score' and 'portfolio.' However, it does not list all possible fields or return format, nor does it describe error conditions or pagination. For a simple get tool, it is adequate but not comprehensive.

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 parameter 'customer_id' with 100% coverage. The description adds no additional meaning or constraints (e.g., format, examples, or expected behavior when invalid ID is given). 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 ('Get') and resource ('customer information') and clearly indicates the scope ('including health score and portfolio'). It distinguishes this tool from sibling tools like 'list_customers' (list vs. single) and 'update_customer' (read vs. write).

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

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

The description implies when to use this tool (to retrieve detailed info on one customer) but does not explicitly state when not to use it or mention alternative tools (e.g., 'list_customers' for overview, 'get_budget_health' for financial details). No usage context or prerequisites 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?

No annotations exist, so the description must disclose behavioral traits. It only states the action and examples but omits read-only status, data source, side effects, or rate limits.

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

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

The description is one sentence, efficiently conveying the main purpose without redundancy or 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?

While the tool is simple (one optional param), the description does not explain the return value structure or how results are presented (e.g., grouped by month, aggregation level). Some users may need more detail.

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 'month'. The description adds no extra meaning beyond the schema, so it meets 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 verb 'Get' and the resource 'organization dashboard metrics' with specific examples (utilization, revenue, active projects). It distinguishes itself from sibling tools by targeting dashboard-level aggregation.

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 usage context is provided. There is no indication of when to use this tool versus alternatives like get_resource_utilization or get_billing_report, nor any prerequisites or limitations.

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 states the tool returns a report with target/actual/variance, implying read-only behavior. But it does not explicitly disclose access requirements, rate limits, or potential errors. For a data retrieval tool, the transparency is adequate but could be improved.

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

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

The description is a single sentence that conveys the purpose, report contents, and parameter usage efficiently. No unnecessary words, and the essential information is front-loaded.

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

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

Given the tool's simplicity (3 params, no output schema), the description covers the main purpose and parameter usage. However, it lacks details about the response format or what happens if no data exists. For a complete description, additional context about the return value would be helpful.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by clarifying the employee_name semantics: 'look up by employee name or default to the requesting user' and reinforcing that it can be empty or 'me'. This goes beyond the schema description.

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 ('Get') and resource ('employee's timesheet report') and lists the report contents (target hours, actual hours, variance). It also differentiates from sibling tools like 'get_my_time_entries' by allowing lookup by employee name or default to self.

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

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

The description provides clear context on when to use the tool (to get an employee's timesheet) and how to use the employee_name parameter (lookup by name or default to requesting user). However, it does not mention alternatives or when not to use this tool among the many sibling tools.

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

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

No annotations are provided, so the description must convey behavioral traits. It explains the output format (hours, amount, utilization) and implies a read-only report. However, it does not address authorization requirements, performance implications, or whether it includes archived data. The transparency is adequate for a simple retrieval tool but lacks depth.

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

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

The description is extremely concise, consisting of two sentences. The first sentence front-loads the core functionality and output, and the second handles filtering. Every phrase adds value 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?

Given the tool has only two optional parameters and no output schema, the description adequately explains the return values (contracted cap, billed draw-down, remaining, utilization). It does not mention pagination or sorting, which might be needed for large datasets, but overall it covers the essential information for invoking the tool correctly.

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

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

The input schema already provides descriptions for both parameters (status and customer_id), achieving 100% coverage. The description merely reiterates 'optionally filtered by customer and/or status' without adding new semantic details like format constraints or parameter interactions. 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 tool reports frame order utilization details (contracted cap, billed draw-down, remaining) for both hours and amount, with percentage. The verb 'Report' and specific resource 'frame order utilization' make the purpose distinct from sibling tools like 'get_resource_utilization'.

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

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

The description mentions optional filters by customer and status, which suggests when to use them, but it does not provide explicit guidance on when to use this tool versus alternatives (e.g., get_resource_utilization) or when not to use it. No exclusions or dependencies are noted.

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 only states the purpose and does not disclose behavioral traits such as read-only nature, authentication requirements, rate limits, or error handling. The 'get' prefix implies safety, but the description adds no depth.

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

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

The description is a single, well-constructed sentence of 16 words. It is front-loaded with the action ('Get a summary') and efficiently conveys the essential information with no fluff.

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

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

Given the tool has 3 parameters, 100% schema coverage, and no output schema, the description covers the purpose adequately. However, it does not describe what the summary contains (e.g., total hours, daily breakdown) or return format, which would be helpful for an AI agent to understand the output.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds the context that scope can be 'user' or 'team', which matches the schema. It does not add significant new meaning beyond what the schema provides, hence baseline 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 clearly states the verb 'Get', the resource 'summary of hours logged', and the scope 'for a user or team over a date range'. It distinctly differentiates from sibling tools like 'get_my_time_entries' or 'list_my_time_entries' which return individual entries rather than an aggregated summary.

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 an aggregated summary of hours is needed, but it does not explicitly state when to use this tool over alternatives (e.g., for individual time entries use 'get_my_time_entries'). There is no guidance on when not to use it or prerequisites.

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

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

No annotations exist, so description carries full burden. It discloses tool retrieves a CSV template (read-only). No side effects mentioned, but adequate for a simple retrieval tool.

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

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

Two concise sentences: first states purpose, second provides workflow instructions. 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?

For a tool with no output schema and no annotations, description adequately covers return (CSV template) and usage context. Could optionally mention return format details, but not required.

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

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

Input schema has zero parameters (baseline 4). Description adds no param info, but none needed since there are no inputs to document.

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

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

Description clearly states it returns the CSV template for bulk-importing work hierarchy, specifying exact resources (customers, projects, tasks, subtasks). This distinguishes it from sibling tools like validate_import and commit_import.

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?

Description provides sequential workflow: get template, fill, validate, commit. It implies when to use (before bulk import) but does not explicitly exclude alternative scenarios.

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

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

No annotations are provided, so the description must fully disclose behavior. It only says 'Get the full details', which implies a read operation, but fails to mention authentication, rate limits, or that this is a safe read-only 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, efficient sentence with no wasted words. It is front-loaded with the key action.

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

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

Given the lack of output schema and annotations, the description should explain what 'full details' includes or the structure of the response. It leaves the agent without crucial information about return values.

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

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

Schema coverage is 100%, so the description adds little beyond what is already in the schema. The phrase 'by ID' is redundant with the schema's parameter description.

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

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

The description clearly states the verb 'Get', the resource 'invoice', and the method 'by ID'. It distinguishes from sibling tools like list_invoices which return multiple invoices.

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 conditions or prerequisites. It lacks contextual decision support for the agent.

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

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

No annotations are provided, so the description carries the full burden. It describes the output structure (breakdowns by project/customer, billable split, target comparison) but does not mention whether the operation is read-only, requires specific permissions, or has any limitations like pagination or date range constraints. The description is adequate but could be more explicit about behavioral expectations.

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

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

The description is a single sentence of 25 words, front-loaded with the core action and resource, and every part adds value. No redundancy or filler.

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

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

Given no output schema and the tool's analytical nature, the description adequately lists the key breakdowns (project, customer, billable split, target comparison). It lacks details on formatting or aggregation level but is sufficient for an agent to understand the return value.

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 both parameters with descriptions (100% coverage), so the description adds no additional semantic value beyond the schema. 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 identifies the verb 'Get' and the resource 'current user's time entry analytics', and specifies the outputs: hours breakdown by project and customer, billable vs non-billable split, target comparison. This distinguishes it from sibling tools like list_my_time_entries (raw list) and get_hours_summary (aggregated without breakdowns).

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

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

The description implies the tool should be used when an agent needs analytics with breakdowns for a date range, but it does not explicitly state when not to use it or mention alternative tools such as list_my_time_entries for raw data. Usage context is clear but exclusions are missing.

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

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

With no annotations, the description should disclose behavioral traits like read-only nature or authentication requirements. It does not mention any such traits, leaving the agent to infer that it is a safe read operation based on the tool name alone.

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

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

The description is a single, concise sentence that front-loads the primary purpose. It is efficient, though could benefit from slight structuring (e.g., listing returned fields explicitly).

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 adequate for a simple getter with one parameter, mentioning key informational components (budget, hours, task breakdown). However, without an output schema, it could be more complete by confirming the response structure or noting any constraints like date ranges.

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 a description for project_id (100% coverage), so the description adds no additional semantics. It meets the baseline but does not enhance parameter understanding.

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

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

The description clearly states the tool retrieves detailed project status including budget, hours, and task breakdown, which distinguishes it from siblings like get_hours_summary or get_budget_alerts. However, it could be more explicit about the exact scope of 'detailed status' and how it differs from similar 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?

No guidance is provided on when to use this tool versus alternatives such as get_budget_health or get_hours_summary. The description lacks context-specific usage instructions or prerequisites.

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

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

No annotations are provided, so the description carries full burden. It discloses that the tool returns assigned and top contributor data, and hints at integration with budget alerts. It doesn't discuss permissions or limits on contributor count, but is largely transparent.

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

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

The description is concise—three sentences—each serving a clear purpose: defining output, stating use case, and providing context. No redundant information.

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

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

Given the tool's simplicity (1 parameter, no output schema, no annotations), the description covers primary purpose, usage context, and parameter source. It could briefly mention default number of top contributors or response format, but overall adequate.

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

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

With 100% schema description coverage, baseline is 3. The description adds value by linking project_id to budget-alert results and emphasizing that the ID can be resolved via other tools. This extra context justifies a higher 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 clearly states the tool's purpose: retrieving project-associated people, distinguishing between assigned personnel and top contributors by hours logged. It uses specific verbs and resources, and uniquely positions itself among siblings.

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

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

The description specifies when to use the tool, particularly for budget overrun questions, and explains how project_id can be obtained from budget-alert results. It does not explicitly state when not to use it, but guidance is clear.

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

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

With no annotations, the description carries full burden for behavioral disclosure. It states the output fields but does not clarify read-only nature, aggregation scope (e.g., per team vs. whole org), timezone handling, or whether historical data is included. This leaves significant ambiguity.

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

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

Single sentence, 18 words, no filler. Every word adds value. Front-loaded with the key action and output summary. Excellent 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?

No output schema exists, so description must explain return value. It lists key fields (target hours, actual hours, billable hours, utilization percentage) but omits aggregation level (team/project?) and format. Adequate but not fully complete for a query 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 coverage is 100% with both parameters described in schema. The description mentions date range implicitly but adds no new meaning beyond the schema. Baseline 3 is appropriate since description does not compensate for any missing parameter information.

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

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

The description clearly states the tool fetches a resource utilization summary with specific fields (target, actual, billable hours, percentage). The tool name itself is a strong indicator, and the description adds enough detail to distinguish from similar tools like get_hours_summary, although it does not explicitly differentiate.

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

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

No guidance on when to use this tool versus alternatives like get_hours_summary or get_frame_order_utilization. No exclusions or prerequisites mentioned. The description implicitly suggests it is for overview, but lacks explicit direction.

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

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

No annotations are provided, so the description carries the full burden. It states the tool returns a summary but does not disclose whether the operation is read-only, any side effects (none expected), or data freshness (real-time vs. cached). The missing behavioral traits reduce transparency.

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

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

The description is a single, focused sentence that efficiently conveys the tool's purpose and output. No redundant words; it is front-loaded with the key action and resource.

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

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

Given no parameters, no output schema, and no annotations, the description names the output fields but lacks details on data scope (e.g., organization-wide? per customer?), format, or any filtering. It is adequate for a simple summary but could be more complete.

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

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

The input schema has 0 parameters with 100% coverage, so baseline is 4. The description correctly adds no parameter information, as there are none. This is appropriate for a parameterless tool.

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

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

The description uses a specific verb ('Get') and resource ('summary of unbilled time'), clearly stating what the tool does. It lists the included fields (total hours, total amount, number of entries, aging information) and distinguishes from sibling tools like 'get_billing_report' which focuses on billing aggregates.

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 'get_billing_report' or 'get_hours_summary'. It does not mention prerequisites, filtering, or context. This omission could lead to confusion in selecting the correct tool.

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

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

With no annotations, the description carries full responsibility. It discloses role validation constraints and the fact that the invitee receives an email with an acceptance link. However, it omits behavioral details such as what happens on failure (e.g., duplicate invite, invalid email), rate limits, or whether the invitation creates a pending user record.

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: three sentences that deliver the core action, constraints, and outcome. Every sentence earns its place, with the main action and context front-loaded. No wasteful 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?

Given the tool's simplicity (3 parameters, no output schema, no nested objects), the description covers the essential context: organization binding, role constraints, and the email notification. However, it lacks information about the return value (e.g., success indicator, invite ID) which would be helpful for completeness.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value beyond the schema by clarifying that the organization is implicitly determined by context, that role validation checks against the caller's privilege, and that the idempotency_key can be used for safe retries. This enriches the parameter understanding.

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