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

Annotations already declare the operation is non-read-only, non-idempotent, non-destructive and open-world, so the safety profile is covered. The description adds nothing beyond that: no required permissions, no duplicate-name behavior, no mention of which fields are mandatory, and no note on side effects such as creating related records.

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

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

A single front-loaded sentence with zero filler, which is structurally clean. The problem is under-specification rather than verbosity, so it is concise but does not earn much informational 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?

For a mutation tool with six parameters, one required field, and no schema documentation, the description should at minimum state the required field and any creation constraints. An output schema exists, so return values need not be explained, but the input-side completeness is inadequate.

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

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

Schema description coverage is 0% across 6 parameters, so the description is the only place semantics could be added, yet it mentions no parameters at all. The field names (name, address, city, state, country, zipcode) are largely self-explanatory, which prevents a 1, but the description does not compensate for the coverage gap.

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

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

The description states a specific verb and resource ('Create a new client record'), so an agent immediately knows this is the creation counterpart to admin_get_client/admin_update_client/admin_delete_client. However, it offers no differentiation from adjacent create tools such as admin_create_client_contact or admin_create_user, so it stops short of a 5.

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

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

There is no guidance on when to use this tool versus admin_create_client_contact, admin_update_client, or admin_create_user, and no prerequisites or conditions are stated. The agent must infer usage purely from the name.

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

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

Annotations already declare the full safety profile (readOnlyHint=false, idempotentHint=false, destructiveHint=false, openWorldHint=true), so the agent knows this is a non-idempotent write. The description adds nothing beyond that — no note on auth/permission requirements, duplicate-handling behavior, or whether the contact is attached to an existing client only. With annotations carrying the load, the description's zero added behavioral context warrants a low score.

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?

It is a single front-loaded sentence with no filler, which is structurally clean. However, at this size it is under-specified rather than concise — the brevity comes at the cost of missing information an agent needs.

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?

An output schema exists, so return values need not be described, and annotations cover the safety profile. But for a 6-parameter mutation tool with 0% schema description coverage and no usage context, the description is far too thin to let an agent call it 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?

Schema description coverage is 0% across 6 parameters, so the description carries the full burden of explaining them — and it explains none. Only the vaguest hint of a client association is implied by "for a client"; the three required fields (client_id, first_name, last_name) and the optional email/phone/title fields are never mentioned.

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 gives a specific verb ("Add") and resource ("a contact for a client"), which is clear enough to distinguish it from siblings like admin_create_client or admin_update_client. It stops short of explicitly naming the sibling boundary (e.g., that this creates a client-contact record, not a client), so it is clear but not sibling-differentiating.

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

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

There is no when-to-use guidance, no prerequisite (e.g., client must already exist), and no reference to the adjacent tools admin_list_client_contacts or admin_delete_client_contact. The agent is left to infer that this is the creation path for the contact resource.

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

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

Annotations already declare the mutation profile: readOnlyHint=false, destructiveHint=false, idempotentHint=false, and openWorldHint=true. The description adds the allowed field/target types but does not disclose permissions, side effects, or the relationship between field_type='select' and the optional options parameter.

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

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

A single front-loaded sentence with a compact parenthetical list. There is no filler, and the most important information appears first.

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?

An output schema exists, and annotations cover the safety profile, so return values need not be described. However, with 0% schema coverage and missing usage/parameter details, the description is only moderately complete for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It supplies allowed values for field_type and target_type, which the schema does not, but it leaves required 'name' and optional 'options' undocumented, including when options should be used.

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

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

The description states a specific verb and resource: 'Create a custom field definition.' It also enumerates allowed values for field_type and target_type, making the tool's purpose unambiguous against list/get/update/delete siblings.

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

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

No when-to-use guidance is provided. It does not mention alternatives such as admin_update_custom_field or admin_list_custom_fields, nor any prerequisites or conditions for creating a custom field.

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?

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false and openWorldHint=true, so the safety and idempotency profile is covered by structured data. The description adds nothing beyond that: no note on required privileges, uniqueness of the discipline name, or what side effects creation triggers.

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

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

One short, front-loaded sentence with zero filler, so it is concise and well-structured. However, the brevity is achieved by omission rather than by precision, so it reads as under-specified rather than 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?

The existence of an output schema means return values need not be described, which helps. Still, for a mutation tool in the admin surface, the definition supplies no permission requirements, no name-uniqueness or validation rules, and no guidance on the surrounding discipline workflow, leaving the agent materially under-informed.

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

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

Schema description coverage is 0%: the single required parameter "name" is typed as a plain string with no description, constraints, or format. The description does not compensate in any way, leaving the agent to guess whether the value is a display label, a code, or must be unique.

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?

"Create a new discipline" is essentially a restatement of the tool name and title (Admin Create Discipline), which is the textbook tautology case. It does identify a verb and resource, so it is not misleading, but it conveys nothing an agent could not read off the name itself, and it draws no distinction from admin_update_discipline or admin_delete_discipline.

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

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

There is no when-to-use guidance, no prerequisite (e.g. admin permission required), and no mention of the sibling CRUD operations. The agent must infer entirely from the name that this is the create-side of the discipline lifecycle.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false and openWorldHint=true. The description adds nothing beyond this: it does not mention that the call is non-idempotent (repeated calls create duplicate expenses) nor that it references external entities. With annotations covering the safety profile, the remaining non-idempotency caveat is exactly the kind of context that should have been stated and is 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?

The single sentence is front-loaded and wastes no words, but its brevity stems from under-specification rather than discipline. It is a minimum-viable one-liner, not a compact but complete definition.

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

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

An output schema exists, so return values need not be described. But for a 7-parameter mutation tool with zero schema description coverage, no usage guidance and no behavioral notes beyond the annotations, the definition leaves too much for the agent to guess in order to call it correctly.

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

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

Schema description coverage is 0% across 7 parameters, five of them required, and the description says nothing about any of them. Critical semantics such as whether amount is in major or minor units, the expected date format, and that user_id/project_id/expense_category_id accept either integers or strings are entirely undocumented.

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

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

The description states a specific verb (log/create) and resource (project expense item), so the operation is identifiable. However, it gives no differentiation from the many sibling expense tools (admin_update_expense, admin_delete_expense, admin_list_expenses) or from admin_create_expense_category, which share the same domain prefix.

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

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

There is no indication of when to use this tool versus admin_update_expense or admin_list_expenses, no prerequisites (e.g. that project_id, user_id and expense_category_id must reference existing records), and no exclusions. The agent is left to infer everything from the name.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false, and openWorldHint=true. The description adds nothing beyond that safety profile—it does not mention authentication requirements, uniqueness constraints on category names, or any side effects. No contradiction, but no added behavioral context either.

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 one-sentence description is short but does not earn its place: it merely repeats the tool title. This is under-specification rather than useful 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?

For a create tool with an output schema and annotations, the description still omits all parameter semantics and creation constraints. The structured fields provide the safety profile and return shape, but the description leaves the agent without enough context to invoke the tool confidently beyond the obvious resource name.

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

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

Schema description coverage is 0% for the single required 'name' parameter. The description does not compensate by explaining format, uniqueness, or any constraints on the name. The agent gets no semantic detail beyond the bare parameter name.

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

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

