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

With no annotations, the description carries full burden but only states the action without behavioral details. It doesn't disclose if this is a mutation (likely), requires permissions, has side effects (e.g., triggers workflows), rate limits, or error conditions. This leaves critical behavioral traits unspecified for a tool that presumably changes system state.

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

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

The description is extremely concise—a single sentence with no wasted words—and front-loads the core action. While under-specified, it's structurally efficient, earning full marks for brevity and clarity within its limited scope.

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

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

Given the tool likely performs a mutation (activating workflows) with no annotations, no output schema, and 0% schema coverage, the description is incomplete. It lacks details on behavior, parameters, outcomes, or error handling, making it inadequate for safe and effective use by an AI agent in this context.

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

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

Schema description coverage is 0%, so the description must compensate but adds no parameter information. It doesn't explain 'workflow_id' (e.g., format, where to find it, or if it's a sys_id), leaving the single parameter's meaning and usage unclear beyond the schema's basic title and type.

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

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

The description states the action ('activate') and resource ('workflow in ServiceNow'), which provides a basic understanding of purpose. However, it lacks specificity about what 'activate' means operationally (e.g., enabling execution, setting status) and doesn't distinguish from sibling tools like 'deactivate_workflow' or 'create_workflow', leaving ambiguity about its unique function.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., workflow must exist), exclusions, or comparisons to siblings like 'deactivate_workflow' or 'update_workflow', leaving the agent to infer usage context without explicit direction.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Add a task' implies a write/mutation operation, but the description does not specify permissions required, side effects (e.g., if it triggers notifications or workflows), error conditions, or response format. This leaves critical behavioral traits undocumented for a mutation tool.

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

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

The description is a single, efficient sentence with no wasted words. It is front-loaded and directly states the tool's purpose without unnecessary elaboration, making it easy to parse quickly.

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

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

Given the complexity (a mutation tool with 6 nested parameters), lack of annotations, and no output schema, the description is incomplete. It does not address behavioral aspects, parameter meanings, or usage context, leaving significant gaps for the agent to operate effectively. It only covers the basic purpose, which is insufficient for this tool's needs.

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

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

The description mentions no parameters, while the input schema has 1 parameter ('params') with 6 nested properties (change_id, short_description, etc.). Schema description coverage is 0%, so the schema provides no descriptions for these properties. The description fails to compensate by explaining any parameters, leaving their semantics entirely unclear.

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

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

The description 'Add a task to a change request' clearly states the action (add) and target resource (task to a change request), making the purpose understandable. It distinguishes from siblings like 'add_comment' or 'add_workflow_activity' by specifying 'task' as the resource type. However, it lacks specificity about what kind of task or context, which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., needing an existing change request), exclusions, or related tools like 'update_change_request' or 'create_change_request' from the sibling list. Without such context, 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?

With no annotations provided, the description carries full burden but only states the basic action without behavioral details. It doesn't disclose permissions needed, whether the operation is idempotent, rate limits, or what happens on success/failure (e.g., comment visibility). This leaves significant gaps for a mutation tool.

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

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

The description is a single, clear sentence with zero wasted words—front-loaded with the core action and resource. It's appropriately sized for the tool's apparent simplicity, making it easy to scan and understand quickly.

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

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

Given no annotations, no output schema, and a mutation tool with implicit parameters, the description is incomplete. It lacks behavioral context (e.g., side effects, error handling), doesn't explain return values, and misses parameter details like 'is_work_note'. For a tool that modifies data, this is insufficient.

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

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

The description doesn't explicitly mention parameters, but with 0% schema description coverage and 1 parameter (a nested object with 3 sub-parameters), it implicitly suggests 'incident_id' and 'comment' through context. However, it misses 'is_work_note' entirely. Since 0 parameters are directly documented, baseline is 4, but it's not a 5 due to the missing boolean parameter nuance.

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

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

The description clearly states the action ('Add a comment') and target resource ('to an incident in ServiceNow'), providing a specific verb+resource combination. However, it doesn't differentiate from potential sibling tools like 'resolve_incident' or 'update_incident' that might also involve incident modification, missing explicit 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 guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites (e.g., incident must exist), exclusions, or comparisons to other comment-related tools (none in the sibling list, but context for incident modification isn't clarified).

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

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

With no annotations provided, the description carries full burden for behavioral disclosure but provides minimal information. 'Add a file to a changeset' implies a write/mutation operation, but the description doesn't disclose permission requirements, whether this action is reversible, what happens if the file already exists, rate limits, or what the response looks like. For a mutation tool with zero annotation coverage, this is inadequate.

Agents need to know what a tool does to the 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 maximally concise with a single clear sentence: 'Add a file to a changeset in ServiceNow.' Every word earns its place - 'Add' (action), 'a file' (object), 'to a changeset' (target), 'in ServiceNow' (context). There's zero waste or redundancy.

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

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

For a mutation tool with 3 parameters, 0% schema description coverage, no annotations, and no output schema, the description is severely incomplete. It states what the tool does at a high level but provides no information about parameters, behavioral characteristics, error conditions, or expected outcomes. The agent would struggle to use this tool correctly without additional context.

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

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

Schema description coverage is 0%, meaning none of the 3 parameters have descriptions in the schema. The tool description provides no parameter information whatsoever - it doesn't mention changeset_id, file_path, or file_content. The description fails to compensate for the complete lack of schema documentation, leaving all parameters semantically undefined.

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

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

The description clearly states the action ('Add a file') and target resource ('to a changeset in ServiceNow'), providing specific verb+resource pairing. It distinguishes from sibling tools like 'create_changeset' or 'commit_changeset' by focusing on file addition rather than changeset creation or finalization. However, it doesn't explicitly differentiate from potential file-related operations that might exist in other contexts.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing changeset), when not to use it, or what alternatives exist for similar operations. The agent must infer usage from the tool name alone without contextual guidance.

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

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

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no 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?

Tool has no description.

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

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

Tool has no 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a write operation ('Add') but doesn't specify permissions required, whether the addition is reversible, error conditions, or response format. This is inadequate for a mutation tool with zero annotation coverage.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded, making it easy to parse quickly.

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

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

For a mutation tool with no annotations, no output schema, and 5 nested parameters (via 'params'), the description is incomplete. It lacks details on behavior, parameters, error handling, and relationships to sibling tools, making it insufficient for safe and effective use by an AI agent.

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

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

The description mentions no parameters, while the input schema has 1 parameter ('params') with 5 nested properties. With 0% schema description coverage, the description fails to add any semantic context beyond what's in the schema, leaving parameters like 'workflow_version_id' and 'activity_type' 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 clearly states the action ('Add a new activity') and resource ('to a workflow in ServiceNow'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'create_workflow' or 'update_workflow_activity', which would require more specificity about what constitutes an 'activity' versus a 'workflow'.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing workflow version), exclusions, or relationships to sibling tools like 'get_workflow_activities' or 'delete_workflow_activity', leaving the agent to infer usage context.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states the action ('approve') but doesn't explain what approval entails—whether it's reversible, requires specific permissions, triggers notifications, or updates the change status. For a mutation tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence with zero wasted words. It's appropriately sized for a simple action, though this brevity contributes to gaps in other dimensions.

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

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

Given the tool's mutation nature, lack of annotations, no output schema, and 0% schema description coverage, the description is incomplete. It doesn't address behavioral implications, parameter usage, or how this tool fits with siblings like 'reject_change', making it inadequate for informed agent decision-making.

Complex tools with many parameters or behaviors need more documentation. 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 for undocumented parameters. It mentions no parameters at all, failing to clarify that 'change_id' is required or that 'approver_id' and 'approval_comments' are optional. This leaves the agent reliant solely on the schema without contextual guidance.

Input schemas describe structure but not intent. Descriptions should explain 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 'Approve a change request' clearly states the verb ('approve') and resource ('change request'), making the purpose understandable. However, it doesn't differentiate from the sibling 'reject_change' tool, which handles the opposite action on the same resource type, leaving room for ambiguity about when to use each.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'reject_change' or 'submit_change_for_approval'. It lacks context about prerequisites (e.g., whether the change must be in a pending approval state) or typical workflows, leaving the agent to infer usage from tool names alone.

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

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

With no annotations provided, the description carries full burden but only states the action without behavioral details. It doesn't disclose whether this is a destructive/mutative operation, permission requirements, side effects, or what happens post-commit (e.g., status changes). For a tool that likely modifies data, this is inadequate.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded with the core action and resource, making it easy to parse quickly.

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

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

For a tool with no annotations, no output schema, and 0% schema description coverage, the description is insufficient. It doesn't explain the tool's role in the ServiceNow change management lifecycle, what committing entails, or expected outcomes, leaving the agent with minimal actionable context.

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

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

Schema description coverage is 0%, so the description must compensate but adds no parameter information. It doesn't explain what a changeset ID is, where to find it, or the purpose/format of the commit message. With 1 required parameter and 1 optional parameter undocumented, this leaves significant gaps.

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

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

