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 adds valuable context beyond the input schema by explaining that 'Measure sorting is ignored by Qlik Engine' and providing specific guidance on how to achieve top-N results using qSortByExpression. This clarifies important behavioral traits not evident from the schema alone.

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

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

The description is appropriately sized with two sentences that are front-loaded with the main purpose. The second sentence provides crucial implementation details without unnecessary elaboration. Every sentence earns its place, though it could be slightly more structured for clarity.

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

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

Given the complexity of the tool (4 parameters with nested objects, no output schema, and no annotations), the description is somewhat complete but has gaps. It explains key behavioral aspects like the engine's handling of measure sorting, but doesn't cover other potential behaviors such as error conditions, performance implications, or what the created hypercube output entails. This is adequate but with clear room for improvement.

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

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

The schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds some semantic value by explaining the purpose of qSortByExpression for top-N results and clarifying that measure sorting is ignored, but it doesn't provide significant additional meaning beyond what's in the schema descriptions. This meets the baseline of 3 for high schema coverage.

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

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

The description clearly states the tool creates a hypercube for data analysis with custom sorting options, providing a specific verb ('create') and resource ('hypercube'). However, it doesn't explicitly differentiate this tool from its siblings (which are all 'get' operations), though the distinction is implied by the 'create' action versus their 'get' actions.

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

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

The description provides implicit usage guidance by mentioning 'To get top-N records, use qSortByExpression: 1 in dimension sorting,' which suggests when to use certain parameters. However, it doesn't explicitly state when to use this tool versus alternatives (e.g., compared to sibling 'get' tools) or provide clear exclusions, leaving some context 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 describes the return content ('metainfo, tables/fields list, master items, sheets and objects with used fields'), which adds useful context beyond basic retrieval. However, it lacks details on permissions, rate limits, error handling, or whether this is a read-only operation (though 'Get' implies read). The description compensates somewhat but leaves gaps for a tool with no annotations.

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

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

The description is a single, dense sentence that efficiently covers purpose, filters, and return values. It's front-loaded with the core action ('Get compact application info') and avoids redundancy. However, it could be slightly more structured (e.g., separating filtering from returns) for better readability, but it earns its place with no wasted words.

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

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

Given no annotations, no output schema, and 2 parameters with full schema coverage, the description is moderately complete. It explains what the tool does and what it returns, which is essential for understanding. However, for a tool with no output schema, it doesn't detail the structure of returned data (e.g., format of 'metainfo'), and with no annotations, it misses behavioral aspects like safety or constraints. It's adequate but has clear gaps.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (app_id and name) with descriptions. The description adds marginal value by noting 'case-insensitive fuzzy search by app name' and 'preferred if known' for app_id, but doesn't provide additional syntax, format, or examples beyond what the schema offers. Baseline 3 is appropriate as the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain 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: 'Get compact application info' with specific filtering capabilities by 'guid or name (case-insensitive)'. It distinguishes itself from siblings like 'get_apps' (likely listing apps) by focusing on detailed info for a single app, though it doesn't explicitly name alternatives. The verb 'Get' and resource 'application info' are specific.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 mentioning filters 'by guid or name', suggesting this tool is for retrieving details of a specific app rather than listing all apps. However, it doesn't explicitly state when to use this vs. siblings like 'get_apps' (for listing) or 'get_app_object' (for specific objects), nor does it provide exclusions or prerequisites. The guidance is implied but not comprehensive.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions pagination and wildcard search support, which adds some context beyond basic retrieval. However, it lacks details on permissions, rate limits, error handling, or response format (e.g., structure of returned values), leaving significant gaps for a tool with 7 parameters and no output schema.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('Return values of a single field from app') and appends key features ('with pagination and wildcard search'). Every word earns its place, with no redundancy or unnecessary elaboration.

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

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

Given the tool's complexity (7 parameters, no output schema, and no annotations), the description is insufficient. It doesn't explain the return format, error conditions, or behavioral nuances like how wildcards interact with pagination. For a data retrieval tool with multiple search options, more context is needed to ensure proper agent usage.

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

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

Schema description coverage is 100%, so the schema fully documents all 7 parameters with details like defaults and constraints. The description adds minimal value by mentioning 'pagination and wildcard search', which loosely relates to 'limit', 'offset', 'search_string', and 'search_number', but doesn't provide additional semantic context beyond what's in the schema. Baseline 3 is appropriate given high schema coverage.

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

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

The description clearly states the action ('Return values') and resource ('a single field from app'), specifying the scope of retrieval. It distinguishes itself from siblings like 'get_app_details' or 'get_apps' by focusing on field values rather than app metadata or lists. However, it doesn't explicitly contrast with 'get_app_field_statistics', which might handle aggregated data instead of raw values.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 provided on when to use this tool versus alternatives like 'get_app_field_statistics' or 'get_app_object'. The description mentions pagination and wildcard search features, but doesn't clarify scenarios where this tool is preferred over other field-related or app-related tools in the sibling list.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'comprehensive statistics' but doesn't specify what types of statistics (e.g., counts, averages, distributions), whether it's a read-only operation, potential rate limits, or authentication requirements. This leaves significant gaps for a tool that likely involves data analysis.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded with the core action ('Get comprehensive statistics'), making it easy to scan and understand quickly.

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

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

