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

With no annotations, the description carries the full burden. It discloses the action, the conditional 'if open', and the return type (confirmation message). It doesn't detail edge cases like behavior when browser is already closed, but 'if it's open' implies idempotency. This is adequate for a simple close operation.

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

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

The description is extremely concise: three short sentences plus a returns line. The main action is front-loaded, and every sentence adds value. No unnecessary details.

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

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

For a tool with no parameters and an output schema, the description is complete. It covers what it does, when to use it, and what it returns. The low complexity means nothing is missing for an agent to call it correctly.

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

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

There are zero parameters, so the schema trivially covers all. The description doesn't need to explain parameters. Baseline for 0 params is 4; no additional info is required.

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

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

The description clearly states the action: close the persistent browser. It specifies the resource (persistent browser) and condition (if open), which is distinct from sibling tools like browser_keep_open and browser_status. The purpose is unambiguous.

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

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

The description provides explicit context: use when done with authentication operations and only when persistence is enabled. It references browser_keep_open to clarify the condition. It doesn't compare with session_browser_close, but the guidance is clear enough for selection.

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

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

With no annotations provided, the description carries the full burden. It discloses the default (False) and the consequence of each setting ('browser closes automatically' vs 'stays open'). This is clear and adequate for the tool's simple state-change nature.

Agents need to know what a tool does to the 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 well-structured with an Args section and Returns note. Every sentence contributes useful information; it is slightly verbose but not padded. The key information is front-loaded.

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

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

For a single-boolean toggle, the description covers the parameter, usage rationale, default behavior, and return value. It could mention persistence across sessions or side effects, but those are not critical for correct invocation.

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

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

The schema only provides a boolean named 'enabled', but the description explains its meaning precisely: 'True to keep browser open after auth, False to close it'. This adds significant value beyond the schema.

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

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

The description clearly states the action ('Enable or disable browser persistence') and the resource (browser after authentication). It is distinguishable from most siblings, though it does not explicitly differentiate from the similar 'session_browser_keep_open' tool.

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

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

It explains when to enable persistence ('multiple operations that need authentication') and notes the default behavior. It does not explicitly mention when not to use it or alternative tools, but the context is sufficient.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It mentions that it returns a JSON string and lists the two pieces of information it returns, implying a read-only operation. However, it does not explicitly state that it has no side effects, nor does it mention any permissions or prerequisites. For a status-checking tool, this is adequate but not exhaustive.

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

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

The description is concise and well-structured, with a brief overview and bullet points listing the returned information. The 'Returns:' line is slightly redundant with the bullet list, but the overall structure is clear and front-loaded. It does not waste words, though it could be slightly tighter.

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

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

The tool has an output schema (indicated by 'Has output schema: true'), so the description does not need to detail the return format beyond what the schema provides. It covers the essential information about the status. However, it lacks a clear differentiation from the sibling 'session_browser_status', which could lead to incorrect tool selection. For a simple status check, this is mostly complete but not fully contextual.

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

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

The tool has zero parameters, so there is no need for parameter explanations. The baseline for a zero-parameter tool is 4, and the description does not attempt to add irrelevant parameter information, so it meets this baseline.

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

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

The description clearly states the tool's purpose: checking browser persistence status and returning specific information. It uses a specific verb ('Check') and resource ('browser persistence status'). However, it does not distinguish itself from the sibling tool 'session_browser_status', which likely serves a similar or overlapping function. A clear purpose but lacking sibling differentiation.

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

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

No guidance is provided on when to use this tool versus alternatives like 'session_browser_status' or 'session_status'. The description only explains what the tool does, not under what conditions it should be selected. For a tool with multiple closely related siblings, this is a significant gap.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states that the checklist is marked completed and returns the updated checklist, but it does not disclose side effects, reversibility, permission requirements, or what 'completed' implies. For a state-changing mutation, this is a notable 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 concise and well-structured with an Args/Returns format. It avoids unnecessary prose and front-loads the primary action. The only minor issue is that the parameter line is redundant with the schema.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 single-parameter mutation, the description provides the core operation and return type. However, with no annotations, it omits usage context, behavioral side effects, and any alternatives. It is minimally viable but leaves an agent guessing about the operation's implications.

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

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

Schema description coverage is 0%, so the description must compensate. However, it only restates the parameter as 'The checklist ID', adding essentially no meaning beyond the property name and type. It could mention required format, constraints, or how to obtain the ID, but does not.

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

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

The description states a specific action ('Mark a checklist as completed') with a clear resource. It is distinct from siblings like uncomplete_checklist and update_checklist, though it doesn't explicitly name them. The purpose is unambiguous and matches the tool name.

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

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

No guidance is given on when to use this tool versus alternatives such as update_checklist or complete_checklist_task_jwt. It does not indicate prerequisites (e.g., checklist must exist, must be incomplete) or exclusions. The description simply states what it does without any contextual decision support.

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

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

With no annotations, the description carries the full disclosure burden. It discloses that the tool mutates a task to completed, requires JWT authentication, and returns a JSON string with the updated task. It does not cover side effects, permission requirements, reversibility, or error behavior, but the core behavioral expectation is present.

Agents need to know what a tool does to the 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 short and well-structured with Args and Returns sections. It front-loads the action and avoids filler. It earns its place, though a bit more context on usage would not hurt.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 single-parameter mutation tool with no annotations, the description covers the action, authentication method, parameter, and return value. Since an output schema exists, not detailing the return structure is acceptable. Gaps remain around when to use this tool versus sibling tools and how the JWT token is supplied, so it is only minimally complete.

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

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

Schema description coverage is 0%, so the description must compensate. It states 'task_id: Task ID to complete,' which adds only minimal meaning beyond the schema's property name and title. It does not explain how to obtain the task_id, what type of task it refers to, or how it relates to checklist-level IDs, so the compensation is thin.

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

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

The description states a specific verb ('Mark') and resource ('checklist task') with an explicit outcome ('as completed'). It also includes 'using JWT authentication', which helps distinguish it from sibling tools like complete_checklist. The purpose is unambiguous.

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

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

The phrase 'using JWT authentication' implies this variant is for JWT-authenticated operations, providing a weak usage signal. However, it does not explicitly state when to prefer it over complete_checklist or mention any exclusions or alternatives, leaving the selection largely to inference.

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

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

With no annotations, the description carries the full burden. It discloses that JWT auth is used, that a browser window may open for SAML if no token is cached, and that it returns a JSON string. It also explains parameter behaviors like optional name and ISO date format. It doesn't mention other side effects beyond creation, but creation is implied and the key behavioral quirks are covered.

Agents need to know what a tool does to the 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 well-organized: a one-line summary, then an explanation of authentication necessity, then a clear Args list, and a Returns line. It front-loads the purpose and includes necessary details without excessive fluff. It is slightly long but each sentence earns its place.

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

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

Given no annotations and an output schema, the description provides essential context: purpose, auth method, parameter meanings, and return type. It also covers the unexpected behavior of opening a browser for SAML. It lacks explicit error handling or prerequisites beyond auth, but those are not critical for 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?

Since the schema has 0% description coverage, the description compensates thoroughly by explaining each parameter: organization_id, checklist_template_id, name (optional, uses template name if omitted), due_date (ISO format), assignee_id (user ID). This adds meaning beyond the schema's type information and default values.

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

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

The description clearly states the tool creates a checklist from a template using JWT authentication. It uses a specific verb ('Create') and resource ('checklist from template'), and differentiates from other checklist tools by specifying the JWT method. It is unambiguous and distinct from siblings like create_checklist_jwt.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 explicitly states that JWT authentication is REQUIRED for checklist creation because IT Glue's API key auth doesn't support it, making it clear when to use this tool over alternatives. It also explains the browser fallback for SAML if no token is cached, providing context on prerequisites and the need for this specific tool.

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

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

With no annotations, the description carries the full burden and does substantial work: it discloses the JWT authentication mechanism, the browser/SAML side effect when no token is cached, and the JSON return format. It doesn't cover permissions or failure handling in detail, but it makes the main non-obvious behavior visible.