The description 'Commit a changeset in ServiceNow' clearly states the action (commit) and target resource (changeset) with platform context (ServiceNow). It distinguishes from siblings like 'publish_changeset' by specifying the commit operation rather than publishing, though it doesn't explicitly contrast them.

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

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

No guidance is provided on when to use this tool versus alternatives like 'publish_changeset' or 'update_changeset', nor does it mention prerequisites such as needing an existing changeset. The description lacks context about typical workflow sequencing.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Create a new knowledge article' implies a write/mutation operation, but it doesn't disclose any behavioral traits like permission requirements, whether the article is immediately published or in draft state, what happens on duplicate titles, or any rate limits. For a creation tool with zero annotation coverage, this is insufficient.

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

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

The description is extremely concise - a single 5-word sentence that gets straight to the point with zero wasted words. It's perfectly front-loaded and appropriately sized for what it does convey.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 creation tool with 7 parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain what parameters are needed, what the tool returns, or any behavioral context. While conciseness is good, the description fails to provide the necessary context for effective tool use.

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

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

The description mentions no parameters at all, while the input schema shows 7 parameters (article_type, category, keywords, knowledge_base, short_description, text, title) with 5 required. With 0% schema description coverage and no parameter information in the description, this represents a significant gap in documentation.

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

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

The description 'Create a new knowledge article' clearly states the verb (create) and resource (knowledge article), but it's somewhat generic and doesn't differentiate from sibling tools like 'create_knowledge_base' or 'create_category'. It's adequate but lacks specificity about what distinguishes this particular creation operation.

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

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

The description provides no guidance on when to use this tool versus alternatives. There are multiple 'create' tools in the sibling list (create_knowledge_base, create_category, create_change_request, etc.), but no indication of when this specific article creation tool is appropriate versus those other creation operations.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Create' implies a write/mutation operation, but the description doesn't state whether this requires specific permissions, what happens on success/failure, if there are rate limits, or if the creation is irreversible. For a mutation tool with zero annotation coverage, this leaves significant behavioral gaps.

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

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

The description is a single, clear sentence with zero wasted words. It's front-loaded with the core action and resource, making it immediately scannable. Every word earns its place by conveying essential purpose without redundancy.

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

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

Given the complexity (a mutation tool with 6 parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what parameters are needed, what the tool returns, or any behavioral constraints. While concise, it fails to provide the contextual information necessary for safe and effective use by an AI agent.

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

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

The schema description coverage is 0%, meaning none of the parameters are documented in the schema. The description provides no information about parameters beyond what's implied by 'category' (e.g., it doesn't mention required fields like 'title' or optional ones like 'description', 'icon', etc.). With 6 parameters (nested under 'params') completely undocumented, the description fails to compensate for the schema's lack of documentation.

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

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

The description clearly states the action ('Create') and resource ('new service catalog category'), making the purpose immediately understandable. It distinguishes from siblings like 'update_catalog_category' and 'list_catalog_categories' by specifying creation rather than modification or listing. However, it doesn't explicitly mention what distinguishes it from 'create_category' (a sibling tool), which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing admin rights), when to choose this over 'update_catalog_category' for modifications, or how it relates to 'create_category' (another sibling). Without any usage context, the agent must infer when this tool is appropriate.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states it's a creation operation but lacks details on permissions required, whether it's idempotent, error handling, or what happens on success (e.g., returns a category ID). This is a significant gap for a mutation tool with zero annotation coverage.

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

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

The description is a single, efficient sentence that front-loads the core purpose without unnecessary words. Every part of the sentence earns its place by specifying the action, resource, and 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?

Given the tool's complexity (a mutation operation with 5 parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't explain parameters, behavioral traits, or return values, making it inadequate for safe and effective tool invocation by an agent.

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

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

The description provides no information about parameters, while the schema has 5 parameters (active, description, knowledge_base, parent_category, title) with 0% description coverage in the schema. This leaves all parameters undocumented, failing to compensate for the schema's lack of descriptions.

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

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

The description clearly states the action ('Create') and resource ('a new category in a knowledge base'), making the purpose immediately understandable. It distinguishes from siblings like 'create_catalog_category' by specifying the knowledge base context, though it doesn't explicitly contrast with 'list_categories' or other category-related tools.

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

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

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites (e.g., needing an existing knowledge base), exclusions, or comparisons with sibling tools like 'list_categories' or 'create_catalog_category', leaving the agent without context for tool selection.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states this is a creation operation but provides no information about permissions required, whether this triggers workflows or notifications, what happens on success/failure, or any side effects. The description doesn't compensate for the lack of 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?

The description is extremely concise at just 7 words, front-loading the essential action and resource. There's no wasted language or unnecessary elaboration, making it efficient for an agent to parse.

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

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

For a creation tool with 10 parameters, 0% schema description coverage, no annotations, and no output schema, this description is severely inadequate. It doesn't explain what constitutes a valid change request, what happens after creation, or provide any context about the ServiceNow change management process.

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

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

The schema description coverage is 0%, meaning none of the 10 parameters have descriptions in the schema. The tool description provides absolutely no information about parameters, not even mentioning the required 'short_description' and 'type' fields or explaining what a change request consists of.

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

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

The description clearly states the verb ('Create') and resource ('a new change request in ServiceNow'), making the purpose immediately understandable. However, it doesn't differentiate this tool from its sibling 'update_change_request' or explain what distinguishes creating from updating a change request.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'update_change_request' or 'list_change_requests'. There's no mention of prerequisites, appropriate contexts, or when this tool should be avoided in favor of other options.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Create a new changeset' implies a write/mutation operation, but the description doesn't disclose any behavioral traits: no information about permissions required, whether this is reversible, what happens on success/failure, rate limits, or what the response contains. For a creation tool with zero annotation coverage, this is a significant gap in behavioral transparency.

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

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

The description is extremely concise at just 6 words. It's front-loaded with the core action and resource. There's zero wasted language or redundancy. While it may be too brief for adequate tool understanding, from a pure conciseness perspective, it's maximally efficient.

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

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

Given the complexity (creation/mutation operation), lack of annotations, lack of output schema, and multiple sibling tools in the same domain, the description is incomplete. It doesn't explain what a changeset is, how it fits into the ServiceNow workflow, what happens after creation, or what the tool returns. For a mutation tool with no structured safety or behavioral annotations, the description should provide more context about the operation's role and consequences.

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

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

The description provides zero information about parameters. With 0% schema description coverage and 4 parameters (name, application, description, developer), the description doesn't add any meaning beyond what the input schema provides. The schema itself has good parameter descriptions, but the tool description doesn't compensate for the lack of schema description coverage or provide any additional context about parameter usage, constraints, or relationships.

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

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

The description states 'Create a new changeset in ServiceNow' which clearly indicates the action (create) and resource (changeset). However, it doesn't differentiate from sibling tools like 'update_changeset' or 'commit_changeset', nor does it specify what a changeset is in this context. The purpose is clear but lacks specificity about what distinguishes this creation operation from other changeset-related operations.

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

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

The description provides no guidance on when to use this tool versus alternatives. There are multiple sibling tools related to changesets (create_changeset, update_changeset, commit_changeset, publish_changeset, add_file_to_changeset, get_changeset_details, list_changesets), but the description doesn't indicate when this initial creation step is appropriate versus updating an existing changeset or other operations. No context about prerequisites or workflow sequencing is provided.

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

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

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no 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?

Tool has no description.

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

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

Tool has no 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. While 'Create' implies a write/mutation operation, the description doesn't disclose important behavioral traits like required permissions, whether this is an idempotent operation, what happens on failure, or what the typical response looks like. This leaves significant gaps for an agent to understand how to use this tool effectively.

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

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

The description is extremely concise at just 5 words, front-loading the essential information without any wasted words. It follows a clear subject-verb-object structure that immediately communicates the core purpose.

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

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

For a mutation tool with 10 parameters, no annotations, no output schema, and 0% schema description coverage, the description is severely inadequate. It doesn't explain what constitutes a valid incident, what fields are required beyond 'short_description', what the tool returns, or any error conditions. The agent would struggle to use this tool correctly without additional context.

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

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

The description provides zero information about parameters, while the schema has 0% description coverage (the schema only has titles, not descriptions). With 10 parameters in the schema and no parameter guidance in the description, this creates a significant knowledge gap about what each parameter means and how they should be used together.

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

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

The description clearly states the action ('Create') and resource ('new incident in ServiceNow'), making the purpose immediately understandable. However, it doesn't differentiate this tool from other incident-related tools like 'update_incident' or 'resolve_incident' that also exist in the sibling tool list, which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'update_incident' or 'resolve_incident' from the sibling list. It also doesn't mention prerequisites, dependencies, or any context about when incident creation is appropriate versus other operations.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While 'Create' implies a write operation, it doesn't specify required permissions, whether creation is immediate or requires approval, what happens on failure, or any rate limits. For a mutation tool with zero annotation coverage, this leaves significant behavioral questions unanswered.

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

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