Given the lack of annotations and output schema, the description is incomplete. It doesn't explain what 'comprehensive statistics' entail or the format of the return value, which is critical for a statistical tool. With 2 required parameters and no behavioral context, more detail is needed for effective use.

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

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

The input schema has 100% description coverage, with clear documentation for 'app_id' and 'field_name'. The description adds no additional parameter details beyond implying statistics are for a specific field in an app, which is already inferred from the parameter names. This meets the baseline for high schema coverage.

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

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

The description clearly states the verb ('Get') and resource ('comprehensive statistics for a field'), making the purpose understandable. However, it doesn't distinguish this tool from sibling tools like 'get_app_field' or 'get_app_details', which might retrieve related but different information about fields or apps.

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

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

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'get_app_field' and 'get_app_details', it's unclear if this tool is for statistical summaries, usage metrics, or other field-specific data, leaving the agent to guess based on the name alone.

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

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

No annotations are provided, so the description carries full burden. It mentions the tool calls 'GetObject and GetLayout sequentially via WebSocket', which implies network operations and potential latency, but doesn't disclose critical behavioral traits like error handling, rate limits, authentication needs, or what 'layout' entails. The description is insufficient for a tool with no annotation coverage.

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

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

The description is a single sentence that is front-loaded with the main action ('Get specific object layout') and includes implementation detail. It's efficient with zero waste, though the implementation detail might be unnecessary for clarity. Structure is appropriate for the tool's complexity.

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

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

Given no annotations, no output schema, and a tool that performs retrieval operations (implied by 'Get'), the description is incomplete. It doesn't explain what 'object layout' returns, error conditions, or behavioral constraints. For a tool with 2 parameters and no structured support, more context is needed to be adequately helpful.

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

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

Schema description coverage is 100%, with both parameters ('app_id' and 'object_id') documented in the schema as 'Application GUID' and 'Object ID to retrieve'. The description adds no meaning beyond this, as it doesn't explain parameter relationships or usage context. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description states the tool 'Get specific object layout' which indicates a retrieval action on an object layout resource. However, it's vague about what 'object layout' means (e.g., UI layout, data structure) and doesn't clearly distinguish it from sibling tools like 'get_app_sheet_objects' or 'get_app_field'. The phrase 'by calling GetObject and GetLayout sequentially via WebSocket' adds implementation detail but doesn't clarify the purpose further.

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

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

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention when this tool is appropriate (e.g., for retrieving layout details vs. other object properties) or refer to sibling tools like 'get_app_sheet_objects' for different use cases. It lacks context about prerequisites or exclusions.

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

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

With no annotations provided, the description carries the full burden. It mentions pagination behavior and filtering capabilities, which is helpful. However, it doesn't disclose authentication requirements, rate limits, error conditions, or what 'essential fields' specifically includes, leaving gaps in behavioral understanding.

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

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

The description is a single, well-structured sentence that efficiently conveys the tool's core functionality, key filters, and pagination support. Every element earns its place with no wasted words, making it easy to parse quickly.

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

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

For a list tool with 5 parameters and no output schema, the description adequately covers the basic purpose and filtering. However, without annotations or output schema, it should ideally mention more about return format (e.g., what 'essential fields' includes) and any critical constraints to be 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 100%, so the schema fully documents all 5 parameters. The description adds minimal value beyond the schema by mentioning filters (name, stream, published) and pagination, but doesn't provide additional context like wildcard syntax examples or interaction effects between parameters.

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

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

The description clearly states the tool's purpose: 'Get list of Qlik Sense applications' with specific resources (applications) and essential fields/filters (name, stream, published). It distinguishes from siblings like get_app_details by focusing on listing rather than detailed retrieval, but doesn't explicitly contrast with other list-like siblings.

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

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

The description implies usage for listing applications with filtering and pagination, suggesting when to use it for bulk retrieval vs. detailed sibling tools. However, it lacks explicit guidance on when to choose this over alternatives like get_app_sheets or get_app_variables for specific needs.

Agents often have multiple tools that could apply. Explicit usage 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 'Get load script from app', which implies a read-only operation, but doesn't clarify permissions, rate limits, error conditions, or what the output looks like (e.g., script format, size limits). For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.

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

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

The description is extremely concise at four words, with zero wasted language. It's front-loaded with the core action ('Get load script from app'), making it easy to parse quickly. Every word earns its place by conveying the essential purpose.

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

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

Given the tool's complexity (a read operation with one parameter) and lack of annotations or output schema, the description is incomplete. It doesn't explain what a 'load script' is, how it's returned, or any behavioral traits like error handling. For a tool that likely retrieves code or configuration data, more context is needed to use it effectively.

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

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

The input schema has 100% description coverage, with 'app_id' documented as 'Application ID'. The description adds no additional meaning beyond this, as it doesn't explain what an 'app_id' is or provide context like valid formats. With high schema coverage, the baseline score of 3 is appropriate, as the schema does the heavy lifting.

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

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