Agents need to know what a tool does to the 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 organized into purpose, auth warning, args, and return sections, making it scannable. The auth rationale is stated twice in slightly different forms, but no sentence is wasted for a tool with 7 parameters and no schema documentation.

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

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

The definition covers everything required to invoke the tool: required and optional parameters, auth prerequisite, browser side effect, and return type. It would be more complete with an explicit pointer to create_checklist_from_template_jwt when a template-only creation is intended, and it doesn't mark name as required in the prose, but the schema covers requiredness.

Complex tools with many parameters or behaviors need more documentation. 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 is the only prose source for parameter meaning. It enumerates all seven parameters and adds useful semantics: due_date format, optional template ID, assignee ID meaning, and restricted flag. Some descriptions are tautological ('name: Checklist name') and organization_id is the only parameter marked required, but the schema already pins required fields.

Input schemas describe structure but not intent. Descriptions should explain 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 opens with a specific verb ('Create') and resource ('new checklist'), and explains the JWT authentication requirement so the agent knows which auth path applies. However, it doesn't distinguish itself from the sibling create_checklist_from_template_jwt, which could also create a checklist with a template ID, so sibling differentiation is incomplete.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 text explicitly says JWT is REQUIRED for checklist creation because IT Glue's API key auth doesn't support it, giving clear when-to-use context. It also warns that a missing cached token will open a browser window for SAML, which sets user expectations. It doesn't name alternatives or say when not to use the template-based sibling, so it's just below a top score.

Agents often have multiple tools that could apply. Explicit usage 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 burden. It discloses the JWT authentication mechanism, the side effect of opening a browser window for SAML if no token is cached, and the JSON string return value. It doesn't elaborate on failure modes or reversibility, but for a create operation this level of transparency is solid.

Agents need to know what a tool does to the 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 well-structured with a clear purpose statement, auth rationale, side-effect disclosure, parameter list, and return type. Every section earns its place; the only minor redundancy is repeating 'JWT authentication,' but the expansion about the API limitation justifies it.

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

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

With seven parameters, no annotations, and an output schema available, the description covers the essential context: required params, formats, auth behavior, browser side effect, and return type. It could mention potential errors or user interaction during SAML, but the output schema and existing detail make it largely complete.

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

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

The input schema has 0% description coverage, but the Args section documents all seven parameters, marks required ones, gives the ISO date format for due_date, and notes the default for completed. This fully compensates for the silent schema and adds actionable detail.

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

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

The description states a specific verb and resource: 'Create a new task on a checklist using JWT authentication.' It also differentiates itself from API-key-based authentication and explains why JWT is required because IT Glue's public API lacks the checklist_tasks POST endpoint, which clearly distinguishes it from other checklist 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?

It gives clear usage context: task creation requires JWT because the alternative API-key path doesn't work. However, it doesn't explicitly name sibling alternatives like update_checklist_task_jwt or delete_checklist_task_jwt, so while the when-to-use is clear, the when-not-to-use is only implied.

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

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

No annotations are provided, so the description carries the full burden. It states the obvious side effect ('Create') and return value, but does not disclose permissions, validation rules, whether IDs must pre-exist, or any failure/partial-write 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 opening one-liner is concise and meaningful, but the long Args block largely duplicates the input schema's property names and titles. Since the schema already provides this structure, the description spends most of its length repeating structured data rather than adding value.

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

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

For a 14-parameter create operation with no annotations, this is incomplete. It omits how to obtain the many reference IDs, does not mention that a new organization/config relation may be required, and provides no guidance on preconditions or expected failures despite having many related sibling tools that could supply that 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?

With 0% schema description coverage, the description at least lists all 14 parameters with human-readable labels and flags the 3 required ones. However, most entries simply re-state the parameter names and do not add real semantics like ID lookup sources, value formats, or constraints.

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

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

The description clearly states a specific action ('Create a new configuration') and resource ('device/asset in IT Glue'), and the word 'new' distinguishes it from update/list/get/search configuration siblings without needing to inspect schemas.

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

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

No guidance is given about when to use this tool versus update_configuration, nor about prerequisites such as looking up configuration_type_id, manufacturer_id, model_id, or operating_system_id from reference-data endpoints. The required-parameter list is not usage guidance.

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

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

No annotations are provided, so the description must disclose behavior such as whether it is a safe operation, if it can be reverted, or if there are side effects. It mentions 'Returns: JSON string with the created contact', which gives some output context, but does not cover potential errors, idempotency, or required permissions. This is a significant gap for a mutation tool.

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

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

The description is well-structured with a clear Args section listing parameters and a Returns section. It is concise but complete for what it covers. No wasted words, and it is reasonably sized for a 10-parameter 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 complexity (10 parameters, 3 required, no annotations, and low schema coverage), the description as it stands is minimal. It lists parameters but omits details on how nested objects should be structured, what the JSON output contains beyond 'created contact', and any prerequisites (e.g., organization must exist). It does not fully equip an agent to call it correctly.

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

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

The description adds a brief description for each parameter (e.g., 'Contact first name (required)'), which adds meaning beyond the schema titles. However, the schema coverage is 0%, so the description must compensate for that, but it does not elaborate deeply on complex parameters like contact_emails whose object structure is unspecified in the schema. It provides basic semantics but not comprehensive 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 'Create a new contact in IT Glue' with a specific verb and resource. It lists the parameters and expected return. While it doesn't explicitly distinguish from sibling tools like update_contact, the name and purpose are clear enough for basic understanding.

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

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

No guidance on when to use this tool versus alternatives. It doesn't mention that this tool is for creating, not updating, or any prerequisites like requiring an organization to exist. The description only lists parameters without context for selection.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure. It clearly indicates a mutating operation ('Create') and states the return type ('JSON string'), but it does not mention authentication requirements, validation behavior, whether the operation can partially fail, or side effects beyond creating a document. This is adequate but not rich.

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

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

The description is well-structured with clear Args and Returns sections, no redundant prose, and every sentence earns its place. It front-loads the core purpose and then packs parameter semantics into a compact, scannable list.

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

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

All five parameters are documented with meanings, requiredness, and defaults, and the return type is stated as a JSON string. The description is sufficient for constructing a valid callache. It loses a point only because it does not mention the relationship to the JWT-based sibling tools or any authentication prerequisites, which would help an agent fully understand the invocation context.

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

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

The input schema has 0% description coverage, so the Args section fully compensates. It explains each parameter's meaning: organization_id is an Organization ID, content is 'Document content as HTML', document_folder_id is an optional placement folder, and public controls visibility with a default. It also marks required parameters, adding meaning beyond the raw schema.

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

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

The description clearly states the action and resource: 'Create a new document in IT Glue.' It uses a specific verb plus resource and is readily distinguishable from get_document, update_document, delete_document, and search_documents. However, it does not differentiate itself from the sibling create_document_jwt, which likely performs a similar creation operation with different authentication.

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

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

The description gives no guidance on when to use this tool versus alternatives such as create_document_jwt or update_document. There are no stated conditions, exclusions, or hints about the intended context (e.g., authenticated session vs. JWT-based flow), leaving the agent to infer selection 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 behavioral burden and does so well. It discloses the session-auth mechanism (cookies + XSRF token), the two-step creation process, the reason the internal web API is needed, and the error condition for an expired/missing session. This goes well beyond a generic 'create' description.

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

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

The description is relatively long but well-structured with a rationale, two-step process, error condition, args list, and return type. Each section earns its place given the tool's complexityasi. It could be tightened slightly, but nothing is 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 create operation with no annotations and no schema-level parameter descriptions, this description is nearly complete: it covers authentication, process, error handling, all parameters, and the return format. It doesn't explain how to obtain organization_id or document_folder_id, but those are discoverable through sibling tools and the output schema exists.

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

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