The description is a single, efficient sentence that gets straight to the point with zero wasted words. It's appropriately sized for a basic tool description and front-loads the essential information.

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

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

For a creation tool with 6 parameters, no annotations, and no output schema, the description is severely incomplete. It doesn't explain what a knowledge base is, what parameters are required, what the tool returns, or any behavioral aspects. The agent would struggle to use this tool effectively without additional context.

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

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

The description mentions no parameters at all, while the input schema shows 6 parameters (title, description, managers, owner, publish_workflow, retire_workflow) with 0% schema description coverage. The description fails to compensate for this complete lack of parameter documentation, leaving the agent with no guidance on what information is needed to create a knowledge base.

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

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

The description clearly states the action ('Create') and resource ('knowledge base in ServiceNow'), making the purpose immediately understandable. However, it doesn't differentiate this from other creation tools like create_article, create_category, or create_change_request, which would require specifying what distinguishes a knowledge base from these other entities.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, appropriate contexts, or how this differs from similar creation tools like create_article or create_category. The agent must infer usage from the tool name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is a creation operation, implying it's a write/mutation tool, but doesn't mention any behavioral traits like permission requirements, whether it's idempotent, what happens on duplicate names, error conditions, or response format. For a mutation tool with zero annotation coverage, this leaves significant gaps in understanding how it behaves.

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

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

The description is a single, efficient sentence with zero wasted words. It's front-loaded with the core action and resource, making it immediately scannable. Every word earns its place by conveying essential information about what the tool does.

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

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

Given this is a mutation tool with no annotations, no output schema, and 7 sub-parameters (though nested under one parameter), the description is incomplete. It doesn't explain what a script include is, when to use it, what permissions are needed, what the response contains, or how it differs from similar creation tools. The agent has insufficient context to use this tool effectively beyond the basic action.

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

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

The schema description coverage is 0%, meaning none of the parameters have descriptions in the schema. The tool description doesn't mention any parameters at all, so it adds no semantic information beyond what's in the schema property names. However, with 1 parameter (a nested object with 7 sub-parameters), the baseline is 3 since the schema at least provides property names and types, though without descriptions.

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

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

The description clearly states the action ('Create') and resource ('a new script include in ServiceNow'), making the purpose immediately understandable. It distinguishes from sibling tools like 'update_script_include' and 'delete_script_include' by specifying creation rather than modification or deletion. However, it doesn't specify what a script include is or its typical use cases, which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing admin permissions), when script includes are appropriate versus other ServiceNow scripting methods, or how it relates to siblings like 'create_workflow' or 'create_article'. The agent must infer usage 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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no 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?

Tool has no description.

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

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

Tool has no 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is a creation operation, implying it's a write/mutation tool, but doesn't describe what happens upon creation (e.g., whether the workflow is immediately active, if it requires approval, or what the response looks like). It lacks details on permissions, side effects, or error conditions, leaving significant gaps for a mutation tool.

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

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

The description is a single, direct sentence with zero wasted words. It front-loads the core action and resource, making it immediately scannable. Every word earns its place by conveying the essential purpose without redundancy or fluff.

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

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

For a mutation tool with no annotations, 0% schema description coverage, and no output schema, the description is inadequate. It doesn't explain parameters, behavioral traits, or what to expect upon success/failure. While concise, it lacks the necessary context for an agent to use this tool effectively beyond the basic action implied by the 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?

The schema description coverage is 0%, meaning none of the parameters have descriptions in the schema. The tool description provides no information about parameters beyond what's implied by the name ('create_workflow'). It doesn't mention required fields like 'name', optional fields like 'active' or 'table', or their purposes, failing to compensate for the complete lack of schema documentation.

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

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

The description clearly states the action ('Create') and resource ('a new workflow in ServiceNow'), making the purpose immediately understandable. It distinguishes this from sibling tools like 'update_workflow' or 'list_workflows' by specifying creation rather than modification or retrieval. However, it doesn't explicitly differentiate from other creation tools like 'create_article' or 'create_incident' beyond the resource type.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., required permissions), when not to use it (e.g., for updating existing workflows), or refer to sibling tools like 'update_workflow' for modifications. The agent must infer usage from the tool name alone.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states the action ('deactivate') which implies mutation, but doesn't disclose whether this requires specific permissions, whether the deactivation is reversible, what happens to active instances, or any rate limits. For a mutation tool with zero annotation coverage, this is a significant gap.

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

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

The description is a single, efficient sentence with zero waste. It's appropriately sized for a simple tool and front-loads the essential information without unnecessary elaboration.

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

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

For a mutation tool with no annotations, no output schema, and 0% schema description coverage, the description is inadequate. It doesn't explain what 'deactivate' means operationally, what the response looks like, or any behavioral implications. Given the complexity of workflow management and the lack of structured documentation, more context is needed.

Complex tools with many parameters or behaviors need more documentation. 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. However, the description provides no information about the single parameter 'workflow_id' beyond what's in the schema. The schema already documents this parameter adequately, so the baseline of 3 is appropriate despite 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 clearly states the action ('deactivate') and target resource ('a workflow in ServiceNow'), providing specific verb+resource information. However, it doesn't distinguish this tool from its sibling 'activate_workflow' beyond the opposite action, missing explicit differentiation about when to use one versus the other.

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

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

No guidance is provided about when to use this tool versus alternatives like 'activate_workflow' or 'update_workflow'. The description states what it does but offers no context about appropriate use cases, prerequisites, or exclusions.

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

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

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no 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?

Tool has no description.

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

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

Tool has no 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. While 'Delete' implies a destructive operation, it doesn't specify whether deletion is permanent, requires special permissions, affects workflow integrity, or has confirmation steps. This is inadequate for a destructive tool with zero annotation coverage.

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

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

The description is a single, efficient sentence with zero wasted words. It's appropriately sized for a simple operation and front-loads the essential information (delete + target).

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

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

For a destructive tool with no annotations, no output schema, and 0% schema coverage, the description is incomplete. It doesn't address behavioral risks, parameter details, or expected outcomes. Given the complexity of workflow management and sibling tools, more context is needed for safe and effective use.

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

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

Schema description coverage is 0%, so the schema provides no parameter documentation. The description mentions 'activity' but doesn't explain what an 'activity_id' represents, its format, or how to obtain it. It adds minimal semantic value beyond what's implied by the tool 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 clearly states the action ('Delete') and target ('an activity from a workflow'), making the purpose unambiguous. However, it doesn't distinguish this tool from sibling tools like 'delete_script_include' or explain what makes workflow activities different from other deletable entities.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., whether the workflow must be deactivated first), consequences of deletion, or relationships to sibling tools like 'reorder_workflow_activities' or 'get_workflow_activities'.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states the action ('Get') but doesn't describe what 'Get' entails—whether it returns full content, metadata, permissions needed, error handling, or if it's a read-only operation. For a retrieval tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence with zero wasted words. It's front-loaded with the core action and resource, making it easy to parse quickly. Every word earns its place, achieving optimal conciseness for this simple 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?

Given the tool's simplicity (1 parameter, no output schema, no annotations), the description is incomplete. It lacks details on return values, error cases, permissions, or how it differs from siblings like 'list_articles'. For a basic retrieval tool, more context is needed to fully guide an agent, especially without annotations or output schema.

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

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

Schema description coverage is 0%, so the description must compensate for parameter documentation. It mentions 'by ID', which aligns with the 'article_id' parameter in the schema, adding minimal semantic context. However, it doesn't explain the ID format, source, or constraints, leaving the parameter only partially clarified beyond the schema's basic structure.

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

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

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('knowledge article by ID'), making it immediately understandable. However, it doesn't explicitly distinguish this from sibling tools like 'list_articles' or 'get_catalog_item', which would require more specific differentiation to achieve a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'list_articles' for browsing or 'get_catalog_item' for similar retrieval operations, nor does it specify prerequisites such as needing an existing article ID. This leaves the agent without contextual usage direction.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. It fails to describe any behavioral traits: it doesn't indicate if this is a read-only operation, what permissions are required, how errors are handled (e.g., invalid item_id), or the format of the returned data. For a tool with zero annotation coverage, this is a significant gap.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is front-loaded with the core action and resource, making it easy to parse quickly. Every word earns its place, adhering to ideal conciseness.

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

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

Given the complexity (a read operation with one parameter), lack of annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects like safety, error handling, or return format, nor does it clarify parameter semantics. For a tool in this context, more detail is needed to guide effective use.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It adds no information about the 'item_id' parameter beyond what the schema minimally provides (type and requirement). The description doesn't explain what constitutes a valid 'item_id', where to find it, or provide examples, leaving semantics unclear.

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

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