The description restates the title and tool name almost verbatim: 'Create an expense category.' It states a verb and resource but offers no differentiation from sibling tools such as admin_list_expense_categories or admin_delete_expense_category. This is a tautological restatement rather than a clarifying purpose statement.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. The description gives no usage context whatsoever.

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?

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false and openWorldHint=true, so the safety profile is covered. The description adds almost nothing beyond that: it doesn't say whether creating a duplicate name is allowed, what happens to overlapping dates, or that it affects company-wide non-working days. The phrase "or non-working day" is the only semantic addition.

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

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

One short, front-loaded sentence with no filler. It is appropriately sized for a simple create tool, though it is terse to the point of under-specification rather than genuinely efficient.

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

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

For a three-parameter mutation with 0% schema coverage and no annotation-adjacent detail in the description, the definition is too thin. An output schema exists so return values need no explanation, but the date format, end_date behavior, and name uniqueness are all left undocumented.

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

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

Schema description coverage is 0% and the description mentions none of the three parameters. The existence of end_date (optional, nullable) implies multi-day holidays, but neither the schema nor the description explains its semantics or the date format. The description does not compensate for the documentation gap.

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

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

States a specific verb and resource: "Create a new company holiday or non-working day." An agent can immediately tell this creates a holiday record. It does not differentiate itself from admin_update_holiday or admin_create_leave_type, but the core purpose is unambiguous.

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

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

No guidance on when to use this versus admin_update_holiday (for existing holidays) or admin_create_leave_type (for leave categories). No prerequisites or permissions mentioned. The agent must infer context from the tool name alone.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false, and openWorldHint=true, so the safety profile is covered. The description adds no behavioral context beyond 'create' - it says nothing about required permissions, whether leave type names must be unique, or what happens on duplicates.

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

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

One short, front-loaded sentence with no wasted words. However, the brevity reflects under-specification rather than disciplined conciseness, since nothing beyond the tool name is communicated.

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?

An output schema exists, so return values need not be explained, and annotations cover the safety profile. Still, for a mutation tool whose only input is an undocumented 'name' field, the description omits everything an agent would need to invoke it 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 single parameter 'name' has 0% schema description coverage, so the schema does not explain its format, constraints, or uniqueness. The description does not compensate - it never mentions the parameter at all.

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

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

The description states a specific verb and resource ('Create a new leave type'), so an agent knows exactly what the tool does. It does not differentiate itself from the many sibling admin_create_* tools (holiday, role, discipline, tag, etc.), which all share the same verb 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?

There is no guidance on when to use this tool versus alternatives such as admin_update_leave_type or admin_list_leave_types, nor any stated preconditions. The one-line description leaves all routing to inference from the tool name alone.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, and openWorldHint=true, and "Create" is consistent with them (no contradiction). The description adds nothing beyond that profile: no mention of side effects, uniqueness constraints on role names, whether duplicate creation fails, or what access level is needed.

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

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

The single sentence is front-loaded and free of waste, but it is under-specified rather than genuinely concise — there is simply almost no content to structure.

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

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

An output schema exists, so return values need not be explained. For a mutating, non-idempotent, open-world creation tool with an undocumented required parameter, however, the description is too thin: it omits conflict/duplicate behavior, permission requirements, and how the new role relates to sibling role-management tools.

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 is one required parameter (name) with 0% schema description coverage, so the description carries the burden of explaining it. It does not: nothing is said about whether name must be unique, its format, or whether roles require additional configuration to be usable.

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

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

The description states a verb and resource ("Create a new role"), so the agent knows this is a creation operation rather than the sibling update/delete/list variants. However, it is essentially a restatement of the tool name and title, adding no scope, target-system detail, or differentiation beyond what the identifier already conveys.

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

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

There is no guidance on when to use this tool versus admin_update_role or admin_delete_role, nor any prerequisites such as required permissions or whether the role must later be populated with permissions. Usage must be fully inferred from the name.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the safety profile is covered by structured data. The description adds nothing beyond that — no tag-name uniqueness constraint, no permission requirements, and no note on what happens if a duplicate tag exists, which matters for a non-idempotent 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 words are technically front-loaded and waste-free, but this is under-specification rather than conciseness. The brevity removes information instead of compressing it.

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?

An output schema exists, so return values need not be explained, but for a non-idempotent create operation the description should still cover input constraints and failure behavior. The description leaves the agent with only the tool name to work from.

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

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

Schema description coverage is 0% and the single required "name" parameter has no description in the schema or the description text. The agent learns nothing about naming rules, length limits, or whether the value must be unique.

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?

"Create a tag." only restates the tool name (admin_create_tag / Admin Create Tag) with no additional specificity. It never distinguishes this from admin_list_tags or admin_delete_tag, so the agent gets no more information than the identifier already carries.

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

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

There is no guidance on when to create a tag versus listing or deleting one, no prerequisites, and no mention of the sibling tools. The agent must infer everything about context from the name alone.

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

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

Annotations already disclose the safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false, openWorldHint=true), so the create-and-write nature is covered. The description adds nothing beyond this – no mention of whether the email must be unique, whether an invitation/notification is sent, required role assignment, or what happens on duplicate 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?

A single front-loaded sentence with no filler or redundancy. It is efficient, though arguably under-specified rather than appropriately sized for a 10-parameter mutation tool.

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

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

An output schema exists so return values need not be described, but with 10 parameters at 0% schema coverage and no usage or behavioral guidance, the definition is far too thin for a create tool that mutates an open-world system.

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

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

Schema description coverage is 0% across 10 parameters, so the description carries the full burden of explaining them – and it names none. Non-obvious fields like user_type_id, billability_target, bill_rate, cost_rate, and discipline are left entirely unexplained.

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

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

The description states a specific verb and resource ('Create a new user profile'), which is clearly identifiable. However, it offers no differentiation from siblings like admin_update_user or admin_create_user_bill_rate, so the agent must rely on the name alone to route correctly.

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

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

There is no guidance on when to use this tool versus admin_update_user, admin_create_role, or any of the other admin_create_* siblings. No prerequisites, no exclusions, no context about what 'profile in Smartsheet RM' entails.

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?

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false, and openWorldHint=true, so the write/non-destructive/non-idempotent profile is covered. The description adds the meaningful detail that tiers are date-ranged ('effective date range'), but omits permissions needed, overlap behavior, and what happens on re-invocation despite idempotentHint=false.

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

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

A single front-loaded sentence with no wasted words, though it is arguably too terse for a 4-parameter mutation tool with no schema documentation.

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?

An output schema exists, so return values need not be explained, and annotations cover the safety profile. Still, for a write tool with 0% schema description coverage, the description lacks date formats, rate units, and conflict-handling detail an agent would need to call it correctly.

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

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

Schema description coverage is 0%, so the description carries the burden. It conceptually maps all four parameters (rate, user_id, start_date/end_date as the 'effective date range'), which is useful, but adds no format, unit, or currency details and says nothing about whether an end_date is optional or how overlapping tiers are handled.

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 gives a specific verb ('Add') and resource ('bill rate tier ... for a user') and indicates the tier is date-scoped, which lets an agent distinguish it from admin_list_user_bill_rates and admin_create_user. It does not, however, explicitly name or contrast a sibling tool.

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

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

There is no statement of when to use this tool versus alternatives such as admin_list_user_bill_rates for viewing existing tiers. No prerequisites or exclusions are given, leaving the agent to infer usage entirely.

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?

Annotations already disclose that this is a non-read-only, non-idempotent mutation with open-world effects, so the safety profile is covered. The description adds nothing beyond that: it doesn't say a POST is issued to callback_url, whether duplicate subscriptions are possible (idempotentHint=false), or that delivery is asynchronous/at-least-once.

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

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