Schema description coverage is 0%, so the description must compensate. It lists all five parameters with meaningful one-line explanations: content is HTML, public controls visibility, and document_folder_id places the document. It adds useful semantics beyond bare schema names, though organization_id could have been elaborated further.

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

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

The description states a specific verb, resource, and distinguishing mechanism: 'Create a new document with content using session authentication.' It explicitly explains why this tool is needed ('IT Glue's public API doesn't persist document content'), clearly separating it from siblings like create_document and update_document_jwt.

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

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

The description clearly communicates when this tool is required: whenever document content must persist through session authentication. It also explains the prerequisite of a valid cached session and the error behavior if that prerequisite is missing warning. However, it does not explicitly name alternatives or state when not to use this tool versus create_document.

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

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

There are no annotations, so the description carries the behavioral burden. It clearly indicates a mutating creation operation and discloses the return value as a JSON string containing the created asset. It does not mention validation behavior, permission requirements, or what happens when trait values do not match the type schema, but the core behavior is transparent enough for a basic create operation.

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

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

The description is concise and well-structured: a one-line purpose statement, a compact Args block covering all parameters, and a short Returns line. No filler or redundant information is included, and the most important information is front-loaded.

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

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

For a create operation with three required parameters, the description supplies all necessary argument semantics and the return format. The dynamic nature of traits is acknowledged, though the description could be stronger by pointing the agent to sibling tools like get_flexible_asset_type or list_flexible_asset_fields to resolve the trait schema. Overall, an agent has enough information to make a correct call.

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

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

Although schema description coverage is 0%, the Args section explicitly documents all three parameters: organization_id, flexible_asset_type_id, and traits. It adds crucial meaning to the generic 'traits' object by explaining that keys are field names and values must match the flexible asset type's schema. It stops short of describing how to discover the exact field names, but it compensates well 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 uses a specific verb and resource: 'Create a new flexible asset.' This clearly distinguishes it from sibling tools like update_flexible_asset, delete_flexible_asset, list_flexible_assets, and unrelated create_* tools. No ambiguity remains about the operation or target.

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

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

The intended use is implied by 'Create a new flexible asset' and the required arguments, but the description does not explicitly state when to choose this tool over alternatives or mention any exclusions. It provides no guidance about when not to use it or when a different flexible-asset tool is more appropriate.

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

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

With no annotations provided, the description must disclose behavioral traits, but it only states the return format ('JSON string with the created location'). It does not explain the side effects of setting primary=true, whether permissions are required, or what happens on duplicate names. This is a significant gap for a mutation tool.

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

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

The description is well-structured: a one-sentence purpose, an Args list, and a Returns line. Every sentence serves a purpose, and there is no filler. It is longer than average due to the 12 parameters, but each entry is necessary because the schema lacks descriptions.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 12 parameters, no annotations, and an output schema, the description covers parameter meanings and the return type adequately. However, it omits important context such as how to obtain valid region_id/country_id values (e.g., via list_regions/list_countries), what happens when primary is set, and whether address fields have dependencies. This makes the tool usable but not fully self-explanatory.

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

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

Schema description coverage is 0%, so the description carries the burden of parameter documentation. It lists all 12 parameters with brief explanations, adding most value for less obvious fields like 'primary: Whether this is the primary location' and 'region_id: Region/state ID'. However, many explanations are nearly tautological (e.g., 'city: City name'), and no constraints or formats are provided.

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

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

The description starts with 'Create a new location.', which is a clear verb-resource statement that distinguishes this tool from its siblings (list_locations, update_location, delete_location, etc.). However, it gives no further detail about what a location means in this domain beyond the parameter names, so it stops short of being fully explicit.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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_location. It only lists arguments and a return type, leaving the agent to infer from the 'create' verb that this is for adding new locations. No prerequisites, exclusions, or alternative routing are mentioned.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says that a new organization is created and a JSON string is returned; it does not disclose permissions, validation behavior, duplicate-name handling, or effects of omitted optional fields.

Agents need to know what a tool does to the 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 well-structured with the purpose stated first, followed by an Args list and a Returns line. It is scannable and avoids unnecessary prose, though the Args section largely restates the schema.

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

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

All parameters are listed and the return format is specified, with an output schema also present. However, operational context is missing, such as prerequisites for type/status IDs and behavior around optional fields, making the description adequate but not comprehensive.

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

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

The schema has 0% description coverage, and the Args section adds basic human-readable labels for all five parameters while marking name as required. This is helpful, but it does not explain where IDs come from, formats, or constraints beyond what the property names already imply.

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

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

The description states a specific verb and resource: 'Create a new organization in IT Glue.' It is immediately distinguishable from related siblings like update_organization, list_organizations, get_organization, and search_organizations.

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

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

No explicit guidance is given about when to use this tool versus alternatives. It does not mention that existing organizations should be updated via update_organization, nor that organization_type_id and organization_status_id may require lookups via list_organization_types or list_organization_statuses.

Agents often have multiple tools that could apply. Explicit usage 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 behavioral disclosure burden. It does disclose useful traits: return is a JSON string, the password value is not included, and otp_secret must be Base32 and at least 16 chars. However, it doesn't address general side effects beyond creation, authorization requirements, error behavior, or idempotency. Adequate but not rich.

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

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

The description is compact and well-organizzed: a one-sentence purpose, an Args block, and a Returns line. Every line adds value, there is no filler, and the core purpose is front-loaded before parameter details.

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

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

For a tool with 11 parameters and 3 required, the description covers all parameters, required markers, and the return behavior, including the notable detail that the password value is not returned. It lacks explicit usage guidance and side-effect nuances, but the schema and output schema cover some of that burden. Strong overall, with minor gaps around prerequisites and alternatives.

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

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

Schema description coverage is 0 %, so the desccription must compensate. It enumerates all 11 parameters, marks the three required ones, and adds meaningful extra context for otp_secret ('TOTP secret key (Base32 encoded, min 16 chars) for 2FA') and resource_type (e.g., 'Configuration'). Though terse, it gives agents semantics beyond bare schema types.

Input schemas describe structure but not intent. Descriptions should explain 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 opens with 'Create a new password entry in IT Glue' – a specific verb, resource, and system. This clearly distinguishes it from sibling tools like update_password, delete_password, list_passwords, and get_password. There is no ambiguity about what the tool does.

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

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

The phrase 'Create a new password entry' implies use for new records, so an agent can infer when to call it versus update/delete siblings. However, it offers no explicit when-to-use or when-not-to-use guidance, no prerequisites (e.g., needing an existing organization_id or category/folder IDs), and never names alternative tools. Usage is implied rather than stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states that the tool creates a relationship and returns a JSON string, but it does not disclose whether the operation is idempotent, whether duplicate relationships are rejected, whether existing relationships are affected, or any permission/authorization requirements. 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 compact and front-loaded with the core purpose, followed by a clear parameter list and return value. The valid resource types list is useful but adds length; overall, every section earns its place and there is no redundant filler.

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

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

The tool has 5 parameters, no annotations, and an output schema, and the description covers the basic call shape and return type. However, it lacks guidance on relationship semantics, duplicate handling, and error conditions, which an agent would need to invoke it correctly in edge cases. It is adequate for a straightforward call but not complete for a mutation tool with no annotation support.

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

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

Schema description coverage is 0%, so the description must compensate. It does list each parameter with a brief explanation (source_type, source_id, destination_type, destination_id, notes) and enumerates valid resource types, which adds meaning beyond the bare schema. However, it does not explain the relationship semantics (e.g., directionality, whether the relationship is symmetric, or what 'notes' should contain), so it only partially compensates for the missing 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 states a specific verb ('Create') and resource ('a relationship between two resources'), which clearly distinguishes it from sibling tools like update_related_item and delete_related_items. It also enumerates valid resource types, adding useful scope. It loses a point because it doesn't explicitly contrast with the sibling relationship tools, though the verb+resource is clear enough.

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

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