The description clearly states the action ('Get') and resource ('a specific service catalog item'), making the purpose understandable. It distinguishes this from sibling tools like 'list_catalog_items' by specifying retrieval of a single item rather than listing multiple items. However, it doesn't explicitly differentiate from other 'get_' tools like 'get_article' or 'get_user', which follow similar patterns.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an item ID), contrast with 'list_catalog_items' for browsing, or specify error conditions. Without such context, the agent must infer usage from the tool name and schema 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?

No annotations are provided, so the description carries full burden. While 'Get detailed information' implies a read-only operation, it doesn't disclose important behavioral aspects like authentication requirements, rate limits, error conditions, or what constitutes 'detailed information' versus basic data. For a tool with zero annotation coverage, this leaves significant gaps in understanding how the tool behaves.

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

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

The description is a single, clear sentence that efficiently states the tool's purpose. It's appropriately sized for a simple retrieval tool and front-loads the essential information without unnecessary elaboration. However, it could be slightly more specific about what 'detailed information' includes.

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

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

For a tool with no annotations, no output schema, and minimal parameter documentation, the description is insufficient. It doesn't explain what information is returned, how errors are handled, or any prerequisites for using the tool. Given the context of change management systems where permissions and data sensitivity are important, more contextual information would be valuable for an AI agent.

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

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

With 0% schema description coverage (the parameter 'change_id' has no description in the schema), the description doesn't add any parameter-specific information. It mentions 'specific change request' which aligns with the parameter name but provides no additional semantics about what format the ID should be, where to find it, or validation requirements. The baseline is 3 since there's only one parameter, but the description doesn't compensate for the schema's lack of documentation.

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

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

The description states the tool 'Get detailed information about a specific change request', which clearly indicates a read operation on change requests. However, it doesn't differentiate from similar sibling tools like 'get_changeset_details' or 'get_workflow_details', leaving ambiguity about what distinguishes this specific retrieval operation from others in the same domain.

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

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

The description provides no guidance on when to use this tool versus alternatives. With sibling tools like 'list_change_requests' and 'get_changeset_details', there's no indication whether this tool is for individual records versus lists, or how it relates to other retrieval operations. The agent must infer usage from the tool name alone.

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

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

With no annotations provided, the description carries full burden but only states it 'gets' information, implying a read-only operation. It lacks behavioral details such as authentication requirements, error handling (e.g., for invalid IDs), rate limits, or what happens if the changeset doesn't exist. This is inadequate for a tool with potential complexity.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded with the core purpose, making it easy to scan. Every word earns its place, though it could benefit from additional 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?

Given no annotations, no output schema, and low schema coverage, the description is incomplete. It doesn't address return values, error conditions, or operational constraints. For a tool that likely returns structured data about changesets, more context is needed to use it effectively.

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

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

Schema description coverage is 0%, and the description adds no parameter information beyond implying a 'specific changeset'. It doesn't explain the 'changeset_id' parameter's format, validation rules, or where to obtain it (e.g., from 'list_changesets'). With 1 undocumented parameter, the description fails to compensate for the schema 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 'Get detailed information about a specific changeset' clearly states the verb ('Get') and resource ('changeset'), but it's vague about what 'detailed information' entails. It distinguishes from siblings like 'list_changesets' (which lists multiple) but doesn't specify what details are included beyond the basic concept.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a valid changeset ID), contrast with 'list_changesets' for browsing, or specify use cases like reviewing changeset metadata before actions like 'update_changeset' or 'publish_changeset'.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool 'Get optimization recommendations', implying a read-only operation, but does not disclose any behavioral traits such as whether it requires authentication, has rate limits, returns structured data, or involves any side effects. For a tool with zero annotation coverage, this leaves significant gaps in understanding how it behaves.

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

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

The description is a single, efficient sentence: 'Get optimization recommendations for the service catalog.' It is front-loaded with the core action and resource, with no wasted words or unnecessary elaboration. Every part of the sentence contributes directly to the tool's purpose.

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

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

Given the complexity of optimization recommendations, lack of annotations, no output schema, and low parameter coverage, the description is incomplete. It does not explain what the recommendations include, how they are returned, or any dependencies. For a tool that likely provides actionable insights, more context is needed to guide effective use.

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

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

The input schema has 1 parameter ('params') with 0% description coverage, and the description does not add any meaning beyond the schema. It does not explain what 'category_id' or 'recommendation_types' are, their expected formats, or examples of valid values. With low schema coverage, the description fails to compensate, leaving parameters largely 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 the tool 'Get optimization recommendations for the service catalog', which provides a basic verb ('Get') and resource ('optimization recommendations for the service catalog'). However, it lacks specificity about what these recommendations entail (e.g., cost savings, performance improvements) and does not differentiate from siblings like 'get_catalog_item' or 'list_catalog_items', which might retrieve catalog data without optimization insights. The purpose is clear but vague in scope.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention any context, prerequisites, or exclusions, such as whether it requires specific permissions or should be used after other operations. With siblings like 'get_catalog_item' or 'list_catalog_items', there is no indication of when optimization recommendations are needed over basic catalog data retrieval.

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

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

No annotations are provided, so the description carries full burden. It states 'Get' which implies a read operation, but doesn't disclose behavioral traits like authentication needs, rate limits, error handling, or what happens if the script include doesn't exist. For a tool with zero annotation coverage, this is a significant gap.

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

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

The description is a single, efficient sentence with zero waste, front-loading the core purpose. It's appropriately sized for a simple retrieval 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?

Given no annotations, no output schema, and low schema description coverage (0%), the description is incomplete. It lacks details on behavior, parameters, return values, and usage context, making it inadequate for a tool that retrieves data from a complex system like ServiceNow.

Complex tools with many parameters or behaviors need more documentation. 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%, with one parameter ('script_include_id') documented only as 'Script include ID or name' in the schema. The description adds no information about parameter semantics, format, examples, or constraints, failing to compensate for the low coverage.

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

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

The description clearly states the verb ('Get') and resource ('a specific script include from ServiceNow'), making the purpose understandable. It distinguishes from sibling 'list_script_includes' by specifying 'specific' rather than listing, though it doesn't explicitly name the sibling alternative.

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

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

No guidance is provided on when to use this tool versus alternatives like 'list_script_includes' or 'create_script_include'. The description implies usage for retrieving a single script include but offers no context about prerequisites, error conditions, or comparisons to other tools.

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

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

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no 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?

Tool has no description.

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

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

Tool has no 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?

No annotations are provided, so the description must fully disclose behavioral traits. It only states the action ('Get activities') without any details on permissions required, rate limits, pagination, error handling, or what the output looks like (e.g., list format, fields included). For a read operation with zero annotation coverage, this is a significant gap in transparency, though it doesn't contradict any 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?

The description is a single, straightforward sentence: 'Get activities for a specific workflow.' It is front-loaded and wastes no words, making it efficient. However, it could be more informative without sacrificing conciseness, such as by adding a brief note on parameters or usage 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?

Given the complexity (a read operation with parameters), lack of annotations, no output schema, and 0% schema description coverage, the description is incomplete. It doesn't cover parameter meanings, behavioral aspects like permissions or output format, or differentiation from sibling tools. This makes it inadequate for the agent to use the tool confidently without additional context.

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

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

Schema description coverage is 0%, meaning the input schema provides no descriptions for parameters. The description does not mention any parameters, failing to compensate for this gap. It doesn't explain that 'workflow_id' is required or that 'version' is optional for filtering activities by version. This leaves the agent with minimal guidance on how to use the tool effectively.

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

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

The description 'Get activities for a specific workflow' clearly states the verb 'Get' and resource 'activities for a specific workflow', making the purpose understandable. However, it's somewhat vague about what 'activities' entail (e.g., tasks, steps, logs) and doesn't differentiate from siblings like 'get_workflow_details' or 'list_workflow_versions', which might provide related information. This meets the minimum viable standard but lacks specificity.

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

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

The description provides no guidance on when to use this tool versus alternatives. With siblings such as 'get_workflow_details' (which might include activity information) and 'list_workflow_versions' (which could relate to version-specific activities), there's no indication of context, prerequisites, or exclusions. This leaves the agent to guess based on tool names alone, which is inadequate.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool is for getting information, implying a read-only operation, but doesn't specify permissions, rate limits, error conditions, or what 'detailed information' includes. For a tool with zero annotation coverage, this is insufficient to inform the agent about behavioral traits.

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

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

The description is a single, clear sentence that efficiently states the tool's purpose without unnecessary words. It's front-loaded with the core action and resource, making it easy to parse. However, it could be more specific to improve utility without sacrificing conciseness.

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

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

Given the lack of annotations and output schema, the description is incomplete. It doesn't explain what 'detailed information' includes, how to handle the 'include_versions' parameter, or the response format. For a tool in a complex environment with many siblings, more context is needed to guide effective use.

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

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