One tight, front-loaded sentence with concrete examples and no filler. It is efficient, though it is arguably too sparse for a mutation tool rather than padded.

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?

An output schema exists so return values needn't be described, but for an open-world webhook registration the description omits callback delivery semantics, duplicate handling, permission requirements, and whether event_type is an open string or a fixed enum. These gaps are material for correct invocation.

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

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

Schema description coverage is 0% for both required parameters. The examples ('time.entry.created', 'project.updated') give real value for the event_type string, but callback_url is left entirely unexplained and there is no indication whether the listed event types are the full set or a sample.

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

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

States a specific verb and resource: 'Register a webhook subscription', which clearly distinguishes it from admin_list_webhooks and admin_delete_webhook. The event-type examples reinforce what a subscription is, but the description never explicitly contrasts itself with those siblings.

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

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

No guidance on when to register a webhook versus using the list/delete siblings, and no prerequisites such as admin scope or a reachable, publicly resolvable callback endpoint. The agent must infer all of this from the tool name.

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

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

Annotations already declare destructiveHint=true, idempotentHint=false and readOnlyHint=false, so the safety profile is covered structurally; the description nonetheless adds a real, non-annotation behavior — the confirm=True guard — which is essential to a successful call. It stops short of saying what else is destroyed (e.g. linked contacts) or what permissions are needed.

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

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

A single front-loaded sentence with no filler; the destructive warning and the confirm requirement come immediately after the verb phrase. Nothing is wasted, though the parenthetical packs two distinct facts (destructiveness, confirm) into one clause.

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 an output schema present, return values need not be described, and annotations cover the destructive profile. Still missing for a destructive mutation: cascade/blast radius, reversibility, and required permissions, plus any client_id guidance.

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

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

Schema description coverage is 0% for two parameters. The description clarifies the semantics of confirm (it must be True to proceed), but says nothing about client_id — neither its accepted types (integer or string per the schema) nor how to obtain a valid 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?

States a specific verb and resource ("Delete a client record"), which separates it from admin_delete_client_contact and the other delete siblings in the admin family. It does not explicitly name the nearest alternative, but the resource noun is precise enough for an agent to route correctly.

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 its usage (this is the delete path for a client) and gives one invocation prerequisite, confirm=True, but never states when to prefer it over admin_update_client or what to do when a delete is not appropriate. Usage is inferable rather than stated.

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

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

Annotations already declare destructiveHint=true and idempotentHint=false, so the destructive nature is covered structurally. The description adds the non-obvious fact that confirm=True is mandatory (the schema only shows a boolean defaulting to false), which is genuinely useful. However, it does not disclose side effects such as cascading deletions or referential impact.

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

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

A single front-loaded sentence with zero filler; the destructive warning is embedded economically and nothing is redundant.

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 an output schema present, return values need no explanation, and annotations cover the safety profile. The remaining gap is behavioral detail about what deletion entails and confirmation of the id parameters, making this minimally adequate rather than complete.

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

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

Schema description coverage is 0% across 3 parameters, so the description must compensate. It only addresses the confirm parameter, leaving client_id and contact_id entirely undocumented in both schema and description (their meaning is only inferable from their names).

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

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

The description states a specific verb (Delete) and resource (a client contact), so an agent immediately understands the operation. It does not explicitly distinguish itself from closely-named siblings like admin_delete_client or admin_create_client_contact, relying on the tool name to carry that 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 only guidance is the prerequisite 'requires confirm=True', which is a call mechanic rather than when-to-use direction. There is no mention of when this tool is appropriate versus alternatives, no prerequisites about the contact, and no 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?

Annotations already declare destructiveHint=true and readOnlyHint=false, so the safety profile is covered. The description adds genuinely new behavioral information the annotations do not carry: the call requires confirm=True. It still omits downstream effects (e.g., whether stored values are destroyed) and any permission requirements.

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

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

A single sentence that front-loads the action and appends the critical precondition in parentheses. Nothing is redundant and nothing is buried.

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?

An output schema exists so return values need no explanation, and annotations cover the destructive profile. However, with zero schema description coverage the description should say more about what deletion entails and what the call requires, and it does not fully close that gap for a permanent, non-idempotent mutation.

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

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

Schema description coverage is 0%, so the description must carry the parameter burden, and it only partially does: it documents the confirm gate and the value it must take. The custom_field_id parameter, including its int-or-string anyOf shape, is left entirely undocumented.

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

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

States a specific verb and resource ('Delete a custom field definition'), which implicitly separates it from sibling operations like admin_set_custom_field_values and admin_update_custom_field. It does not explicitly name a sibling or contrast scope, so it stops short of a 5.

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

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

There is no guidance on when to delete a definition versus updating it or clearing values, nor any prerequisites beyond the inline confirm flag. The agent must infer the usage context entirely from the tool name and the deletion semantics.

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?

Annotations already declare destructiveHint=true, idempotentHint=false, and readOnlyHint=false, so the destructive nature is covered structurally. The description adds value beyond them by disclosing the confirm=True guard, but it says nothing about cascading effects (what happens to users or records referencing the discipline) or reversibility.

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

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

One sentence, front-loaded with the action, and the parenthetical adds the highest-value constraint without padding. Nothing is wasted.

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?

An output schema exists, so return values need not be explained, and annotations cover the safety profile. What remains missing for a destructive admin mutation is the blast radius of the deletion and any permission prerequisites, leaving the definition minimally viable.

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

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

Schema description coverage is 0%, so the description carries the burden for two parameters. It documents the confirm parameter's requirement (must be True) but adds nothing about discipline_id's accepted forms, even though the schema allows either integer or string.

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

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

States a specific verb and resource ('Delete a discipline'), which cleanly separates it from the sibling admin_list_disciplines, admin_create_discipline, and admin_update_discipline. It does not explicitly name those siblings, but the verb makes the distinction 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 supplies one real precondition, confirm=True, which is a genuine usage gate for invoking this tool. It offers no when-not-to-use guidance and does not point to alternatives such as admin_update_discipline or admin_list_disciplines, so usage is only 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?

Annotations already declare destructiveHint=true and readOnlyHint=false, so the safety profile is covered; the description adds real value beyond them by disclosing the confirm=True gate, which is not documented anywhere in the schema. It omits other declared traits (non-idempotent, open-world), but the confirm requirement is the operationally important addition.

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

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

A single sentence with zero filler, and the destructive/confirm warning is front-loaded in a parenthetical where it will be read. It is tight, though arguably terse given the tool is irreversible.

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?

An output schema exists, so return values need no explanation, and annotations cover the safety profile. The description supplies the one thing the structured fields lack, the confirm gate; only the expense_id identifier format is left for the agent to infer.

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

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

Schema description coverage is 0%, so the description carries the burden for two parameters. It explains confirm (must be True) but says nothing about expense_id's accepted form despite the schema allowing either integer or string, leaving half the parameters undocumented.

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 gives a specific verb and resource ("Delete an expense item"), and the word "item" implicitly separates it from the sibling admin_delete_expense_category. It is clear on its own, but it never names a sibling or scope constraint to make routing 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?

It states a precondition ("requires confirm=True") which is a genuine usage rule, but offers no when-to-use vs. when-not guidance and no pointer to alternatives such as admin_update_expense or admin_list_expenses. Usage is only implied by the verb.

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?

Annotations already declare destructiveHint=true, readOnlyHint=false, idempotentHint=false and openWorldHint=true, so the safety profile is covered. The description still adds genuine value by disclosing the confirm=True gate, which the schema does not document (0% coverage) and which would otherwise cause silent failures. It stops short of saying what happens to dependent expenses or whether the delete cascades.

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

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