The description implies usage by listing required arguments and valid resource types, but it does not state when to use this tool versus alternatives like update_related_item or delete_related_items. There is no explicit when/when-not guidance, so an agent must infer the appropriate context from the tool name and 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, the description carries the full behavioral burden, but it only states the action and the return value. It does not disclose that deletion is permanent, whether it cascades to associated tasks or templates, any permission requirements, or error 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 short and front-loaded, with the core action stated in one sentence and then minimal, clear Args and Returns sections. Every line earns its place and there is no filler.

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

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

For a simple one-parameter call, the description and existing output schema are mostly sufficient. However, for a destructive bulk operation with no annotations, the missing permanence/cascade caveats are a notable gap that an agent would benefit from before invoking it.

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

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

Schema coverage is 0%, but the description explicitly defines checklist_ids as 'List of checklist IDs to delete,' adding meaning beyond the bare schema type and title. It fully conveys the single parameter's purpose, though details like empty-list validity or existence requirements are not addressed.

Input schemas describe structure but not intent. Descriptions should explain 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 opening sentence 'Delete multiple checklists' names a specific verb and resource, and 'multiple' plus the 'checklist_ids' parameter make the bulk nature clear. This distinguishes it from sibling tools like update_checklist, complete_checklist, or get_checklist.

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

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

No guidance is given on when to use this tool rather than alternatives, no prerequisites are mentioned, and there is no stated exclusion for single or task-level deletions. The description provides no routing information relative to the many sibling checklist tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose that the operation deletes a task, uses JWT authentication, and returns a JSON confirmation string. However, it does not mention potential side effects, irreversibility, permission requirements, or failure 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 well-structured with an Args section and Returns section, and it is reasonably concise. The JWT rationale is useful, though the point that JWT authentication is used appears twice, creating slight 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 single-parameter destructive operation, the description covers the core purpose, the parameter, and the return shape, and an output schema exists. It lacks information about authentication prerequisites, idempotency, or what happens if the task does not exist, but the simplicity of the tool keeps this from being a major gap.

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

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

Schema description coverage is 0%, so the description is the only documentation for the single parameter. It documents task_id as 'Task ID to delete,' which clarifies the parameter's role, but this adds little beyond what the parameter name and schema already imply. It is adequate but not rich.

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

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

The description clearly states a specific operation ('Delete a checklist task') and the resource affected. It also notes the JWT authentication approach, which distinguishes this tool from sibling tools like delete_checklists and makes its unique role easy to identify.

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

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

The description explains why JWT authentication is used rather than the public API, but it gives no explicit guidance about when to choose this tool over alternatives, when not to use it, or what conditions are required before calling it. The intended use is mostly implied by the name and one-line operation.

Agents often have multiple tools that could apply. Explicit usage 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 deletion action but does not disclose whether the operation is destructive/permanent, whether confirmation is required, or what happens to related data. The return value is mentioned ('JSON string with deletion confirmation') but no details about error cases or side effects.

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

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

The description is concise and front-loaded with the action. The Args/Returns structure is clear and efficient, though the Returns line is somewhat redundant with the output schema.

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

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

For a destructive operation with no annotations, the description is incomplete. It doesn't warn about permanence, cascading effects, or required permissions. The output schema exists but the description doesn't explain what 'deletion confirmation' contains or how to interpret failures.

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

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

Schema description coverage is 0%, so the description must compensate. It does mention 'contact_id: The IT Glue contact ID', which adds a bit of context beyond the schema's bare type definition, but it doesn't explain how to obtain the ID or any format constraints. Baseline 3 is appropriate given the minimal compensation.

Input schemas describe structure but not intent. Descriptions should explain 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 a contact') and the resource ('from IT Glue'), which is specific and unambiguous. It doesn't explicitly differentiate from sibling tools like delete_password or delete_document, but the resource is named, so an agent can distinguish it.

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

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

The description provides no guidance on when to use this tool versus alternatives, no prerequisites, and no mention of consequences (e.g., whether deletion is permanent or cascades). It simply states the action, 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states only the fact of deletion and the return format; it does not disclose irreversibility, required permissions, cascading effects, or whether deletion is a hard delete/archive. For a destructive operation, 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 compact and well-structured: a one-sentence purpose, an Args list, and a Returns line. There is no redundant language or filler; every sentence earns its place.

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

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

For a one-parameter destructive operation with no annotations, the description provides the essential input and return type. However, it omits behavioral safeguards such as permissions, irreversibility, and error behavior. The existence of an output schema reduces the need to detail return fields, but the missing safety context keeps it from being fully complete.

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

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

Schema description coverage is 0%, but the description compensates by naming document_id and explaining its role: 'The document ID to delete.' This adds meaning beyond the schema's bare integer type. It could provide more context about where the ID comes from, but for a single parameter it is sufficient.

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

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

The description begins with a direct verb-object statement: 'Delete a document from IT Glue.' It clearly identifies the resource and action, and the destructive verb distinguishes it from get_document, create_document, update_document, and list_documents among the siblings. The Args/Returns structure reinforces the purpose.

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

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

Usage is implied by the verb 'Delete' and the required document_id, but there is no explicit guidance on when to choose this over update_document or get_document, nor any mention of prerequisites or exclusions. The description does not state that this should be used for permanent removal or caution about destructiveness.

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

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

No annotations are provided, so the description carries the full burden. It states the tool deletes an asset but does not disclose whether deletion is permanent, whether it requires special permissions, or what happens to associated relationships. The return value is mentioned ('JSON string with deletion confirmation') but no behavioral detail beyond that.

Agents need to know what a tool does to the 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 compact and front-loaded with the core action. The Args and Returns sections are minimal and useful. It could be slightly more structured, but every sentence earns its place.

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

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

For a destructive tool with no annotations and no output schema details, the description is thin. It lacks information about permanence, side effects, permissions, or error conditions. The single parameter is documented, but the overall context is insufficient for an agent to invoke this safely and correctly.

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

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

Schema description coverage is 0%, but the description explicitly documents the single parameter: 'asset_id: The flexible asset ID.' This adds meaning beyond the raw schema, which only says 'Asset Id' with type integer. However, it doesn't clarify the ID format or how to obtain it, so it's adequate but not rich.

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

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

The description states a clear verb and resource: 'Delete a flexible asset.' This distinguishes it from sibling tools like update_flexible_asset and create_flexible_asset, though it doesn't explicitly name them. The action is unambiguous.

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

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

No guidance on when to use this tool versus alternatives, no prerequisites, and no mention of consequences (e.g., whether deletion is permanent or cascades to related items). The context is minimal and leaves usage entirely to inference.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that deletion returns a JSON confirmation string and does not warn about irreversibility, permission requirements, or potential side effects on related data. For a destructive operation, this level of transparency 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 compact and front-loaded with the primary action, followed by a clear Args/Returns structure. It is not bloated, though the parameter line is essentially a restatement of the schema and could have been used to add richer 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?

For a destructive tool with no annotations, the description lacks essential safety and usage context. It does not mention preconditions, consequences of deletion, or how this tool relates to other location tools. The output schema may explain the return value, but it does not compensate for the missing behavioral and 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?

The schema has 0% description coverage, so the description must compensate for the parameter's meaning. It merely repeats 'The location ID', which adds no value beyond the schema's property title. It does not explain how to obtain a location_id, what format is expected, or any constraints associated with it.

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

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

The description opens with 'Delete a location', a specific verb and resource, making the core operation unambiguous. It does not explicitly differentiate itself from sibling delete tools, but naming the 'location' resource is enough to separate it from tools like delete_password or delete_contact.

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

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

No guidance is given on when to use this tool versus alternatives such as search_locations, get_location, or other delete operations. It also does not mention prerequisites, such as confirming the location exists or checking for related items, 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?

No annotations are present, so the description carries the full burden of behavioral disclosure. It does mention that a JSON string deletion confirmation is returned, but it does not note that deletion is permanent, whether permissions are required, or whether related references are affected. For a destructive tool, this is thin.