The description doesn't explicitly mention parameters, but with only one required parameter ('workflow_id'), the tool's purpose inherently implies its use. Schema description coverage is 0%, but the parameter is straightforward (a workflow ID). The description's focus on 'specific workflow' aligns with the parameter, adding minimal but adequate context beyond the schema.

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

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

The description states the tool's purpose as 'Get detailed information about a specific workflow', which is clear but vague. It specifies the verb ('Get') and resource ('workflow'), but doesn't distinguish it from sibling tools like 'get_workflow_activities' or 'list_workflows'. The description is adequate but lacks specificity about what 'detailed information' entails.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'list_workflows' for listing workflows or 'get_workflow_activities' for activity details, nor does it specify prerequisites or contexts for usage. This leaves the agent without direction on tool selection.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure but offers minimal insight. It implies a read-only operation by using 'list', but doesn't clarify aspects like pagination behavior, rate limits, authentication needs, or what happens if no articles match filters. The description lacks details on return format, error conditions, or any constraints beyond the basic action.

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

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

The description is extremely concise with just three words, which could be seen as efficient but results in under-specification. It's front-loaded but lacks necessary detail, making it more sparse than appropriately brief. While not verbose, it doesn't earn its place by adding value beyond the tool name.

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

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

Given the complexity (6 parameters with no schema description coverage, no annotations, no output schema), the description is completely inadequate. It doesn't explain what 'list' returns, how filters work, pagination behavior, or any operational context. For a tool with multiple filtering options and no structured guidance, this description leaves critical gaps for an AI agent.

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

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

The description provides no information about parameters, while the schema has 0% description coverage (parameters are documented but schema-level description is absent). With 6 parameters (category, knowledge_base, limit, offset, query, workflow_state) all undocumented in the description, the agent lacks context on how these filters interact or their practical use. The description fails to compensate for the schema 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 'List knowledge articles' is a tautology that merely restates the tool name 'list_articles' with minimal elaboration. It specifies the resource (knowledge articles) but lacks a clear verb beyond 'list' and doesn't differentiate from sibling tools like 'get_article' or 'list_categories'. The purpose is vague about what 'list' entails operationally.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'get_article' for retrieving a single article or 'list_categories' for different resources, nor does it specify any prerequisites, contexts, or exclusions for usage. This leaves the agent without direction on tool selection.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. 'List' implies a read operation, but the description doesn't mention pagination behavior (though schema hints at it via limit/offset), authentication requirements, rate limits, or what the output looks like. It's minimally informative for a tool with parameters.

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

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

The description is a single, efficient sentence with zero wasted words. It's appropriately sized for a basic listing tool and front-loads the core purpose 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?

Given the tool's moderate complexity (4 parameters for filtering/pagination), lack of annotations, and no output schema, the description is insufficient. It doesn't explain return values, error conditions, or how parameters interact, leaving the agent with inadequate context to use the tool effectively beyond its 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?

The description mentions no parameters, while the schema has 4 parameters (active, limit, offset, query) with 0% schema description coverage. This leaves all parameter meanings undocumented in both schema and description, creating significant gaps for the agent to understand filtering, pagination, and search capabilities.

Input schemas describe structure but not intent. Descriptions should explain 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 'List service catalog categories' clearly states the verb ('List') and resource ('service catalog categories'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'list_categories' or 'list_catalog_items', leaving ambiguity about scope and relationship to similar listing operations.

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

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

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'list_categories', 'list_catalog_items', and 'get_catalog_item', there's no indication of whether this tool is for browsing, filtering, or specific catalog contexts, leaving the agent to guess based on naming 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'List' implies a read-only operation, but the description doesn't clarify if it's safe, if it requires authentication, what the output format is, or if there are rate limits. For a tool with zero annotation coverage, this is a significant gap in behavioral context.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded with the core action and resource, making it easy to parse quickly. Every word earns its place by conveying essential information without redundancy.

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

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

Given the complexity (a list operation with filtering and pagination), no annotations, and no output schema, the description is minimally complete. It states what the tool does but lacks details on behavior, output, or error handling. The schema provides good parameter documentation, but overall context is limited, making it adequate but with clear gaps for effective tool use.

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

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

The input schema has 1 parameter ('params') with 0% description coverage, but this parameter is a nested object containing 5 well-documented sub-parameters (active, category, limit, offset, query) with clear descriptions in the schema. Since the description doesn't add any parameter information beyond the schema, and the schema effectively covers all parameters, the baseline is high. However, the description could have added context like default behaviors or usage examples.

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

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

The description 'List service catalog items' clearly states the verb (list) and resource (service catalog items), making the basic purpose understandable. However, it doesn't differentiate from sibling tools like 'list_catalog_categories' or 'get_catalog_item', nor does it specify scope (e.g., all items vs. filtered). This makes it adequate but vague regarding exact function.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'get_catalog_item' for single items or 'list_catalog_categories' for categories, nor does it specify prerequisites or contexts for use. This leaves the agent without explicit usage instructions.

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

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

No annotations are provided, so the description carries full burden. It states a read operation ('list'), implying it's non-destructive, but doesn't disclose any behavioral traits like pagination behavior (though the schema suggests it), rate limits, authentication requirements, or what the return format looks like. For a tool with 6 parameters and no annotations, this is inadequate.

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

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

The description is a single, efficient sentence with no wasted words. It's appropriately sized for a basic listing tool, though this conciseness comes at the cost of detail.

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

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

Given the tool's complexity (6 parameters, no annotations, no output schema), the description is incomplete. It doesn't explain the filtering capabilities implied by parameters, the return structure, or how it integrates with the knowledge base system. For a tool with rich parameters but minimal description, this leaves significant gaps.

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

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

The description mentions 'knowledge base' but doesn't explain its role as a filter or identifier. With 0% schema description coverage (the schema has descriptions, but they're not counted in coverage), the description fails to add any meaningful context about the 6 parameters (e.g., 'active', 'parent_category', 'query'), leaving them undocumented beyond the schema.

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

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

The description 'List categories in a knowledge base' clearly states the verb ('list') and resource ('categories'), but it's vague about scope and functionality. It doesn't specify whether this lists all categories globally, only top-level categories, or includes nested structures, nor does it differentiate from sibling tools like 'list_catalog_categories' or 'list_knowledge_bases'.

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

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

The description provides no guidance on when to use this tool versus alternatives. There are multiple sibling listing tools (e.g., 'list_catalog_categories', 'list_knowledge_bases'), but no indication of when this specific tool is appropriate, what prerequisites might exist, or any exclusions.

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

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

With no annotations provided, the description carries full burden but only states the basic action. It doesn't disclose whether this is a read-only operation, what permissions might be required, whether results are paginated, what format they return, or any rate limits. For a list operation with 8 parameters, this leaves significant behavioral questions unanswered.

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

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

The description is a single, efficient sentence with no wasted words. It's appropriately sized for what it does convey, though it's under-specified rather than 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?

For a tool with 8 parameters, no annotations, and no output schema, the description is severely incomplete. It doesn't explain what 'list' means operationally, what data is returned, how to filter results, or how this tool fits within the broader ServiceNow context provided by sibling 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?

The description provides zero information about parameters, while the schema has 8 parameters with 0% description coverage. The description doesn't mention any filtering capabilities, pagination options, or query parameters, failing to compensate for the complete lack of schema documentation.

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

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

The description 'List change requests from ServiceNow' states the basic action (list) and resource (change requests) but is vague about scope and filtering capabilities. It doesn't distinguish from sibling tools like 'list_incidents' or 'list_changesets' beyond mentioning 'change requests' specifically.

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

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

No guidance is provided about when to use this tool versus alternatives. The description doesn't mention when this tool is appropriate versus using 'get_change_request_details' for single records or how it differs from other list tools like 'list_incidents' or 'list_changesets'.

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

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

No annotations are provided, so the description carries full burden. It mentions 'List' which implies a read operation, but doesn't disclose behavioral traits like whether it's paginated, rate-limited, requires authentication, returns partial/full data, or how results are ordered. For a list operation with 7 parameters, this leaves significant gaps.

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

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

The description is extremely concise at just 4 words, with zero wasted language. It's front-loaded with the core action and resource, though this brevity comes at the cost of completeness.

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

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

Given the tool's complexity (7 parameters, no output schema, no annotations), the description is severely incomplete. It doesn't explain what a changeset is in this context, how results are returned, what filtering options exist, or any behavioral characteristics. The agent would struggle to use this tool effectively.

Complex tools with many parameters or behaviors need more documentation. 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%, meaning none of the 7 parameters are documented in the schema. The description provides no information about any parameters, failing to compensate for the complete lack of schema documentation. This leaves the agent with no guidance on what 'application', 'developer', 'timeframe', etc. mean.