A single sentence with the verb and resource front-loaded and the destructive/confirm constraint appended where it is most needed. No filler, no repetition of the title.

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

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

For a two-parameter destructive delete with an output schema already covering return values and annotations covering the safety profile, the description supplies the one thing structured data omits: the confirm requirement. Missing only consequence details (cascade behavior, failure when the category is in use), which are secondary here.

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

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

Schema description coverage is 0% for two parameters, so the description must compensate. It does explain the semantics of 'confirm' (must be True to proceed), but says nothing about 'category_id' — notably that it accepts either an integer or a string, a non-obvious anyOf the schema leaves unexplained.

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

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

States a specific verb (Delete) and resource (expense category), which cleanly separates it from the adjacent admin_delete_expense and admin_delete_tag siblings. It does not explicitly name those siblings or contrast scope, but the resource noun is 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 parenthetical 'requires confirm=True' gives an actionable precondition for invoking the tool, which is real usage guidance. However, there is no statement of when to prefer deletion over deactivation, no warning about categories still referenced by expenses, and no mention of the admin permission scope implied by the name.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the 'Destructive' label is largely redundant. The genuinely additive piece is that confirm=True is required, which is real behavioral information the annotations do not convey. It still omits what else is affected (e.g. whether holiday references in timesheets break) and whether the delete is recoverable.

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

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

A single short sentence with the destructive constraint front-loaded in parentheses. No wasted words, though the parenthetical could be better integrated as a precondition sentence.

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?

An output schema exists, so return values need not be described. However, for a destructive tool with zero schema description coverage and no sibling routing guidance, the definition leaves an agent without enough to safely call it — the holiday_id format and side effects are missing.

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

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

Schema coverage is 0%, so the description must carry parameter meaning. It explains the confirm flag's role, but holiday_id is left entirely unexplained — notably its anyOf integer/string type and which form to use. Only half the parameters are covered, leaving a real gap.

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

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

States a specific verb and resource ('Delete a holiday'), which is unambiguous and easily distinguished from admin_update_holiday / admin_create_holiday by name. It does not explicitly name siblings, but the operation is clear enough that an agent can select it correctly.

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 delete vs. update or archive a holiday, no prerequisites, no warning about consequences. The only usage-like content is the confirm=True requirement, which is a mechanical gate rather than selection 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?

Annotations already declare destructiveHint=true and readOnlyHint=false, so the safety profile is covered. The description earns credit by adding the confirm=True gate, which is not derivable from the annotations and only weakly visible in the schema (confirm defaults to false). It still says nothing about what happens to leave types already referenced by users.

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

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

A single short sentence with the destructive warning and the confirm requirement front-loaded. No filler.

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

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

An output schema exists so return values need no explanation, and annotations cover the safety profile. However, for a destructive, non-idempotent delete the description omits irreversibility, any in-use/referential-integrity effects, and permission requirements.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning. It partially compensates by explaining the confirm gate, but leave_type_id is left entirely undocumented despite being the required 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?

States a specific verb and resource ("Delete a leave type"), which cleanly separates it from the admin_list/get/create/update_leave_type siblings in the same family. It does not explicitly name those siblings, but the verb alone is 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 supplies the critical invocation precondition ("requires confirm=True"), which implies when the tool will actually execute, but it gives no context on when deletion is appropriate versus other leave-type operations, and names no 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?

Annotations already declare destructiveHint=true and readOnlyHint=false, so the 'Destructive' label is largely redundant. The added value is the confirm=True requirement, which is a behavioral gate an agent must satisfy for the call to succeed and is not stated in the annotations themselves.

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

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

A single front-loaded sentence with no filler; the destructive warning and the confirm gate are both surfaced immediately.

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?

An output schema exists, so return values need no explanation, and annotations cover the safety profile. Still, for a destructive admin mutation the description omits blast radius (role reassignment of users) and role_id format, leaving meaningful gaps for correct invocation.

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

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

Schema description coverage is 0% for 2 parameters, so the description must compensate. It does explain the confirm parameter's required value, but role_id gets no explanation of accepted formats (integer or string) or sourcing. Partial compensation only.

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

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

States a specific verb and resource ('Delete a role'), which cleanly separates it from the admin_create_role, admin_update_role, and admin_list_roles siblings. It stops short of explicitly naming those alternatives, so it is clear but not sibling-differentiating.

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 parenthetical gives a hard precondition (confirm=True must be set), which is genuine usage guidance. However, there is no when-to-use vs. update/disable guidance and no warning about consequences (e.g., what happens to users holding the role).

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?

Annotations already declare destructiveHint=true, readOnlyHint=false and non-idempotency, so the safety profile is covered structurally. The description adds the genuinely useful fact that confirm=True is required, but says nothing about irreversibility, what happens to entities carrying the tag, or required permissions.

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

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

A single short sentence with the destructive constraint front-loaded inside parentheses; nothing is padded. It is tight, though the parenthetical could be promoted to a clearer standalone clause.

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?

An output schema exists, so return values need no explanation. For a destructive mutation with 0% schema coverage the description is minimally adequate: it covers the confirm gate but omits irreversibility, side effects on tagged entities, and tag_id semantics.

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

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

Schema description coverage is 0%, so the description must compensate; it explains the confirm parameter's role, which is real added value. However, tag_id is left unexplained, including why it accepts either an integer or a string.

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

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

States a specific verb (Delete) and resource (tag), which cleanly separates it from admin_list_tags and admin_create_tag in the sibling set. It stops just short of naming the alternative siblings or scope (e.g., admin-scoped only), so it is clear but not fully differentiated.

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

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

There is no explicit guidance on when to delete a tag versus other operations, no prerequisites (permissions), and no warning about consequences. The parenthetical hints at destructive intent but gives no usage context or alternatives.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, idempotentHint=false, and openWorldHint=true, so the safety profile is largely covered. The description usefully adds the confirm=True requirement, which is not visible in the schema defaults, but it never clarifies whether the outcome is permanent deletion or a recoverable archive.

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

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

A single sentence with no filler, and the destructive nature plus the confirm precondition are front-loaded. The concision is slightly bought at the cost of the delete-vs-archive ambiguity.

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

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

An output schema exists, so return values need not be described. For a destructive, non-idempotent mutation the critical confirm gate is covered, but the unresolved delete/archive distinction and the undocumented user_id formats leave 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 0%, so the description must carry the burden: it does explain the non-obvious confirm=True requirement, which matches the parameter's default of false. It says nothing about user_id's accepted forms (integer or string), leaving half the parameters unexplained.

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

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

States a specific verb and resource ("Delete or archive a user") that clearly distinguishes it from siblings like admin_list_users, admin_get_user, and admin_update_user. The "or archive" wording leaves some ambiguity about which operation actually occurs, which keeps it short of a 5.

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

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

It signals a destructive operation and names the required confirm=True gate, which is a usage precondition. It does not say when to choose delete/archive over an alternative such as admin_update_user for deactivation, so routing guidance is only 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?

Annotations already declare destructiveHint=true, readOnlyHint=false, and idempotentHint=false, so the safety profile is covered. The description adds genuinely new behavioral context: the operation is gated on confirm=True. It stops short of saying what happens if confirm is omitted or false (the schema default is false), leaving the failure mode unspecified.

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

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

A single front-loaded sentence with no filler. The destructive warning and confirm gate are placed immediately after the action, where an agent will see them.

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?