Agents need to know what a tool does to the 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 compact and front-loaded with a clear purpose sentence, followed by scannable Args and Returns sections. The Args block is somewhat redundant with the schema, but the structure is efficient and easy to parse.

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

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

For a single-parameter destructive tool this is minimally adequate: the agent knows the action, the required parameter, and that a deletion confirmation is returned, with an output schema also present. It lacks warnings about permanence or operational caveats that would make it fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. The line 'password_id: The IT Glue password ID' adds minimal context beyond the schema's 'Password Id' title but gives no format, source, or validation details. It is sufficient for a simple integer ID, but no more.

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

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

States a specific verb ('Delete') and resource ('password entry') scoped to IT Glue, making it unambiguous among the many delete_* siblings such as delete_contact, delete_document, and delete_location. The purpose is immediately clear.

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

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

The description gives no explicit comparison to alternatives like update_password or create_password, and no when-not-to-use guidance. The only signal is the implied use case: when a password entry needs to be removed.

Agents often have multiple tools that could apply. Explicit usage 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 behavioral burden. It discloses that the operation deletes relationships and returns a JSON confirmation, but it does not mention whether deletion is permanent, whether it cascades, whether missing IDs are ignored, or whether special permissions are required.

Agents need to know what a tool does to the 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 brief and front-loaded with the core purpose, but the Args block largely duplicates what the input schema already exposes. It is not bloated, yet the parameter listing adds limited value beyond the schema itself.

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

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

For a destructive operation with no annotations and no schema descriptions, the description omits important context: valid source types, relationship types, deletion semantics, and failure behavior. The stated return type helps, but the definition is not complete enough for an agent to confidently invoke this tool in varied contexts.

Complex tools with many parameters or behaviors need more documentation. 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 the schema's silence. It only restates the parameter names with shallow labels like 'The type of the source resource' and 'List of related item IDs to delete.' It does not explain valid source_type values, the nature of the relationships, or edge-case behavior.

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

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

The description states a specific verb and resource: 'Delete relationships between resources.' It clearly identifies the action and general object, and the parameter names reinforce what is being deleted. It doesn't explicitly differentiate from siblings like update_related_item, but the delete semantics are clear enough.

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

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

There is no guidance about when to use this tool versus alternatives such as list_related_items, create_related_item, or update_related_item. The intended use is only implied by 'Delete relationships,' and there are no prerequisites, exclusions, or alternative routing instructions.

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

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

With no annotations, the description carries the full burden. It discloses that only the first page of each type is returned and that the result is a JSON string, which is meaningful behavioral detail. It could say more about payload size or authentication, but for a zero-parameter read-only aggregate, this is adequate.

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

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

The description is concise, well-structured, and front-loaded with the main purpose. The usage guidance and return-type note each earn their place 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?

For a tool with no parameters and an output schema, the description covers purpose, use cases, and pagination behavior. It is complete enough for an agent to invoke correctly, though the phrase 'all reference data types' could be more explicit about what types are included.

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

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

There are zero parameters, so the baseline is 4. The description adds no parameter-specific meaning, but none is needed since the input schema is an empty object.

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

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

The description clearly identifies the tool as retrieving all reference data in a single call, with a resource and action. It implicitly distinguishes itself from the many individual list_* sibling tools by emphasizing the aggregate nature, though it does not explicitly name a sibling.

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

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

It states useful scenarios: caching reference data locally or understanding available options. This provides clear context for when to use the tool, though it does not explicitly contrast it with alternatives like list_countries or list_regions.

Agents often have multiple tools that could apply. Explicit usage 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 behavioral transparency burden. It explicitly discloses that the tool returns a 'JSON string with checklist details', which is useful because the agent knows to expect a serialized string. It does not mention error cases or authentication, but for a read-only ID lookup this is a reasonable level of disclosure.

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

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

The description is compact and front-loaded: the core purpose appears in the first sentence, followed by a clean Args/Returns structure. There is no filler or redundant repetition of 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?

For a simple two-parameter retrieval tool with an output schema, the description covers the essential elements: what it does, what arguments it takes, and the return type. It could be more complete by mentioning how checklist_id is obtained or by noting alternatives, but no critical information needed to invoke the tool correctly is missing.

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

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

Schema description coverage is 0%, so the description must compensate, and it does by explicitly listing checklist_id and include_tasks with a short explanation for each. It adds meaning beyond the bare schema by clarifying that include_tasks controls whether checklist tasks are included in the response.

Input schemas describe structure but not intent. Descriptions should explain 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 opens with 'Get a specific checklist by ID', which clearly states the action, resource, and unique identifier scope. This distinguishes it from listing tools like list_checklists or get_organization_checklists, since it targets retrieval by ID.

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

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

The description implies the right use case: call it when you already have a checklist_id and want one specific checklist. It does not explicitly mention alternatives such as list_checklists or get_organization_checklists, nor does it state when not to use this tool, so the guidance is inferred rather than explicit.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It does disclose the return type ('JSON string with template details'), which is useful. However, it does not state whether the operation is read-only, what errors may occur, or any permission requirements, leaving the burden only partially fulfilled.

Agents need to know what a tool does to the 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 short, front-loaded with the purpose, and includes separate Args and Returns sections. Every sentence earns its place with no unnecessary fluff.

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

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

For a simple getter with one parameter, the description provides the core purpose, the required argument, and the return format. However, with no annotations or usage guidance, it lacks context about error behavior, whether the operation is safe/read-only, and how the template ID should be obtained.

Complex tools with many parameters or behaviors need more documentation. 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 the missing parameter documentation. It only restates 'The checklist template ID', which adds no real meaning beyond the parameter name and title. It does not explain where the ID comes from, how it relates to list_checklist_templates, or any constraints.

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

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

The description clearly states the operation is 'Get' and the resource is 'a specific checklist template' identified by ID. It is unambiguous, though it does not explicitly call out sibling tools like list_checklist_templates or get_checklist for differentiation.

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

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

The phrase 'by ID' implies the tool should be used when a specific template_id is already known, but there is no explicit guidance about when to use list_checklist_templates instead or how to obtain a template_id. Usage context is only implicit.

Agents often have multiple tools that could apply. Explicit usage 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 mentions the return type ('JSON string') but does not disclose potential errors, authentication requirements, or any side effects. For a read operation this is a moderate gap, but the lack of any behavioral context beyond the return format limits the score.

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

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

The description is short and front-loaded with the core action. The Args/Returns structure is clear and wastes no words, though the Returns line is somewhat redundant with the output schema.

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

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

For a simple single-parameter getter with an output schema, the description is mostly adequate. It lacks usage guidance and any error/edge-case context, but the operation is straightforward and the output schema covers return structure. A 3 reflects the minimal viable completeness for this simple tool.

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

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

Schema description coverage is 0%, so the description must compensate. It names the parameter (configuration_id) and states it is the IT Glue configuration ID, which adds a small amount of meaning beyond the schema's bare 'Configuration Id' title. However, it does not explain the format, constraints, or how to obtain the ID, so compensation is incomplete.

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

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

The description states a specific verb ('Get') and resource ('configuration by ID'), which clearly identifies the operation. It does not explicitly differentiate from siblings like list_configurations or search_configurations, but the 'by ID' qualifier makes the purpose reasonably 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 list_configurations or search_configurations. The description simply states what it does without any context or exclusions, leaving the agent to infer usage.

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

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

There are no annotations, so the description carries the full burden. It does disclose the return behavior ('Returns: JSON string with all related items'), which is useful for a getter. However, it doesn't mention anything about read-only status, permissions, pagination, or what 'all related items' means in practice, leaving some behavioral ambiguity.

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

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

The description is concise and well-structured: a clear one-sentence purpose, a brief convenience context, then Args and Returns sections. Every sentence earns its place, though the convenience note is slightly redundant with the tool's purpose. The front-loading is good.

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

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