Input schemas describe structure but not intent. Descriptions should explain 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 'List changesets from ServiceNow' states the basic action (list) and resource (changesets), but is vague about scope and lacks differentiation from sibling tools like 'list_change_requests' or 'get_changeset_details'. It doesn't specify whether this lists all changesets, filtered ones, or provides pagination 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 guidance is provided on when to use this tool versus alternatives. With siblings like 'get_changeset_details' (for specific changesets) and 'list_change_requests' (for related entities), the description offers no context on appropriate use cases, prerequisites, or distinctions.

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

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

No annotations are provided, so the description must fully disclose behavior. It only states the action without details on permissions, rate limits, pagination, or output format. 'List incidents' implies a read-only operation, but it doesn't confirm safety or describe what data is returned. This is insufficient for a tool with no annotation support.

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

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

The description is extremely concise with a single sentence, 'List incidents from ServiceNow', which is front-loaded and wastes no words. It efficiently communicates the core purpose without redundancy, earning full marks for brevity and clarity in 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?

Given the complexity (6 sub-parameters, no output schema, no annotations), the description is incomplete. It doesn't explain the tool's behavior, parameters, or output, leaving significant gaps. For a list operation with filtering capabilities, more context is needed to guide effective use, making this 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?

The input schema has 0% description coverage, meaning parameters are undocumented in the schema. The description adds no information about parameters, failing to compensate for this gap. With 1 parameter (a nested object with 6 sub-parameters), the description should at least hint at filtering options or usage, but it does not.

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

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

The description 'List incidents from ServiceNow' states the basic action (list) and resource (incidents) with the source (ServiceNow), which is clear but minimal. It doesn't distinguish this from other list tools like list_change_requests or list_articles, nor does it specify scope (e.g., all incidents, filtered). This is vague but not tautological, placing it at the minimum viable level.

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

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

The description provides no guidance on when to use this tool versus alternatives. With sibling tools like list_change_requests and list_articles, there's no indication of how incidents differ or when to prefer this tool. It also lacks prerequisites or context for usage, such as authentication or permissions, leaving the agent without direction.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states it's a list operation, implying read-only behavior, but doesn't mention pagination (though parameters suggest it), rate limits, authentication needs, or what the output looks like. For a tool with 4 parameters and no output schema, this leaves significant gaps in understanding how it behaves.

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

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

The description is a single, clear sentence with no wasted words. It's front-loaded with the core purpose and efficiently communicates the essential action and resource. Every word earns its place, making it easy to parse quickly.

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

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

Given the tool's complexity (4 parameters, no output schema, no annotations), the description is insufficient. It doesn't explain what 'knowledge bases' are in ServiceNow context, how results are returned, or parameter usage. For a list operation with filtering and pagination parameters, more context is needed to use this tool effectively.

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

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

The description provides zero information about parameters, while the schema description coverage is 0% (parameters have titles but no descriptions in the schema). With 4 parameters (active, limit, offset, query) undocumented in both the description and schema, the agent has no semantic understanding of what these parameters do or how to use them effectively.

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

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

The description clearly states the action ('List') and resource ('knowledge bases from ServiceNow'), making the purpose immediately understandable. It distinguishes from siblings like 'create_knowledge_base' by indicating retrieval rather than creation. However, it doesn't specify scope (e.g., 'all' or 'filtered') which would make it more precise.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to use 'list_knowledge_bases' versus 'get_article' or 'list_articles', nor does it specify prerequisites or typical use cases. 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?

With no annotations, the description lacks behavioral details. It doesn't disclose if this is a read-only operation, its potential side effects, rate limits, or authentication requirements. The description merely states the action without context, leaving the agent to infer behavior.

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

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

The description is a single, direct sentence with no wasted words. It's front-loaded and efficiently communicates the core purpose without unnecessary elaboration.

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

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

Given the tool's complexity (5 parameters, no output schema, no annotations), the description is insufficient. It doesn't explain return values, pagination behavior, or error handling, making it incomplete for effective agent use despite the concise structure.

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

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

The description provides no parameter information, while the schema has 5 parameters with 0% description coverage (only titles like 'Active' without context). This leaves semantics unclear, such as what 'active' or 'client_callable' mean in ServiceNow, failing to compensate for the schema 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 the action ('List') and resource ('script includes from ServiceNow'), which is clear but basic. It doesn't differentiate from siblings like 'get_script_include' (singular retrieval) or 'create_script_include' (creation), leaving the scope ambiguous between listing all vs. filtered subsets.

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

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

No guidance is provided on when to use this tool versus alternatives. For example, it doesn't mention using 'get_script_include' for single-record retrieval or 'create_script_include' for creation, nor does it specify prerequisites like authentication or context.

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

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

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no 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?

Tool has no description.

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

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

Tool has no 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?

With no annotations provided, the description carries full burden but only states the action without behavioral details. It doesn't disclose whether this is a read-only operation, what permissions might be required, if there are rate limits, pagination behavior (implied by limit/offset params but not described), or what the output format looks like. For a list operation with multiple parameters, this is inadequate.

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

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

The description is extremely concise at just 4 words, with no wasted language. It's front-loaded with the core action and resource. While it lacks detail, every word serves a purpose in stating the basic function.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 list operation with 5 parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain what a 'workflow' entails in ServiceNow context, how results are structured, or provide any behavioral context. The agent must rely entirely on the parameter names and default values in the schema without semantic 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?