An output schema exists, so return values need not be described. For a destructive mutation the description covers the essential confirm requirement, but omits the consequence of omitting confirm, whether deletion is permanent, and any auth/permission expectations — gaps that matter for a destructive admin operation.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the confirm parameter's required value, which is real added meaning, but says nothing about webhook_id (its int-or-string form, where to obtain it, or whether it is reusable after deletion). Partial compensation warrants the baseline-ish 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?

States a specific verb+resource ('Delete a webhook subscription') that is unambiguous and clearly separable from the sibling admin_create_webhook and admin_list_webhooks. It does not explicitly route against those siblings, but the action plus resource name is enough for an agent to tell them apart.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as admin_list_webhooks for identifying the target webhook_id first. The parenthetical only restates the destructive nature already implied by the name.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is fully covered. The description adds no behavioral context whatsoever — nothing about permissions, failure modes for nonexistent IDs, or lookup scope. With annotations doing all the work, this is a bare-minimum contribution.

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

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

A single short sentence with no filler, appropriately front-loaded. It is brief rather than bloated — the low score elsewhere reflects under-specification, not verbosity.

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?

An output schema exists, so return values need not be described. What is missing is the identifier format and any usage context; for a simple one-parameter lookup this is borderline adequate but clearly thin.

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?

One required parameter with 0% schema description coverage. The description only implies 'client_id' via the word 'client'; it does not explain that the ID accepts either an integer or a string, nor what form of identifier is expected. It fails to compensate for the documentation gap.

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

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

States a specific verb ('Get') and resource ('client'), and the resource name distinguishes it from the other admin_get_* siblings. However, it does not explicitly differentiate itself from admin_list_clients or explain the scope of 'details'.

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 when-to-use context is given, and the obvious alternative (admin_list_clients) is never mentioned. The agent must infer that this is the single-record lookup counterpart to the list 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is fully covered without the description. The description adds nothing beyond the purpose sentence - no note on which definition types are supported, whether inactive/deleted fields are returned, or any auth/scope requirement.

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

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

A single front-loaded sentence with zero filler. It is efficient, though at this length it is arguably under-specified rather than optimally concise.

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

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

An output schema exists, so return values need not be described, and annotations cover the safety profile. What remains missing is context the structured fields cannot supply: the distinction between a custom field definition and custom field values, and the expected identifier format.

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?

One required parameter with 0% schema description coverage: custom_field_id is typed only as anyOf integer|string with no explanation. The description does not clarify what form of identifier is expected (numeric ID vs. string key) or where to obtain it, so it fails to compensate for the coverage gap.

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

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

States a specific verb (Get) and resource (details of a custom field definition), which clearly marks it as a single-item lookup as opposed to the sibling admin_list_custom_fields. It stops short of explicitly naming or distinguishing itself from siblings, but the singular 'definition' does the disambiguating work.

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

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

There is no when-to-use guidance, no prerequisite (e.g. where a custom_field_id comes from), and no mention of alternatives such as admin_list_custom_fields or admin_list_custom_field_values. The agent must infer usage entirely from the name.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is fully covered. The description adds only the word 'logged', hinting it operates on persisted rather than draft expenses, but says nothing about admin-level permissions or behavior on a missing/invalid id.

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

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

A single short sentence with the action and target front-loaded and no filler. It is efficient, though so terse that it borders on under-specification rather than true conciseness.

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

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

An output schema exists, so return values need not be described, and the tool is a simple read with one parameter. Still, the identifier's origin and the int-or-string ambiguity are left entirely unresolved for a tool an agent must call 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 sole parameter expense_id has 0% schema description coverage and the description provides no compensating meaning. It does not explain that the id comes from admin_list_expenses, nor address the unusual anyOf integer|string type. This is the one place the description had room to add real value and it did not.

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

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

The description states a clear verb+resource: 'Get details for a specific logged expense.' An agent knows it retrieves one expense record. However, it never distinguishes itself from the adjacent admin_list_expenses sibling, so the differentiation is left implicit.

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

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

There is no when-to-use guidance, no prerequisite (e.g., needing an expense_id obtained from admin_list_expenses), and no named alternative. The single sentence offers no routing information at all.

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?

Annotations already declare readOnlyHint, idempotentHint, non-destructive and openWorld, so the safety profile is fully covered by structured data. The description contributes nothing beyond that — no note on permissions, error behavior for a missing/invalid ID, or lookup semantics — so it adds no behavioral value.

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

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

One short sentence, front-loaded and free of padding, so it is not verbose. But it is under-specified rather than genuinely concise — the brevity comes from omitting useful information.

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

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

Although an output schema exists (so return values need not be described), the definition omits parameter format, ID source, and any routing hint versus admin_list_holidays. For a lookup tool with 0% schema description coverage, this leaves real 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 0% and the single holiday_id parameter accepts an anyOf of integer or string with no explanation of which form is valid or where to obtain the ID. The description's phrase 'specific holiday' adds no meaning beyond what the schema already shows.

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?

Names a verb (Get) and a resource (holiday), and 'specific' implies a single-item lookup, which distinguishes it loosely from admin_list_holidays. However it never names the sibling it contrasts with and gives no scope detail, so the agent must infer the distinction from the tool name alone.

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

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

There is no when-to-use guidance, no statement of prerequisites, and no mention of alternatives such as admin_list_holidays. The agent is left to infer that a known holiday_id is required.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is fully covered elsewhere. The description adds nothing on top of that - no note on lookup behavior, error/not-found semantics, or auth requirements - so it contributes no incremental behavioral context.

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

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

A single short sentence with no wasted words, but its brevity comes from under-specification rather than disciplined compression. It is appropriately sized for a simple lookup but earns little.

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?

An output schema exists, so return values need not be explained, but the description still omits the identifier format for its one required parameter and any distinction from the sibling list/create/update/delete leave-type tools. For a lookup tool it is minimally adequate but leaves real 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 0% and the single parameter leave_type_id is an anyOf of integer or string with no documentation in either place. The description does not clarify the accepted identifier format or which form callers should pass, leaving the only required input under-specified.

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?

It states a verb (Get) and a resource (leave type) scoped to one item, which distinguishes it from the list variant by implication. However, "details" is vague and the sentence largely restates the name and title rather than saying what is actually returned.

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 when-to-use guidance, no prerequisites, and no mention of the obvious alternative admin_list_leave_types. The agent must infer that this is the by-ID lookup versus the collection listing.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so safety is covered. The description adds nothing beyond that – notably it doesn't explain the opaque report_parameters blob, whether results are paginated, or how the open-world report schema is interpreted.

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

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

A single short sentence that is front-loaded and wastes no words, but its brevity stems from under-specification rather than disciplined concision. There is room for another clause about report parameters without bloat.

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

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

An output schema exists, so return values need not be described. However, the one input is an entirely undocumented nested object and the relationship to the sibling admin_get_report_totals is unstated, leaving the agent without enough to call this 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 single required parameter is a free-form object with additionalProperties:true and 0% schema description coverage, so the schema conveys zero semantics. The description must compensate and does not – the structure, keys, or expected report identifiers of report_parameters are never hinted at.

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 largely restates the tool name: 'Generate detailed custom report rows' vs. 'Admin Get Report Rows'. The only added words ('detailed', 'custom') don't tell an agent what distinguishes this from the sibling admin_get_report_totals or what a 'row' contains.

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 versus admin_get_report_totals, which is the obvious alternative for report data. No prerequisites, no mention of whether rows and totals are meant to be called together or what report types are supported.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is covered. The description adds almost nothing beyond that — no indication of auth requirements, scope of the aggregation, or cost/latency. The word 'Generate' could read as a mutation if the annotations weren't present, but it doesn't directly contradict them.

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

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