For a simple one-parameter getter with an output schema, this is adequate. It covers the core purpose, parameter, and return type. However, it doesn't differentiate from the generic list_related_items sibling, nor does it state preconditions or potential failure modes, leaving some gaps in an agent's ability to fully determine when and how to invoke it.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning by calling configuration_id 'the configuration ID' and linking configuration to 'device/asset,' which goes beyond the schema's bare integer type. Yet it doesn't explain how to obtain a valid configuration_id or any format expectations, so the compensation is only partial.

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

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

The description clearly states a specific verb and resource: 'Get all items related to a specific configuration (device/asset).' The parenthetical clarifies what a configuration is, and the tool is easily distinguishable from sibling relationship tools like get_contact_relationships and get_flexible_asset_relationships based on the configuration focus.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 says 'This is a convenience method for a common use case,' which provides some usage context, but it never explicitly names alternatives or says when NOT to use this tool. An agent would need to infer that this is the configuration-specific version of list_related_items, but no direct guidance or exclusion is given.

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

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

No annotations are provided, so the description carries the full burden. It only provides the output type ('JSON string with contact details') and the verb 'Get' implies read-only, but it does not explicitly state no side effects, error behavior for missing IDs, or authentication requirements.

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

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

The description is concise and front-loaded, with a clear one-sentence purpose followed by well-labelled Args and Returns sections. No filler or redundant information.

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

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

For a simple one-parameter getter, the description covers purpose, parameter, and return type. However, with no annotations, it lacks explicit handling of not-found cases, read-only confirmation, and guidance on when to use this tool instead of list_contacts or search_contacts.

Complex tools with many parameters or behaviors need more documentation. 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 'The IT Glue contact ID' to explain contact_id. This provides minimal semantic context beyond the schema's title and type, but it does not elaborate on how to obtain the ID or any constraints beyond being an integer.

Input schemas describe structure but not intent. Descriptions should explain 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 and resource: 'Get a specific contact by ID.' It differentiates from sibling tools like list_contacts and search_contacts by specifying retrieval by a single ID, so an agent can tell it apart without opening schemas.

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

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

Usage is implied: 'Get a specific contact by ID' suggests this tool is for when you already have the contact_id. However, it does not explicitly contrast with list_contacts or search_contacts, nor does it state when not to use it.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does state that the tool returns 'a JSON string with all related items,' which is useful, but it does not describe edge cases, empty results, authorization needs, or whether the response is fully unfiltered. For a read-like 'get' tool this is adequate but not rich.

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

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

The description is short, front-loaded with purpose, and includes a structured Args/Returns section. The 'convenience method' sentence adds a mild usage hint without being overly verbose, so nearly every part earns its place.

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

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

For a single-required-parameter tool with an output schema available, the description covers the core purpose and return format well. The main missing context is clearer guidance about when to use this versus sibling relationship tools, but the tool is simple enough that an agent can likely invoke it correctly.

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

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

The description only repeats 'contact_id: The contact ID,' which adds little beyond the schema's property name and integer type. With schema description coverage at 0%, the description should compensate by explaining where the ID comes from, what kind of contact ID is expected, or providing an example, 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 uses a specific verb ('Get') and resource ('all items related to a specific contact'), making the tool's scope immediately clear. It distinguishes itself from sibling tools like get_configuration_relationships and get_flexible_asset_relationships by explicitly targeting contact relationships.

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

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

The phrase 'convenience method for a common use case' implies when this might be used, but the description does not explicitly state when to prefer it over alternatives such as list_related_items or the other relationship tools. There are no clear when-to-use or when-not-to-use conditions, leaving usage to be inferred.

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

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

No annotations are provided, so the description carries the full burden. It states the return is a JSON string with document details including content, but doesn't disclose potential errors, permissions, or whether the document content is fully returned or truncated. For a read operation, this is a moderate 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 compact and front-loaded with the core purpose. The Args/Returns structure is clear and wastes no words. It could be slightly more informative, but it is appropriately sized.

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

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

The tool has one required parameter and an output schema, so the description doesn't need to explain return structure in detail. It covers the basic call pattern. However, it doesn't mention error cases or any prerequisites, which for a simple get-by-ID tool is a minor gap.

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

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

Schema description coverage is 0%, so the description must compensate. It does explain that document_id is the document ID, which adds minimal meaning beyond the schema's type and title. It doesn't clarify the ID format or source, but for a simple integer ID this is adequate.

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

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

The description states a specific verb ('Get') and resource ('a specific document by ID'), which clearly distinguishes it from list_documents and search_documents. It doesn't explicitly name sibling alternatives, but the resource and ID-based retrieval are clear enough.

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

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

The description implies usage: call this when you have a document ID and need a single document's details. It doesn't explicitly state when to use list_documents or search_documents instead, but the ID-based nature is a clear contextual signal.

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

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

No annotations are provided, so the description carries the full burden. It discloses that it returns a JSON string with folder details, but it doesn't mention whether the folder is fetched from a specific organization context, whether it requires authentication, or what happens if the folder_id is invalid. The return format is mentioned, which is some credit, but behavioral traits beyond the basic operation are largely absent.

Agents need to know what a tool does to the 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 short and front-loaded with the main purpose. The Args and Returns sections are structured and easy to parse. No wasted words, though the Returns line is somewhat redundant with the output schema.

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

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

For a simple single-parameter getter with an output schema, the description is mostly adequate. It lacks context about when to use it versus list_document_folders, and doesn't mention any prerequisites or error behavior. Given the tool's simplicity, this is a minor gap, but the missing usage guidance prevents a higher score.

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

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

Schema description coverage is 0%, so the description must compensate. It does name the parameter (folder_id) and its meaning ('The document folder ID'), which adds a bit of semantic value beyond the raw schema. However, it doesn't provide details like where to find the folder_id, format constraints, or how it relates to other resources. Baseline 3 is appropriate because the description adds minimal but non-zero meaning.

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

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

The description states a specific verb ('Get') and resource ('document folder by ID'), which clearly identifies the operation. It doesn't explicitly differentiate from sibling tools like list_document_folders or get_document, but the resource and ID-based retrieval are clear enough to distinguish it from most siblings.

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

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

No guidance on when to use this tool versus alternatives such as list_document_folders or get_organization_documents. The description simply states what it does without any context about when it is the right choice.

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

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

With no annotations, the description carries the burden; it does state that this is a fetch operation returning a JSON string of domain details. It does not disclose not-found/error behavior or access requirements, but for a simple read-by-ID tool the basic behavior is adequately characterized.

Agents need to know what a tool does to the 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 short, front-loaded with the action, and uses a clear Args/Returns structure. The Args line is slightly redundant with the property name, so it is not flawless, but there is no real waste.

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

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

For a one-parameter fetch tool with an output schema, the description is minimally adequate: the resource, ID parameter, and return format are present. It is incomplete because it leaves usage-versus-sibling decisions and error behavior to inference.

Complex tools with many parameters or behaviors need more documentation. 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. The Args line (domain_id: The domain ID) merely restates the property name and adds no practical detail about where the ID comes from, its format, or its relationship to organization/domain resources.

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

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

The description uses a clear verb ('Get'), a specific resource ('domain'), and the retrieval criterion ('by ID'), which distinguishes it from list/search siblings in broad terms. It is not a 5 because it never explicitly contrasts with sibling tools like list_domains or search_domains.

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

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

The phrase 'by ID' implicitly tells an agent to use this when a domain identifier is already known rather than searching or listing. However, it gives no explicit when-not guidance and does not mention any alternative tools.

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

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

Annotations are absent, so the description carries the full burden of behavioral disclosure. It states the return type (JSON string with details) but does not mention that it is a read-only operation, any permission requirements, or what happens if the asset does not exist. The lack of side-effect disclosure and error behavior is a 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 concise and well-structured with a clear summary, args, and returns sections. It front-loads the purpose and avoids redundant text. The Returns sentence adds useful context about the output format, though it may duplicate output schema 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 simple get-by-ID tool, the description covers the basic input and output, but it lacks guidance on when to use this tool versus siblings, potential error scenarios, or prerequisites like authentication. Given the breadth of related flexible asset tools, this omission reduces completeness for an agent.

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

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