The description provides zero information about parameters, while the schema has 0% description coverage (the schema's descriptions are in the properties, not the overall schema). With 5 parameters (active, limit, name, offset, query) completely undocumented in the description, and no context about how filtering works (e.g., 'name' uses contains matching), this fails to compensate for the schema 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 'List workflows from ServiceNow' states the basic action (list) and resource (workflows) but lacks specificity about scope or format. It doesn't differentiate from sibling tools like 'list_workflow_versions' or 'get_workflow_details', leaving the agent to infer differences. The purpose is clear but vague about what exactly is being listed.

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

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

No guidance is provided on when to use this tool versus alternatives like 'get_workflow_details' for specific workflows or 'list_workflow_versions' for version listings. The description offers no context about prerequisites, typical use cases, or exclusions, leaving the agent to guess based on tool names alone.

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

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

With no annotations provided, the description carries full burden but only states the basic action without disclosing behavioral traits like pagination, rate limits, permissions required, or response format. It doesn't mention that it's a read-only operation or any constraints, leaving significant gaps for a tool with parameters.

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

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

The description is a single, direct sentence with zero waste, front-loading the core action. It's appropriately sized for such a simple statement, though this conciseness comes at the cost of detail.

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

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

Given no annotations, no output schema, and low schema coverage, the description is incomplete. It doesn't cover parameter meanings, behavioral aspects, or usage context, making it inadequate for a tool with parameters and siblings in a complex server environment.

Complex tools with many parameters or behaviors need more documentation. 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 provides no information about parameters beyond what the schema includes. It doesn't explain the meaning of 'workflow_id', 'limit', or 'offset', or how they affect the listing, failing to compensate for the lack of schema descriptions.

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

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

The description 'List workflow versions from ServiceNow' clearly states the action (list) and resource (workflow versions), but it's vague about scope and doesn't distinguish from siblings like 'list_workflows' or 'get_workflow_details'. It doesn't specify whether this lists all versions or filtered ones, making it minimally adequate but with gaps.

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

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

No guidance is provided on when to use this tool versus alternatives such as 'list_workflows' or 'get_workflow_details'. The description lacks context about prerequisites, filtering, or typical use cases, offering no help in tool selection.

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

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

No annotations are provided, so the description carries full burden. It implies a mutation ('Move'), suggesting potential side effects, but doesn't disclose behavioral traits such as permissions required, whether the move is atomic or reversible, error handling for invalid IDs, or impact on related data (e.g., references to moved items). This leaves significant gaps for a tool that modifies 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?

The description is a single, clear sentence with zero wasted words. It front-loads the core action ('Move catalog items') and specifies the destination efficiently. Every word earns its place, making it easy to parse quickly.

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

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

Given the tool's complexity (a mutation with no annotations, 0% schema description coverage, and no output schema), the description is incomplete. It doesn't explain what 'move' entails (e.g., does it remove from the original category?), potential side effects, error conditions, or return values. For a tool that alters data, more behavioral and contextual information is needed.

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

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

The description mentions 'catalog items' and 'different category', which aligns with the parameters 'item_ids' and 'target_category_id' in the schema. However, schema description coverage is 0%, so the schema provides no parameter descriptions. The description adds some semantic context (e.g., items are moved to a category) but lacks details on ID formats, constraints, or examples. Baseline 3 is appropriate as it partially compensates for the schema 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 clearly states the action ('Move') and resource ('catalog items'), specifying the destination ('to a different category'). It distinguishes from sibling tools like 'update_catalog_item' or 'create_catalog_category' by focusing on relocation rather than modification or creation. However, it doesn't explicitly differentiate from potential similar tools like 'reorder_workflow_activities' in terms of scope.

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

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

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites (e.g., existing items/categories), exclusions (e.g., cannot move to non-existent categories), or comparisons with siblings like 'update_catalog_item' for changing other properties. It only states the basic action without context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure but fails to do so. It doesn't indicate whether this is a read-only or destructive operation, what permissions are required, potential side effects (e.g., making content publicly visible), or error conditions. The description is too vague to inform the agent about the tool's behavior beyond the basic action implied by the name.

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

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

The description is extremely concise with a single sentence, 'Publish a knowledge article', which is front-loaded and wastes no words. While this brevity contributes to clarity in structure, it results in significant informational gaps as noted in other dimensions.

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

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

Given the complexity of a publishing operation (likely a mutation with side effects), no annotations, no output schema, and 0% schema description coverage, the description is severely incomplete. It fails to address critical aspects like what publishing entails, expected outcomes, error handling, or how it differs from related tools, making it inadequate for safe and effective use by an AI agent.

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

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

The schema description coverage is 0%, meaning parameter descriptions in the schema are minimal or generic. The tool description adds no information about parameters beyond what's implied by the tool name. It doesn't explain the 'article_id' requirement, the purpose of 'workflow_state' or 'workflow_version', or how these parameters affect the publishing process. This leaves all parameter semantics 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 'Publish a knowledge article' is a tautology that essentially restates the tool name 'publish_article' with minimal elaboration. While it identifies the verb ('publish') and resource ('knowledge article'), it lacks specificity about what publishing entails (e.g., making it live, changing workflow states) and doesn't distinguish it from potential siblings like 'update_article' or 'create_article'.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing article), exclusions, or relationships with sibling tools like 'create_article' (for creation) or 'update_article' (for modifications before publishing). This leaves the agent with no contextual cues for appropriate tool selection.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure but offers minimal insight. It states the action is 'publish' but doesn't clarify if this is a destructive/mutative operation, what permissions are required, what happens post-publish, or any side effects. This leaves critical behavioral traits undocumented.

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

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

The description is extremely concise—a single sentence with no wasted words. It's front-loaded with the core action and resource, making it easy to parse quickly, though this brevity contributes to gaps in other dimensions.

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

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

Given the complexity of a 'publish' operation in ServiceNow (likely a mutative action with side effects), no annotations, no output schema, and 0% schema coverage, the description is incomplete. It fails to address behavioral risks, parameter meanings, or expected outcomes, leaving the agent under-informed for safe and effective use.

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

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

Schema description coverage is 0%, so the description must compensate but adds no parameter information. It doesn't explain what 'changeset_id' represents, the format of 'publish_notes', or their roles in the publishing process. This leaves both parameters semantically unclear beyond 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 the action ('Publish') and resource ('a changeset in ServiceNow'), which provides a basic understanding of the tool's function. However, it lacks specificity about what 'publish' entails operationally and doesn't differentiate from sibling tools like 'commit_changeset' or 'update_changeset', leaving ambiguity about when to use each.

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

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

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites (e.g., whether the changeset must be committed first), exclusions, or relationships to sibling tools like 'commit_changeset', leaving the agent to infer usage context.

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

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

With no annotations provided, the description carries full burden but offers no behavioral disclosure. It doesn't state whether this is a destructive/mutative action, what permissions are required, how it affects the change request lifecycle, or what the expected outcome is. For a tool that likely alters system state, this lack of transparency is critical.

Agents need to know what a tool does to the 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, straightforward sentence with no wasted words. It's front-loaded with the core action and resource. While under-specified, it achieves maximum conciseness for its limited content.

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

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

Given the tool's likely complexity (state-changing operation in a change management context), no annotations, no output schema, and poor parameter documentation, the description is severely incomplete. It doesn't explain the tool's role in workflows, error conditions, or system impact, making it inadequate for safe and effective use.

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

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

The description mentions no parameters, while the schema has 3 parameters (change_id, rejection_reason, approver_id) with 0% schema description coverage. The schema provides basic titles but no contextual meaning. The description fails to compensate by explaining what these parameters represent or how they're used, leaving semantics largely 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 'Reject a change request' restates the tool name 'reject_change' almost verbatim, making it tautological. It specifies the verb 'reject' and resource 'change request', but lacks any detail about what rejecting entails or how it differs from alternatives like 'approve_change'. This provides minimal value beyond the name 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?

No guidance is provided on when to use this tool versus alternatives. The sibling list includes 'approve_change', but the description doesn't mention it or explain the decision context (e.g., after review, based on criteria). There's no indication of prerequisites, sequencing, or exclusion conditions, leaving the agent with no usage context.

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

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

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no 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?

Tool has no description.

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

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

Tool has no 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?

No annotations are provided, so the description carries full burden. It fails to disclose any behavioral traits: it doesn't mention that this is a mutation operation, potential side effects, permissions required, error conditions, or what happens to existing activity order. This is inadequate for a tool that modifies workflow state.

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

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

The description is a single, efficient sentence with zero wasted words. It's front-loaded and appropriately sized for the tool's apparent complexity, though this conciseness comes at the cost of detail.

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

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

Given no annotations, 0% schema description coverage, no output schema, and a mutation tool with siblings, the description is incomplete. It doesn't address behavioral aspects, parameter meanings, or usage context, making it insufficient for safe and effective tool 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%, but the description adds no parameter information beyond what the tool name implies. The input schema documents two parameters (workflow_id and activity_ids), but the description doesn't explain their semantics, formats, or constraints. Baseline is 3 as the schema provides some structure, but the description doesn't 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 'Reorder activities in a workflow' clearly states the action (reorder) and resource (activities in a workflow), but it's vague about scope and doesn't differentiate from siblings like 'update_workflow_activity' or 'add_workflow_activity'. It lacks specificity about what 'reorder' entails operationally.

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

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

No guidance is provided on when to use this tool versus alternatives. With siblings like 'update_workflow_activity' and 'get_workflow_activities', the description doesn't explain prerequisites, context, or exclusions, leaving the agent to 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?

With no annotations provided, the description carries full burden but only states the action without disclosing behavioral traits. It doesn't mention permissions required, whether resolution is reversible, side effects, or typical response formats, which is inadequate for a mutation tool.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded and appropriately sized for the tool's name, though it lacks detail.

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

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

Given the tool's complexity (a mutation with 3 parameters), no annotations, no output schema, and 0% schema coverage, the description is incomplete. It doesn't provide enough context for safe and effective use, missing critical operational details.

Complex tools with many parameters or behaviors need more documentation. 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%, meaning parameters are undocumented in the schema. The description adds no information about the three required parameters (incident_id, resolution_code, resolution_notes), failing to compensate for the schema 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 'Resolve an incident in ServiceNow' clearly states the action (resolve) and resource (incident), but it's vague about what 'resolve' entails compared to siblings like 'update_incident' or 'create_incident'. It doesn't specify if this is a final closure or status change, making it less distinct.

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

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

No guidance is provided on when to use this tool versus alternatives such as 'update_incident' or other incident-related tools. The description lacks context about prerequisites, timing, or exclusions, leaving the agent without usage direction.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a mutation (submitting for approval) but doesn't specify permissions required, whether it triggers notifications, if it's reversible, or what happens upon submission. This is a significant gap for a tool that likely alters workflow states.

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

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

The description is a single, clear sentence with no wasted words. It's front-loaded and efficiently conveys the core action, making it easy to parse quickly.

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

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

Given the complexity of a submission tool in a workflow context, no annotations, no output schema, and minimal parameter coverage, the description is inadequate. It doesn't explain the approval process, expected outcomes, or error conditions, leaving the agent with insufficient information for reliable use.

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

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

The description doesn't mention parameters, but with only 1 required parameter (change_id) and 0% schema description coverage, it's minimal. Since there's only one essential parameter, the lack of param details in the description is less critical, but it doesn't add value beyond the schema.

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

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

The description 'Submit a change request for approval' clearly states the action (submit) and target (change request for approval), which is adequate. However, it doesn't differentiate from sibling tools like 'approve_change' or 'reject_change', leaving ambiguity about its specific role in the approval workflow.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., if the change request must be in a draft state), exclusions, or how it relates to siblings like 'approve_change' or 'reject_change', leaving the agent to infer usage context.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states this is an update operation (implying mutation), but doesn't describe what happens during update: whether partial updates are allowed (vs. full replacement), what permissions are required, if changes are reversible, or what the response looks like. For a mutation tool with zero annotation coverage, this is a significant gap.

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

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

The description is a single, efficient sentence with no wasted words. It's appropriately sized for a basic tool description and front-loads the essential information (update operation on knowledge articles).

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 1 required parameter (plus 5 optional ones), no annotations, no output schema, and 0% schema description coverage, the description is inadequate. It states what the tool does at a high level but provides no guidance on usage, no parameter information, and minimal behavioral context, leaving significant gaps for an AI agent to use it correctly.

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

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

The description provides zero information about parameters beyond what's implied by 'update an existing knowledge article.' With schema description coverage at 0% (no parameter descriptions in the schema), the description fails to compensate. It doesn't mention the required 'article_id' parameter or any of the optional update fields (title, text, category, etc.), leaving all 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 'Update an existing knowledge article' clearly states the verb ('update') and resource ('knowledge article'), making the purpose immediately understandable. It distinguishes this from sibling tools like 'create_article' (creation) and 'get_article' (retrieval), though it doesn't explicitly differentiate from other update tools like 'update_catalog_item' or 'update_workflow'.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing article ID), when not to use it (e.g., for creating new articles), or how it differs from similar update operations on other resources in the sibling list.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions 'update' which implies mutation, but doesn't specify permissions required, whether changes are reversible, error handling, or rate limits. This is inadequate for a mutation tool with zero annotation coverage.

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

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

The description is a single, clear sentence with no wasted words. It's appropriately sized for a basic tool definition and front-loads the essential action, though this conciseness comes at the cost of completeness.

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

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

For a mutation tool with no annotations, no output schema, and 7 parameters (through 'params'), the description is insufficient. It doesn't explain what 'update' entails, what fields can be modified, or what the response contains, making it inadequate for safe and effective tool invocation.

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

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

The description provides no information about parameters beyond the generic 'update' action. With 0% schema description coverage and 7 parameters (through the 'params' object), the description fails to compensate for the lack of schema documentation, leaving all parameters semantically undefined.

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

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

The description states the verb ('Update') and resource ('an existing service catalog category'), which provides a basic understanding of purpose. However, it doesn't differentiate from sibling tools like 'update_catalog_item' or 'update_category', nor does it specify what aspects can be updated beyond the generic term 'update'.

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

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

No guidance is provided on when to use this tool versus alternatives like 'create_catalog_category' or 'list_catalog_categories'. The description lacks context about prerequisites (e.g., needing an existing category ID) or exclusions, leaving the agent to infer usage from the tool name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states 'update' implies a mutation, but fails to mention required permissions, whether changes are reversible, rate limits, or what the response looks like. This is inadequate for a mutation tool with zero annotation coverage.

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

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

The description is a single, efficient sentence with no wasted words. It's appropriately sized for a basic tool definition, though this conciseness comes at the cost of detail.

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

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

Given the tool's complexity (a mutation with 1 required and 7 optional parameters), no annotations, no output schema, and 0% schema description coverage, the description is severely incomplete. It doesn't explain what a 'service catalog item' is, what fields can be updated, or the behavioral implications, making it inadequate for effective use.

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

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

The schema description coverage is 0%, meaning all parameters are undocumented in the schema. The description adds no information about parameters beyond the tool name, not even hinting at the required 'item_id' or optional fields like 'active' or 'price'. It fails to compensate for the schema's lack of descriptions.

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

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

The description 'Update a service catalog item' clearly states the verb ('update') and resource ('service catalog item'), providing a basic understanding of the tool's function. However, it lacks specificity about what fields can be updated and doesn't differentiate from sibling tools like 'update_catalog_category' or 'update_article', making it somewhat 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?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing catalog item), exclusions, or comparisons to sibling tools like 'create_catalog_category' or 'move_catalog_items', leaving the agent with no usage context.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states this is an update operation, implying mutation, but provides no information about permissions required, whether changes are reversible, what happens to unspecified fields, or any rate limits/constraints. This is inadequate for a mutation tool with zero annotation coverage.

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

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