One short, front-loaded sentence with no filler, so it is concise. But the brevity comes at the cost of substance rather than being tight-but-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?

An output schema exists, so return values need no explanation. But for a tool whose only input is an untyped, undocumented nested object, the description should at minimum describe the shape of report_parameters; it leaves the agent unable to form a valid request.

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

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

The single required parameter 'report_parameters' is a free-form nested object with additionalProperties=true and 0% schema description coverage. The description provides no hint about which keys are accepted, so the agent has essentially nothing to construct a valid call.

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

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

States a verb (Generate) and a resource (aggregated custom report totals), and the 'totals' vs 'rows' wording loosely distinguishes it from the sibling admin_get_report_rows. However, 'custom report' is never defined and the scope of the aggregation is left vague.

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 versus admin_get_report_rows or the many admin_list_* tools. The agent must infer that 'totals' means summarized output rather than row-level data, with no explicit conditions or exclusions 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?

Annotations already declare readOnly, idempotent, non-destructive, and open-world, so the safety profile is covered. The description adds nothing beyond that: it doesn't say what detail set is returned, whether admin privileges are required (the 'admin_' prefix implies it), or what happens for an unknown user_id.

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

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

One short, front-loaded sentence with zero padding or redundancy. It is efficient, though its brevity is partly under-specification rather than disciplined concision.

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?

An output schema exists, so return values needn't be explained, and the operation is simple (one parameter). However, with a polymorphic user_id and no sibling differentiation in a namespace containing several near-identical 'get user'-style tools, the description is thinner than an agent would like.

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

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

Schema description coverage is 0%, so the description carries the full burden for the single user_id parameter and simply doesn't address it. The schema allows either an integer or a string, and the description gives no hint about which form is expected or whether the two are interchangeable.

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 pairs a clear verb ('Get') with a specific resource ('details for a specific user'), so the core purpose is unambiguous. It offers no differentiation from the many closely-related siblings (admin_list_users, admin_get_user_availability, admin_get_user_utilization), which is the only thing keeping it from a 5.

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

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

There is no indication of when to use this tool versus admin_list_users or the user availability/utilization getters. No prerequisites, no exclusions, no alternative named. The agent must infer all routing from the tool name alone.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so safety is covered. The description adds no behavior beyond that: nothing about whether omitted from_date/to_date default to a window, permission requirements, or what the availability comparison includes.

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

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

A single front-loaded sentence with no filler, which is the right size for a simple read. It is terse to the point of under-specification, but nothing is wasted.

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?

An output schema exists so return values need not be described, but with 0% parameter coverage, no usage routing against the overlapping utilization sibling, and no behavioral detail, the definition is too thin for an agent to call it 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?

Schema description coverage is 0% across three parameters, and the description never mentions user_id, from_date, or to_date. It doesn't clarify that user_id accepts either integer or string, nor what format the date strings take or what omitting them means.

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

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

States a specific verb (Query) and resource concept (scheduled hours vs available capacity for a user), so the operation is identifiable. However, it gives no differentiation from the near-identical sibling admin_get_user_utilization, which an agent would reasonably confuse it with.

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

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

There is no statement of when to use this over admin_get_user_utilization, admin_get_user, or the time_* tools, and no prerequisites or exclusions. Usage must be inferred entirely from the name and one-line description.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered by structured data. The description adds only the domain vocabulary of status codes (ITO, WFH, SIC, OOO, VAC, OOF), saying nothing about auth scope, result volume, pagination, or time-range 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?

A single compact sentence that front-loads the action and resource, with the status-code enumeration tucked in parenthetically. Nothing is wasted, though the brevity comes at the cost of missing context.

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?

An output schema exists, so return values need not be described, and annotations cover the safety profile. However, for a user-scoped admin read tool the description omits parameter format, permission requirements, and any temporal scoping, leaving notable 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?

With one required parameter and 0% schema description coverage, the description carries the full burden, but 'a specific user' only restates the obvious. It never clarifies whether user_id is a numeric ID, email, or username, despite the schema accepting both integer and string.

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

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

The description states a specific verb and resource ('Retrieve work status history for a specific user'), which is clearly distinct from the setter sibling admin_set_user_status and from admin_get_user. It does not explicitly name or differentiate itself from any sibling, so it falls short of a 5.

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

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

There is no guidance on when to use this tool versus alternatives such as admin_get_user or admin_get_user_availability, and no stated prerequisites (e.g., admin privileges). Usage is only inferable from the name.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is fully covered elsewhere. The description adds only the 'billable' qualifier to indicate the metric type; it says nothing about date-range scoping, aggregation window, or what the metrics contain.

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

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

A single front-loaded sentence with zero padding. It is efficient, though its brevity contributes to the gaps noted in other dimensions rather than being a model of tight-but-complete writing.

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?

An output schema exists, so return values need not be explained, and the tool is low-complexity with only 3 parameters. Still, the undocumented date-range parameters and the absence of any usage context leave the definition thinner than a read metric tool should be.

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

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

Schema description coverage is 0% across 3 parameters, so the description carries the full documentation burden. 'For a user' loosely maps to user_id, but from_date and to_date are never mentioned, leaving the date-range semantics entirely undocumented in both schema and 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?

States a specific verb (Get) and resource (billable utilization metrics) scoped to a user, which distinguishes it from sibling admin_get_user (profile data) and admin_get_user_availability. It does not, however, explicitly name or contrast with those siblings, so the differentiation is inferable rather than stated.

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 offers no when-to-use guidance, no prerequisites, and no mention of alternatives such as admin_get_user_availability or admin_get_user_bill_rates. An agent must infer the selection criteria from the tool name alone.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds nothing beyond that — no pagination, filtering, ordering, or auth/scope context for a list operation.

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

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

A single short sentence with the resource front-loaded and zero padding. It is efficient, if minimal.

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?

An output schema exists, so return values need no explanation, and annotations carry the safety profile. However, for a list tool the definition omits any note about result scope (all contacts vs. paginated) or the dual integer/string identifier, leaving it only minimally complete.

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

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

Schema description coverage is 0%, and the single client_id parameter accepts either an integer or string without explanation. The description only implies that the parameter identifies a client, which the schema already conveys via the name, so it fails to compensate for the coverage gap.

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

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

States a specific verb+resource (list contacts) with the scoping association (associated with a client). It is clearly distinct from admin_create_client_contact and admin_delete_client_contact, though it does not explicitly name them. Clear 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?

Contains no when-to-use guidance, no preconditions, and no mention of alternatives such as admin_get_client or the create/delete contact siblings. Usage must be inferred entirely from the name.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds nothing beyond that — no pagination behavior, no note on the archived default (null), no indication of result size.

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?

It is short and front-loaded, but this is under-specification rather than conciseness. Two words cannot carry the burden of a three-parameter listing tool.

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

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

An output schema exists, so return values need not be explained, but for a paginated admin list tool the description should at least clarify the archived tri-state and paging. As written, it leaves the agent to infer everything about how results are scoped.

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

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

Schema description coverage is 0% and the description says nothing about page, per_page, or the tri-state archived filter (null/true/false). Three undocumented parameters with zero compensating text — the agent must guess semantics from names and defaults alone.

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?