Schema description coverage is 0%, so the description must compensate. It only restates 'asset_id: The flexible asset ID,' which adds no new meaning beyond the parameter name and type. It fails to explain how to obtain the ID, any format constraints, or the relationship to other tools. This is insufficient given the zero 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 states the action clearly: 'Get a specific flexible asset by ID.' It specifies a verb (Get), resource (flexible asset), and selection criterion (by ID), which distinguishes it from sibling list and search tools. No ambiguity in purpose.

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

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

The description does not explicitly mention when to use this tool versus alternatives like list_flexible_assets or search_flexible_assets. It only implies that you need an asset ID, but provides no exclusions or alternative routing. The user must infer that this is for known IDs, which is insufficient.

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

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

No annotations are present, so the description carries full responsibility for behavioral disclosure. It only states the tool 'gets all items related' and returns a 'JSON string'. It doesn't mention error behavior for invalid IDs, whether results are limited/paginated, what types of related items are included, or any permissions needed. This is minimal for a read operation 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 brief and to the point, with the core action front-loaded. The Args and Returns sections are minimal but not bloated. It earns points for being concise, though it sacrifices substance for brevity.

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

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

Despite having an output schema, the description doesn't elaborate on the nature of 'related items' or the structure of the returned JSON beyond stating it's a string. It lacks context about how this relates to the generic list_related_items or other relationship getters, and it doesn't cover edge cases or limits. For a tool with zero annotations and no param docs, this is incomplete.

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

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

Schema coverage is 0%, and the description's Args section just repeats the parameter name ('flexible_asset_id: The flexible asset ID') without adding meaning beyond the schema's title and type. The description fails to explain how the ID is used or any format expectations, leaving the agent with no additional semantic value.

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

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

The description clearly states the tool's function: 'Get all items related to a specific flexible asset.' It uses a specific verb and resource, and the name reinforces the flexible asset context. However, it doesn't explicitly differentiate from the sibling 'list_related_items' or other relationship getters (e.g., get_configuration_relationships), though the name makes the distinction obvious.

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

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

The phrase 'convenience method for a common use case' vaguely implies it's a shortcut but provides no explicit guidance on when to use this tool versus list_related_items or the configuration/contact-specific relationship tools. No when-not conditions or alternatives are named.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states that it returns a JSON string and does not cover error handling, permission requirements, rate limits, or any side effects. While 'get' implies a read operation, this is not explicitly stated, and there is no mention of what happens if the type_id does not exist.

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

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

The description is concise and well-structured with an Args and Returns section. It front-loads the primary purpose and includes only essential information without redundancy. The format is clean and easy to parse.

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

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

The description is adequate for a simple getter but lacks contextual detail. It does not explain when to use include_fields, how to handle errors, or what 'field definitions' refers to. Since an output schema exists, return structure is covered, but the absence of usage context and behavioral details makes it only minimally complete for a tool with no annotations.

Complex tools with many parameters or behaviors need more documentation. 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 a brief semantic for each parameter: type_id is 'The flexible asset type ID' and include_fields is 'Whether to include field definitions'. This adds clarity beyond the schema's types and titles, but it does not elaborate on what 'field definitions' entails or provide any constraints or format details. Given the schema coverage is 0%, the description compensates minimally but not fully.

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

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

The description states a clear verb ('Get') and resource ('specific flexible asset type by ID'), which distinguishes it from siblings like list_flexible_asset_types (which retrieves multiple) and get_flexible_asset (which retrieves an asset, not a type). The purpose is unambiguous.

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

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

No guidance is given on when to use this tool versus alternatives such as list_flexible_asset_types or get_flexible_asset. It also does not explain when to set include_fields to true or false, leaving the agent to infer the intended usage from the parameter 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It communicates a read operation and states that the return value is a JSON string with location details, but it does not mention not-found/error behavior or authentication requirements. For a simple getter this is minimally adequate.

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

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

The description is short, front-loaded, and structured with concise Args and Returns sections. Every sentence contributes useful information without filler.

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

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

For a one-parameter read operation with an output schema, this description provides enough information to invoke the tool correctly. It lacks explicit alternative usage and error-case details, but those are not essential for a simple point lookup.

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

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

The schema has one required integer parameter with no description coverage. The tool description's Args section restates 'location_id: The location ID', which adds little beyond the schema title, but the parameter is a self-explanatory opaque ID and does not require extensive additional semantics.

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

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

The description states the verb 'Get', the resource 'location', and the access pattern 'specific ... by ID'. This clearly distinguishes it from collection-oriented siblings like list_locations and search_locations.

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

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

The phrase 'by ID' implies the caller must already know the location ID, but the description does not explicitly name alternatives such as search_locations or list_locations, nor does it state when not to use this tool. Usage guidance is present only by implication.

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

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

No annotations are provided, so the description carries the full burden. It states it returns a JSON string with organization details, but doesn't disclose behavior like whether it returns null/error for missing IDs, whether it requires authentication, or any rate limits. For a read operation, the lack of annotations makes this a notable 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 compact and front-loaded with the core purpose. The Args/Returns structure is clear and wastes no words, though the Returns line is somewhat redundant with the output schema.

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

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

For a simple single-parameter read tool with an output schema, the description is mostly complete. However, with no annotations and no mention of error behavior or authentication, an agent might not know how to handle a missing or invalid ID. The output schema covers return structure, so that gap is acceptable.

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

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

Schema description coverage is 0%, but the description explicitly documents the parameter 'organization_id: The IT Glue organization ID', adding meaning beyond the bare schema property. It doesn't add format details (e.g., integer range), but for a single simple parameter this is adequate.

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

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

The description states a specific verb ('Get') and resource ('a specific organization by ID'), which clearly distinguishes it from list_organizations and search_organizations. It doesn't explicitly name the sibling alternatives, but the resource and ID-based lookup are clear enough.

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

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

The description implies this is for fetching a single organization by ID, which is a clear context. However, it doesn't explicitly state when to use this versus list_organizations or search_organizations, nor does it mention any exclusions or prerequisites.

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

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

With no annotations, the description carries full behavioral burden. It does not state whether the operation is read-only, what side effects occur (beyond the optional save_to_file parameter), or any authentication/permission requirements. It also implies 'Get all' but introduces pagination parameters, creating ambiguity about whether the tool returns a single page or all results. No error handling or response format details beyond the return type are given.

Agents need to know what a tool does to the 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 well-structured as a docstring with Args and Returns sections. It is concise without redundancy, each line adds value. Slightly longer than necessary but efficiently organized, making it easy to scan.

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

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

The description covers parameters and return format, but lacks details on sorting, additional filters, or behavior for empty results. The 'Get all' vs pagination ambiguity is a notable gap. Since an output schema exists, return field details are not needed, but the description could clarify whether the tool returns a single page or all pages. Overall, it is adequate but incomplete for a tool with 7 parameters.

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

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

The description adds substantial meaning to every parameter beyond the schema. It explains each parameter's purpose, defaults, and options (e.g., output_format with three choices, page_size max, save_to_file behavior). Since schema description coverage is 0%, the description fully compensates and even adds usage details like 'starts at 1' and 'max 1000'.

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

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

States a clear verb and resource: 'Get all checklists for a specific organization.' The scope is explicit via 'organization_id'. While it doesn't explicitly name sibling alternatives, the name itself differentiates from list_checklists (all) and get_checklist (single), and the description clarifies the organizational scoping.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 list_checklists or get_checklist. It does not mention any conditions, exclusions, or recommended contexts. The sibling list shows multiple checklist-related tools, but the description fails to differentiate usage, leaving the agent to infer based on names.

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

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