The description is a single, efficient sentence that gets straight to the point with zero wasted words. It's appropriately sized for what it does convey, though it's under-specified rather than 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?

For a mutation tool with 11 parameters, 0% schema description coverage, no annotations, and no output schema, this description is severely incomplete. It doesn't explain what fields can be updated, what the change_id parameter represents, what happens after updating, or any behavioral constraints.

Complex tools with many parameters or behaviors need more documentation. 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%, meaning none of the 11 parameters have descriptions in the schema. The tool description provides absolutely no information about parameters beyond what's in the name ('update_change_request'), failing to compensate for the complete lack of schema documentation.

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

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

The description clearly states the action ('Update') and resource ('an existing change request in ServiceNow'), making the purpose immediately understandable. However, it doesn't differentiate this tool from other update tools in the sibling list (like update_article, update_incident, etc.), which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. There's no mention of prerequisites (like needing an existing change request ID), when not to use it, or how it differs from related tools like 'create_change_request' or 'update_changeset' in the sibling list.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. While 'Update' implies a mutation operation, the description doesn't specify required permissions, whether changes are reversible, potential side effects, or what happens to unspecified fields. It lacks critical context for a mutation tool with zero annotation coverage.

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

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

The description is a single, efficient sentence with zero wasted words. It's appropriately sized for a basic tool description and front-loads the essential information (action and resource).

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

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

For a mutation tool with 5 parameters, 0% schema description coverage, no annotations, and no output schema, the description is severely incomplete. It covers only the basic purpose without addressing parameter meanings, behavioral traits, usage context, or expected outcomes, leaving significant gaps for agent understanding.

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

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

The description mentions no parameters at all, while the input schema shows 5 parameters (changeset_id, description, developer, name, state) with 0% schema description coverage. The description fails to compensate for this complete lack of parameter documentation in the schema, leaving all parameters semantically undefined.

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

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

The description clearly states the action ('Update') and resource ('an existing changeset in ServiceNow'), providing a specific verb+resource combination. However, it doesn't differentiate this tool from sibling tools like 'update_change_request' or 'update_article', which follow the same pattern for different resources.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing changeset ID), when not to use it, or how it differs from related tools like 'create_changeset' or 'publish_changeset' in the sibling list.

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

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

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no 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?

Tool has no description.

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

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

Tool has no 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states it's an update operation, implying mutation, but doesn't mention required permissions, whether changes are reversible, rate limits, or what the response looks like. This is inadequate for a mutation tool with zero annotation coverage.

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

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

The description is a single, efficient sentence with no wasted words. It's appropriately sized for a basic tool definition, though it could benefit from more detail given the complexity.

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

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

For a mutation tool with 14 parameters, 0% schema description coverage, no annotations, and no output schema, the description is severely incomplete. It doesn't explain what fields can be updated, behavioral traits, or return values, leaving significant gaps for an AI agent.

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

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

Schema description coverage is 0%, meaning none of the 14 parameters have descriptions in the schema. The tool description adds no information about parameters beyond what's implied by the name 'update_incident', failing to compensate for the complete lack of schema documentation.

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

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

The description 'Update an existing incident in ServiceNow' clearly states the verb ('update') and resource ('incident'), but it's vague about what specific aspects can be updated and doesn't differentiate from sibling tools like 'resolve_incident' or 'update_change_request'. It's a basic statement of purpose without specificity.

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

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

No guidance is provided on when to use this tool versus alternatives like 'resolve_incident' or 'create_incident', nor any prerequisites or context for usage. The description merely states what it does without indicating appropriate scenarios or exclusions.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. 'Update' implies a mutation operation, but the description doesn't disclose what permissions are required, whether the update is atomic/reversible, what happens to unspecified fields, error conditions, or rate limits. For a mutation tool with 7 parameters and zero annotation coverage, this is a significant gap in behavioral context.

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

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

The description is maximally concise - a single sentence that states the core purpose without unnecessary words. It's front-loaded with the essential information and contains no redundant phrases. Every word earns its place in this minimal description.

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

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

For a mutation tool with 7 parameters, no annotations, no output schema, and 0% schema description coverage, the description is severely incomplete. It doesn't explain what constitutes a valid script include ID, what fields can be updated, what the update operation returns, or any behavioral constraints. The agent lacks sufficient context to use this tool effectively.

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

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

The description provides zero information about parameters beyond what's implied by the tool name. With 0% schema description coverage and 7 parameters (1 required, 6 optional), the description fails to compensate for the complete lack of parameter documentation in the schema. The agent must rely entirely on parameter names and types without semantic guidance.

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

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

The description clearly states the action ('Update') and resource ('an existing script include in ServiceNow'), providing specific verb+resource combination. However, it doesn't distinguish this tool from its sibling 'update_article', 'update_catalog_category', etc., which all follow the same 'update [resource]' pattern without indicating what makes script includes unique.

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

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

The description provides no guidance on when to use this tool versus alternatives. There's no mention of prerequisites (e.g., needing an existing script include ID), when to use this versus 'create_script_include' or 'delete_script_include', or what constitutes a valid update scenario. The agent must infer usage 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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no 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?

Tool has no description.

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

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

Tool has no 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. While 'Update' implies a mutation operation, the description doesn't mention what permissions are required, whether changes are reversible, what happens to unspecified fields, or what the response looks like. This is a significant gap for a mutation tool with zero annotation coverage.

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

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

The description is a single, efficient sentence that states exactly what the tool does without any wasted words. It's appropriately sized for a basic tool description and gets straight to the point.

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