"List clients." restates the tool name and title verbatim without adding scope, filtering behavior, or differentiation from the many sibling list tools (admin_list_users, admin_list_roles, etc.). It is a tautology rather than an explanation.

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 versus admin_get_client, admin_list_client_contacts, or any other list endpoint. No mention of pagination expectations, the archived filter, 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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, covering the safety profile. The description adds no further behavioral context such as pagination, filtering, or output format; it merely restates the operation.

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

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

A single, front-loaded sentence with no filler. It communicates the operation immediately and every word earns its place.

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

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

For a no-parameter list tool with rich annotations and an output schema, the description is nearly sufficient. It does not need to explain return values, but it also offers no additional scope such as 'all definitions' or pagination behavior that would make it fully self-contained.

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 baseline is 4 per the rubric. Schema coverage is 100% (empty schema), and the description does not need to compensate for any parameter meaning.

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

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

States a specific verb ('List') and resource ('custom field definitions'), which distinguishes it from siblings like admin_list_custom_field_values and admin_get_custom_field. However, it does not explicitly name an alternative or scope, so it lacks the explicit sibling-differentiation of a 5.

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

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

Provides no when-to-use guidance, prerequisites, or alternative tools. The agent can infer it is for reading definitions, but the description offers no selection criteria among the many admin_list_* 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint, so the safety profile is fully covered. The description adds nothing beyond that—no pagination, authorization, or scoping behavior for a tool that lists arbitrary entity data.

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

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

A single short sentence with the resource front-loaded and no filler. Efficient, though its brevity is partly a symptom of under-specification rather than discipline.

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?

An output schema exists so return values need not be described, but with zero parameter documentation, no usage guidance, and no sibling differentiation, the description is too thin for a polymorphic-target admin listing tool.

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

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

Schema description coverage is 0% for both target_id (anyOf integer/string/null) and target_type. The phrase 'for a specific entity' only dimly gestures at these two parameters and gives no accepted type values or ID format, so the description fails to compensate for the coverage gap.

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

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

States a clear verb+resource: list custom field values scoped to a specific entity. It does not, however, differentiate itself from adjacent siblings like admin_list_custom_fields or admin_set_custom_field_values, leaving the agent to infer which one applies.

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 when-to-use guidance, no prerequisites, and no mention of alternatives such as admin_set_custom_field_values or admin_list_custom_fields. The agent gets no help routing between these closely named 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is fully covered by structured data. The description adds only the word 'all', which hints at unfiltered/unpaginated output but stops short of confirming it, so it contributes modest extra context.

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

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

A single six-word sentence with the verb and resource front-loaded and zero filler. Nothing could be trimmed without losing meaning.

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 zero parameters and an output schema present, the description need not explain return values, and annotations carry the safety profile, so the definition is nearly complete. It could still note that results are unfiltered and unpaginated (relevant for a workspace with many disciplines) to fully close the loop.

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

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

The tool takes zero parameters, so there is no parameter semantics for the description to explain; the baseline for a 0-param tool applies. Nothing in the description misleads about inputs.

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

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

States a specific verb ('List') and resource ('disciplines'), making it immediately distinguishable from sibling mutations like admin_create_discipline and admin_delete_discipline. It does not explicitly contrast itself with those siblings, but the naming pattern makes the read intent 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?

Usage is only implied: an agent can infer this is the read path used to discover disciplines before creating, updating, or deleting one. There is no explicit when-to-use statement, no mention of whether the result feeds admin_create_discipline, and no 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?

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds only the word 'configured', which hints that unconfigured categories are excluded, but discloses nothing further about scope, ordering, or pagination behavior.

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

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

A single efficient sentence with no filler, and the operation is front-loaded. It is appropriately sized for a zero-argument list tool, though it stops at the minimum.

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 zero parameters, an output schema present, and rich annotations, the description is adequate for this simple read tool. Return values need not be explained, and nothing essential to calling it correctly is missing.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate. Baseline 4 applies.

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

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

The description states a specific verb ('List') and resource ('expense categories'), making the operation unambiguous. It does not, however, distinguish itself from adjacent siblings such as admin_list_expenses or admin_create_expense_category beyond the resource name.

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

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

There is no when-to-use guidance, no mention of prerequisites, and no routing to alternatives (e.g., admin_create_expense_category for adding new categories). The agent must infer usage from the name alone.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and openWorld, so the safety profile is covered. The description adds only the filter scope and says nothing about pagination defaults (page/per_page) or how date bounds behave, which would be the useful extra context here.

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

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

One tight sentence with the resource and filter scope front-loaded and no filler. Its brevity is appropriate, though it is brief at the cost of the parameter detail the schema lacks.

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?

An output schema exists so return values need not be described, and annotations cover safety. But with six undocumented parameters at 0% schema coverage, the description is incomplete on the filter/pagination semantics an agent needs to call this list tool correctly.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning, and it only hints at project_id and user_id. It says nothing about page, per_page, from_date, or to_date, leaving the time-range and pagination parameters entirely unexplained.

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

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

States a specific verb+resource ('List logged expenses') and its scope ('across projects or filtered by project/user'). It does not name a contrasting sibling such as admin_get_expense or admin_list_expense_categories, so the agent gets clarity on what it does but not on how it differs from neighbors.

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 mention of filtering 'by project/user' implies the use case, but there is no explicit when-to-use, when-not-to-use, or pointer to alternatives like admin_get_expense for a single expense. Usage is inferable but not guided.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is fully covered. The description adds only the fact that both company and regional holidays are returned, which is modest added context beyond the annotations.

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

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

A single short sentence with zero filler and the resource front-loaded. It is efficient, though the brevity edges into under-specification rather than pure 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?

An output schema exists, so return values need not be explained, and annotations cover the safety semantics. The gap is the undocumented date-range parameters and lack of any routing versus admin_get_holiday, making the definition minimally viable rather than complete.

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

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

Schema description coverage is 0% and the description never mentions from_date or to_date, leaving both parameters (and their expected date format) completely undocumented anywhere. With low coverage, the description was obliged to compensate and does not.

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

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

Specific verb (List) and resource (holidays), plus a scope qualifier (company and regional) that helps frame the data. However, it does not distinguish itself from the sibling admin_get_holiday, nor does it mention the date filtering the tool clearly supports.

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 versus admin_get_holiday or the create/update/delete holiday siblings. No prerequisites or exclusions are stated; usage must be inferred entirely from the name.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the agent knows this is a safe, repeatable read. The description adds minor value by exemplifying the content ('Vacation, Sick, Parental, PTO') but says nothing about pagination, ordering, or total-count behavior for what is declared an open-world listing.

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

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

A single front-loaded sentence with the examples placed where they clarify the resource rather than padding. Nothing is wasted and nothing needs to be trimmed.

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?

An output schema exists, so return values need no explanation, and the safety profile is covered by annotations. For a zero-parameter read tool the description is essentially sufficient, with only pagination/ordering behavior left unstated.

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

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

The tool takes zero parameters, so the baseline is 4 and there is no parameter information the description could legitimately add. It neither omits nor misstates anything on this dimension.

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

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

States a clear verb+resource ('List leave types') and the parenthetical gives concrete examples of the values returned, which makes the resource unambiguous. It does not explicitly distinguish itself from admin_get_leave_type or admin_create/update/delete_leave_type, though the plural 'List' verb carries that distinction implicitly.

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 offers no when-to-use guidance, no prerequisite or permission notes, and never names an alternative such as admin_get_leave_type for a single record. The only usage signal is the imperative 'List', which is inferred rather than stated.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is fully covered. The description adds no extra behavior detail (e.g., whether roles are paginated or sorted), so it neither helps nor harms beyond the structured data.

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

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