With no annotations, the description carries the full burden. It usefully discloses the return type, output_format behavior, and the save_to_file side effect of writing a temp file. However, it does not clarify the apparent tension between 'get all documents' and paginated page/page_size parameters, nor does it describe error or permission 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 opens with a one-line purpose, then uses a clean Args block and a Returns line. Every sentence adds useful information, and the structure is scannable. Despite being longer than many descriptions, it is efficient because all parameter details matter.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 six parameters and no annotations, the description covers inputs, output format, and unusual file-saving behavior well. It is missing guidance on choosing among sibling tools and edge-case behavior, but what is needed to make a correct call is largely present.

Complex tools with many parameters or behaviors need more documentation. 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 fully compensates by documenting all six parameters: organization_id, folder_id, page starting at 1, page_size max of 1000, allowed output_format values, and save_to_file behavior. This is exactly the semantic enrichment an agent needs beyond the bare 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 a specific verb and resource: 'Get all documents for a specific organization.' This clearly distinguishes it from generic document tools like list_documents or get_document by adding the organization scope. The purpose is immediately understandable.

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

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

There is no explicit guidance about when to use this tool versus alternatives such as list_documents, search_documents, or get_document. The organization-scoped purpose implies usage, but no conditions or exclusions are stated. An agent must infer when this is the right choice over sibling tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It covers output format variants, pagination behavior, page_size limits, and the save_to_file side effect that writes to a temp file and returns its path. This is meaningful behavioral context beyond a simple read operation.

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

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

The Args/Returns structure is clear and front-loaded with the tool's purpose. Every parameter line adds semantic value beyond the schema, with no filler or redundancy.

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

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

The description fully covers the input parameters, output behavior, output format options, and file-saving side effect. For a read-only domain retrieval tool with an output schema available, nothing essential for correct invocation is missing.

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

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

Schema description coverage is 0%, so the description must compensate. It documents every parameter and adds details the schema lacks: page starts at 1, page_size max is 1000, output_format has enumerated values and a default, and save_to_file explains its side effect. This is excellent parameter-level 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 states a specific action and resource: getting all domains for a specific organization. This clearly distinguishes it from global domain tools like list_domains, get_domain, and search_domains among the siblings.

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

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

The phrase 'for a specific organization' implies when this tool should be used, but the description does not explicitly mention alternatives or exclusion conditions. Usage guidance is present but left to inference rather than stated directly.

Agents often have multiple tools that could apply. Explicit usage 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 behavioral burden. It discloses pagination parameters, archived filtering, output_format behaviors, and the save_to_file side effect of writing to a temp file and returning its path. It stops short of covering permissions, rate limits, or error behavior, but it gives enough for a safe read-oriented call.

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

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

The description is front-loaded with a one-line purpose and then uses a clean Args/Returns structure where each parameter has exactly one explanatory line. There is no filler or repetition of schema defaults beyond what adds clarity.

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

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

The tool has 7 parameters)Skip and only 1 required, with no annotations and a 0% schema description coverage. The description covers all parameters, pagination constraints, output format options, the save_to_file path, and the return type. Combined with the existing output schema, this is enough for an agent to invoke the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate, and it does. Every parameter gets meaningful prose: organization_id is the required scope, flexible_asset_type_id is a filter, page starts at 1, page_size max is 1000, output_format lists all valid values, and save_to_file explains the temp-file behavior.

Input schemas describe structure but not intent. Descriptions should explain 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 opens with a specific verb and resource: 'Get all flexible assets for an organization.' This clearly separates it from siblings like get_flexible_asset (single asset) and search_flexible_assets (search behavior), and the organization scope distinguishes it from list_flexible_assets.

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

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

The description implies use when an agent needs organization-scoped flexible assets, and it clearly states the required organization_id. However, it never explicitly tells the agent when to prefer this over list_flexible_assets, search_flexible_assets, or get_flexible_asset, nor does it state when not to use it.

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

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

No annotations exist, so the description carries the full burden. It does add useful behavior: output_format choices (full/compact/summary) and save_to_file saving to a temp file with path return for jq. However, the phrase 'all locations' is ambiguous alongside pagination parameters (page, page_size) — it does not clarify whether a single call returns all results or if the agent must paginate, which is a meaningful behavioral 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 well-structured with a one-line summary followed by Args and Returns sections. It is a bit longer than strictly necessary, but each parameter explanation carries useful information and the format is scannable.

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

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

Although the description covers all parameters, it leaves a critical ambiguity: pagination behavior under 'Get all locations.' It does not state whether the tool auto-paginates or returns a single page, nor how output_format interacts with save_to_file ('full results' vs compact/summary). Without annotations or an output schema visible, this gap could cause an agent to misuse the tool or incorrectly assume a single call returns everything.

Complex tools with many parameters or behaviors need more documentation. 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, and it does thoroughly: organization_id is explained, page, page_size with a max of 1000, output_format with enumerated values and default, and save_to_file with its behavioral effect of saving to a temp file and returning a path. Every parameter receives semantic meaning beyond the bare 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 a specific verb and resource: 'Get all locations for a specific organization.' This clearly distinguishes it from get_location (single location) and implies organization scoping. However, it does not explicitly name sibling tools like list_locations or search_locations, so the differentiation is implicit rather than explicit.

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

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

The description implies usage context by requiring an organization_id and being organization-scoped, which suggests it is the right choice when locations are needed for a known organization. However, it provides no explicit guidance on when to use this tool versus sibling tools like list_locations or search_locations, and no exclusion criteria.

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

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

With no annotations provided, the description carries the full burden. It does disclose that show_password controls whether the actual password value is included and that the result is a JSON string. However, it does not mention security implications, permission requirements, or that this is a read-only operation, which would be useful for a sensitive password resource.

Agents need to know what a tool does to the 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 compact, front-loaded with the core purpose, and uses a clear Args/Returns structure. Every line contributes useful information without unnecessary filler.

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

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

For a simple two-parameter retrieval tool, the description covers the essential behavior, parameters, and return type. It lacks explicit mention of error cases or authorization assumptions, but the presence of an output schema and the simplicity of the tool make this reasonably complete.

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

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

Schema description coverage is 0%, but the description fully compensates by explaining each parameter: password_id is the IT Glue password ID and show_password indicates whether to include the actual password value. This adds meaningful semantic information beyond the bare schema types.

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

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

The description states a specific verb and resource: "Get a specific password by ID." This clearly distinguishes it from siblings like list_passwords, search_passwords, update_password, and delete_password, which all have different 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 phrase "by ID" clearly indicates this tool is for retrieving a single known password rather than listing or searching. It does not explicitly mention when not to use it or name alternatives, but the context is clear enough for an agent to select it appropriately.

Agents often have multiple tools that could apply. Explicit usage 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 burden of explaining side effects. It clearly states the cached JWT token is cleared and that this relates to re-authentication, and it discloses the return type (confirmation message). It could additionally clarify whether the token is also invalidated server-side or whether the current session is immediately logged out, but the core behavior is transparent.

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

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

The description is short, front-loaded with the main action, and contains only useful context. The use-case guidance and return note are each valuable, with no filler or repetition.

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

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

For a zero-parameter utility with an output schema already present, the description provides adequate context: what is cleared, when to use it, and what the response will be. Nothing critical is missing for an agent to invoke this tool correctly.

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

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

The tool has zero parameters, so there is no parameter ambiguity. The description correctly focuses on behavior rather than inputs; a score of 4 reflects the baseline for a no-parameter tool.

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

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

The description states a specific action ('Clear') on a specific resource ('the cached JWT token'), which is immediately understandable. It also gives concrete use cases (re-authenticate with a different account, token issues) that make the tool's purpose distinct from generic session-clearing tools.

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

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

The description explicitly says when to use this tool: when re-authenticating with a different account or when the token is causing issues. It does not mention when not to use it or point to an alternative like session_clear, so it falls just short of full usage guidance.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It explicitly states return information (validity, expiration, user) and the return format, which implies a read-only status operation. It could mention edge cases like absence of a token, but the core behavior is transparent.

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

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

The description is short, front-loaded with the main purpose, and each line adds meaningful detail about the output. No redundant or filler content.

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