The description 'Get load script from app' states a clear verb ('Get') and resource ('load script from app'), but it's vague about what a 'load script' is and doesn't distinguish this tool from its siblings like 'get_app_details' or 'get_app_object'. It provides a basic purpose but lacks specificity about the script's nature or format.

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

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

The description offers no guidance on when to use this tool versus alternatives. With siblings like 'get_app_details' and 'get_app_object', there's no indication of when to retrieve a load script specifically, nor any prerequisites or exclusions mentioned. Usage is implied by the name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves a list but doesn't describe key behaviors: whether it's paginated, rate-limited, requires specific permissions, returns empty lists for invalid inputs, or handles errors. For a read operation with zero annotation coverage, this leaves significant gaps in understanding how the tool behaves.

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

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

The description is a single, efficient sentence that front-loads the core action ('Get list of objects') and specifies key details (source, returned fields). There is no wasted verbiage, repetition, or unnecessary elaboration—every word earns its place.

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

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

Given the tool's complexity (a read operation with 2 required parameters) and lack of annotations and output schema, the description is incomplete. It doesn't cover behavioral aspects (e.g., pagination, error handling), usage context, or return format details. While concise, it fails to provide sufficient context for an agent to use the tool effectively beyond basic parameter passing.

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

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

The schema description coverage is 100%, with both parameters ('app_id' and 'sheet_id') documented as GUIDs for application and sheet. The description adds no additional meaning beyond the schema—it doesn't explain parameter relationships (e.g., sheet must belong to app) or provide examples. With high schema coverage, the baseline is 3, as the description doesn't compensate but also doesn't detract.

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

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

The description clearly states the tool's purpose with a specific verb ('Get list of objects') and resource ('from specific sheet'), and specifies the returned fields ('object ID, type and description'). It distinguishes from some siblings like 'get_app_object' (singular) and 'get_app_sheets' (lists sheets, not objects), but doesn't explicitly differentiate from all potential alternatives like 'get_app_field' or 'get_app_field_statistics'.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing valid app and sheet IDs), compare with siblings like 'get_app_object' (for single objects) or 'get_app_field' (for fields), or specify use cases (e.g., for auditing or data exploration). The context is implied but not articulated.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While 'Get list' implies a read-only operation, it doesn't specify whether this requires authentication, what format the list returns (e.g., paginated, filtered), or any rate limits. The description is minimal and lacks important operational context for a tool with no annotation coverage.

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

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

The description is a single, efficient sentence that communicates the core purpose without unnecessary words. It's appropriately sized for a simple retrieval tool, though it could potentially be more front-loaded with additional context about when to use 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?

For a tool with no annotations and no output schema, the description is insufficiently complete. It doesn't explain what format the returned list takes, whether it includes all sheets or is filtered, or what happens with invalid app_ids. The description should provide more operational context given the lack of structured metadata.

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

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

Schema description coverage is 100% with the single parameter 'app_id' fully documented as 'Application GUID'. The description doesn't add any parameter-specific information beyond what the schema provides, but with complete schema coverage, the baseline score of 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the action ('Get list of sheets') and resource ('from application'), specifying what information is retrieved ('with title and description'). It distinguishes this from general app retrieval tools like 'get_apps' by focusing specifically on sheets, but doesn't explicitly differentiate from the sibling 'get_app_sheet_objects' which might retrieve different sheet-related data.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to prefer this over 'get_app_sheet_objects' or other sheet-related tools, nor does it specify prerequisites or context for usage beyond the basic parameter requirement.

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

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

With no annotations provided, the description carries full burden. It mentions pagination and wildcard search, which are useful behavioral traits, but fails to disclose critical information: whether this is a read-only operation, what authentication is needed, rate limits, error conditions, or the structure of returned data. For a tool with 7 parameters and no output schema, this leaves significant gaps.

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

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

The description is a single, efficient sentence that front-loads the core purpose and mentions key features. Every word earns its place with no redundancy or fluff.

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

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

Given the tool's complexity (7 parameters, no output schema, no annotations), the description is insufficient. It doesn't explain the return format, how variables are 'split by source', what the pagination response looks like, or error handling. For a data retrieval tool with filtering and pagination, more context is needed for effective use.

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

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

Schema description coverage is 100%, so the schema fully documents all 7 parameters. The description adds minimal value beyond the schema—it mentions 'wildcard search' which aligns with search_string/search_number parameters, and 'pagination' which aligns with limit/offset. However, it doesn't provide additional context like typical use cases for created_in_script or interaction between parameters.

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

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

The description clearly states the verb ('Return') and resource ('variables'), and specifies they are 'split by source (script/ui)'. It distinguishes from siblings like get_app_details or get_app_field by focusing on variables rather than other app components. However, it doesn't explicitly differentiate from all possible variable-related tools that might exist.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 through mentioning 'pagination and wildcard search', suggesting this tool is for browsing/filtering variables. However, it provides no explicit guidance on when to use this versus alternatives like get_app_field or get_app_script, nor does it mention prerequisites or exclusions.

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