A single tight sentence with the resource front-loaded and zero filler. Appropriate for a trivial list tool, though it is minimal enough that a little more context could have been included without becoming bloated.

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 an output schema documenting the return shape, rich annotations covering the safety profile, and no input parameters, the description covers everything an agent strictly needs to invoke the tool correctly. Only the usage routing gap keeps it from being 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?

The tool takes zero parameters, so the baseline is 4. There is no parameter semantics for the description to clarify, and the schema fully describes the empty input object.

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

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

States a clear verb (List) and resource (user roles) with scope (all configured). It is distinguishable from admin_create_role/update_role/delete_role by the verb, though it doesn't explicitly call out that distinction.

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 when-to-use guidance, no prerequisites, and no mention of alternatives such as admin_get_user when role detail is needed. Usage must be inferred entirely from the name and verb.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered structurally. The description adds nothing beyond that — no mention of pagination, ordering, or result volume, which is the kind of context that would be genuinely useful here.

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

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

The single sentence is short but that brevity reflects under-specification rather than efficiency. There is no front-loaded scope, filtering note, or routing information to earn the space.

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?

An output schema exists so return values need not be explained, but for a paginated list tool with 0% parameter documentation and no usage context, the description is inadequate. It leaves the agent with only the name to work from.

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

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

Schema description coverage is 0%, so both page and per_page are undocumented in the schema, and the description does not compensate at all — it never mentions pagination, defaults, or limits. The parameters are simple optional integers with defaults, which keeps this above a 1, but the description contributes zero parameter meaning.

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

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

"List tags." restates the tool name (admin_list_tags) almost verbatim and adds no specificity. It does not distinguish this from the many sibling list tools (admin_list_users, admin_list_roles, admin_list_clients), so an agent gains nothing beyond the identifier itself.

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

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

There is no guidance on when to call this versus alternatives, no mention of prerequisites, and no note about pagination behavior when result sets are large. The agent must infer usage entirely from the name.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, providing a clear safety profile. The description adds no additional behavioral context beyond confirming it's a list operation. It doesn't mention pagination, rate limits, or what the tiers represent.

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

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

The description is a single, concise sentence that is front-loaded with the core action. Every word earns its place, with 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?

The tool has an output schema, so return values needn't be explained. However, with only one parameter and 0% schema description coverage, the description should do more to clarify the parameter semantics and usage context. It's minimally complete but leaves gaps for an agent to infer.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'for a user,' which implies the user_id parameter, but doesn't explain the parameter's expected format (integer or string UUID?) or constraints. The anyOf type in the schema suggests flexibility, but the description doesn't clarify.

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

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

The description states a verb (List) and resource (bill rate tiers for a user), which is adequate. However, it doesn't differentiate from the sibling admin_create_user_bill_rate tool or explain how it relates to admin_get_user. It's vague about whether this lists historical tiers or current ones.

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

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

No guidance is provided on when to use this tool vs. alternatives. There is a sibling admin_create_user_bill_rate tool, but the description doesn't mention the relationship or when to choose one over the other. No context on prerequisites or typical use cases.

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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so safety is covered. The description adds only organizational scoping; it says nothing about pagination defaults or whether archived users are excluded by default, which would be genuinely useful 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?

One short sentence, front-loaded with the operation and scope, with no filler. Brevity is appropriate, though it errs toward under-specification given the parameter count.

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?

An output schema exists so return values need not be described. However, with 6 parameters at 0% schema coverage, the description should at minimum explain the archived toggle and pagination defaults, which it omits.

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

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

Schema description coverage is 0% across 6 parameters, so the description carries the burden. It only names role and discipline filtering, leaving page, per_page, archived, and include_billability entirely undocumented anywhere, so agents must guess their semantics.

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

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

States a specific verb (list) and resource (users) with the scope 'in the organization' and notes filterable dimensions. It does not distinguish itself from siblings like admin_get_user or admin_create_user, but for a list tool the operation is unambiguous.

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

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

There is no when-to-use guidance, no mention of when to prefer admin_get_user for a single record, and no prerequisites. The filtering mention implies a use case but gives no alternative-routing information.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true and destructiveHint=false, so the safety profile is fully covered by structured data. The description adds only that the webhooks are organization-scoped, which is modest extra context beyond the annotations.

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

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

A single short sentence with the resource front-loaded and no filler. It is appropriately sized, though it is so terse that it conveys no information beyond the name and title.

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 an output schema present, the description need not explain return values, and the annotations plus zero-parameter schema mean little is missing. The remaining gap is the absence of any hint about pagination or filtering, which is minor for a no-arg list tool.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline of 4 applies. No parameter-related claims are made or needed.

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

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

States a specific verb (List) and resource (organization webhooks) with the scope qualifier 'organization'. It is clear what the tool returns, though it never names the write siblings (admin_create_webhook, admin_delete_webhook) that an agent must distinguish it from.

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

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

There is no explicit guidance on when to use this versus alternatives, no mention of prerequisites (e.g. admin permissions) and no exclusions. The read-only listing intent is only implied by the verb 'List'.

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

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

Annotations already declare idempotentHint=true, destructiveHint=false, readOnlyHint=false and openWorldHint=true, so the safety profile is covered structurally. The description adds nothing beyond that: it does not say whether values are merged or replace existing ones, what happens to unmentioned fields, or what permission level is required for an admin-scoped write.

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

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

A single eight-word sentence is technically compact and front-loaded, but here the brevity reflects under-specification rather than efficiency. There is no structure for an agent to anchor on beyond the bare verb and resource.

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

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

An output schema exists, so return values need not be described. But for a three-parameter mutation tool with a nested free-form object, zero schema coverage, and an open-world admin scope, the description omits the target_type vocabulary, the values format, and any usage context, leaving the agent without enough to call it correctly.

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

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

Schema description coverage is 0% and the three required parameters are entirely undocumented. The phrase 'custom field values for an entity' only loosely hints at the values map and the target_id/target_type pair; it never explains the accepted target_type strings or the expected shape of the nested values object (additionalProperties: true).

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

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

The description names a specific verb ('Set') and resource ('custom field values') and scopes it to 'an entity', so the basic action is identifiable. However, it does not distinguish this write tool from nearby siblings such as admin_list_custom_field_values, admin_create_custom_field, or admin_update_custom_field, and 'entity' is never resolved to a concrete type.

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

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

There is no when-to-use guidance, no mention of prerequisites (e.g., admin privileges, pre-existing custom fields), and no reference to the list/get siblings an agent would need to call first to obtain field identifiers. The agent gets no help choosing this tool over the related custom-field 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?

Annotations already disclose this is a non-read-only, idempotent, non-destructive write, so the safety profile is covered. The description adds the valid status values, but says nothing about permissions required, whether the status overwrites a prior entry or creates a dated record, or how it interacts with timesheets. With annotations carrying the safety load, a 3 is appropriate.

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

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

A single compact sentence with the action front-loaded and the enum list parenthetically attached. Nothing is wasted, though the acronyms would benefit from a brief gloss rather than raw codes.

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?

An output schema exists, so return values need no explanation. But for a mutation of user working status, the definition omits what the codes mean (ITO/WFH/SIC/OOO/VAC/OOF), whether the change is dated or overwrites, and any permission requirement — meaningful gaps for an agent to call this correctly.

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