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

With no annotations, the description carries the burden. It discloses the file reading behavior and the automatic nature. It does not cover error cases (e.g., missing settings.json), but for a simple connector, it 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 with three short sentences, each adding necessary information: purpose, mechanism, and rationale. No redundancy or fillers.

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 one parameter, no output schema, and a simple action, the description covers the core functionality. It could mention expected outcomes or errors, but remains sufficiently complete for an agent to invoke correctly.

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

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

The single parameter 'project_path' is described in the schema as the absolute path. The description adds value by explaining it is used to locate the .vscode/settings.json for automatic connection, going 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 tool's action: automatically connect to a device using settings from the AScript project directory. It specifies the resource (device) and the mechanism (reading .vscode/settings.json), which distinguishes it from the sibling 'connect_device' that likely requires manual input.

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

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

The description explains when to use the tool: when you have an AScript project created by the VSCode plugin, and it avoids manual IP entry. However, it does not explicitly mention the alternative 'connect_device' or when not to use this tool, though the context implies it.

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

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

No annotations provided. Description states returns boolean but does not mention prerequisites (e.g., connected device), side effects, or whether it captures screen or uses existing data.

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

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

Extremely concise: two simple sentences front-loading the action and purpose. No redundant words.

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

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

Covers basic purpose and return type but lacks context on prerequisites, alternate tools, or detailed behavior. Adequate for the tool's simplicity but not fully complete.

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

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

Schema coverage is 100%. Description adds an example for 'colors' parameter, enhancing understanding beyond the schema. 'diff' parameter is well-described in schema. Overall, moderate added 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?

Description clearly states the tool compares colors at multiple screen positions, returns boolean, and is used for UI state determination. It distinguishes from siblings like 'find_colors' which likely searches for colors.

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?

Only a brief hint ('用于判断界面状态') about usage. No explicit when-to-use or when-not-to-use compared to alternatives like 'find_colors', 'ocr', or 'dump_ui_tree'.

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 bears the full burden of behavioral disclosure. It reveals that the tool establishes a connection and enables further device operations, but it does not disclose non-obvious behaviors such as whether it modifies the device's state, requires specific permissions, or handles errors. The absence of details about side effects or failure modes limits transparency. While not incorrect, it could be more explicit.

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

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

The description is extremely concise: two short sentences in Chinese that convey the purpose and basic usage instructions. The first sentence introduces the tool's function, and the second provides parameter guidance. No unnecessary words or redundant information. This structure efficiently communicates the essential information without burdening the agent.

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 that there is no output schema, the description should ideally explain what the tool returns (e.g., connection ID or success status). It does not mention return values or error handling. However, the description covers the core usage pattern and prerequisites. Sibling tools like 'get_device_status' and 'observe_device' imply that connection is a prerequisite, and the description reinforces that. The missing return value info is a minor gap but does not severely impair usability.

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 provides 100% description coverage for all four parameters, including default values and enums. The description adds marginal value by stating that the port is ignored in ADB mode and clarifying the required format for 'ip' (IP for LAN, serial for ADB). However, this is already implied by the schema's parameter descriptions. Thus, the description does not significantly enhance understanding 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 tool's purpose: connecting Android/iOS devices as a prerequisite for using other device tools like screenshots and UI trees. It distinguishes the tool from siblings by specifying that it is the initial connection step, and it contrasts with tools like 'auto_connect' which might automate the process. The verb 'connect' and resource 'device' are specific and unambiguous.

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

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

The description explicitly says when to use this tool: before using device-specific tools (screenshots, control tree). It provides guidance on parameter usage: for LAN devices pass IP, for ADB pass serial number and set connection_mode='ADB'. However, it does not mention when not to use this tool or provide alternatives; the sibling list includes 'auto_connect' which may be an alternative in some scenarios.

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

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

No annotations are provided, so the description carries the full burden. It fails to disclose behavioral traits such as whether the tool requires a connected device, what happens if the project name already exists, or whether it has side effects on existing data. The description is too brief.

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

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

The description is very concise with one short sentence, front-loading the core purpose. However, it could include more detail without being verbose.

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 simplicity of the tool (one required parameter, no output schema), the description barely meets the minimum viable. It lacks information about return values, failure conditions, or naming constraints beyond the schema.

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

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

The input schema has 100% coverage with a description for the single parameter 'name'. The description adds no additional meaning beyond what the schema already provides, so baseline 3 is appropriate.

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

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

The description clearly states the action ('创建新工程') and the context ('在设备上'), and distinguishes from siblings like upload_file which requires a project to already 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 provides explicit context for when to use this tool: before uploading files. It implies a prerequisite but does not explicitly state alternatives or when not to use it, missing a full 'when-to-use vs alternatives' guideline.

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 that code is uploaded as __init__.py and projects are auto-created. However, it does not mention side effects like overwriting existing files or potential failures.

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

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

The description is extremely concise, consisting of two sentences that first state the main loop (upload→run→logs→screenshot) then detail specifics (upload as __init__.py, auto-create project, return values). No wasted words.

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

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

Given the tool's complexity (multi-step) and the absence of an output schema, the description covers the workflow and return values reasonably. It could be improved by mentioning behavior for existing projects and error handling, but is largely complete for a dev loop tool.

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

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

Schema coverage is 100% so parameters are documented. The description adds context that code is uploaded as an entry file and that projects are auto-created, which adds meaning beyond the schema. It does not elaborate on the project_name parameter's relation to existing projects.

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: uploading code, running it, collecting logs, and taking a screenshot in one step. It distinguishes from sibling tools that only handle individual steps (upload_file, run_project, screen_capture, get_run_log).

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 rapid development loops but does not explicitly state when to use this tool versus alternatives. It mentions auto-creation of missing projects but lacks clear when-to-use or when-not-to-use guidance.

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

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

Discloses that Android requires mode matching, iOS ignores mode, and that certain run_modes yield empty trees. Warns about the 'hid' naming trap. No annotations provided, so description carries full burden and does so thoroughly.

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?

Description is lengthy but well-organized into sections (Android, iOS, selector notes). Each section earns its place. Could be slightly more concise, but the complexity warrants the detail. Structure aids readability.

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?

Comprehensive coverage: explains return attributes, platform behavior, empty tree conditions, and how to use Selector. No output schema, but description conveys enough about return format. Fills all gaps given tool complexity.

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

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

Input schema has 100% coverage with detailed mode descriptions. The description adds value beyond schema by linking modes to device status, naming constants, and explaining platform differences. Some repetition of schema info, but overall adds context.

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

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

Clearly states the tool retrieves the UI control tree (hierarchy) of the current device interface, listing properties like id, text, desc, className, rect, clickable. Distinguished from siblings like scan_devices and screen_capture.

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

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

Provides explicit prerequisites: call get_device_status first. Maps run_mode codes to mode parameter values. Differentiates Android vs iOS handling. Tells when not to use (screen_only mode) and warns about naming pitfalls. Includes Selector 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?

The description discloses all critical behaviors: code execution cannot be interrupted, HTTP 60s timeout only disconnects client but server continues, UI freezes if code hangs, platform-specific modifications (iOS replaces ascript.android), image_path injection, and return value conventions. Since no annotations are provided, the description fully covers the behavioral traits.

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

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

The description is long but well-structured with clear sections (use cases, red lines, caution notes, return conventions, cross-platform). Every sentence adds value, though a bit verbose. It could be slightly more concise but remains effective.

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 (arbitrary code execution, multiple platforms, safety constraints), the description is exhaustive. It covers security warnings, alternative tools for longer tasks, behavior under timeout, image handling, and platform-specific code replacement. No output schema exists, but return values are fully documented.

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

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

Schema coverage is 100% (both code and image_path described), but the description adds significant meaning: code must assign to _result, image_path injects _im_source (and on iOS img is preloaded as ndarray). It also explains the expected return formats (simple string, JSON, image base64) which the schema omits.

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 that the tool execs arbitrary Python code in the device's main process and returns results immediately. It distinguishes itself from siblings like upload_file and run_project by emphasizing fast execution (hundreds of milliseconds) and listing specific use cases such as exploratory debugging and composite decision-making.

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 provides when-to-use scenarios (exploratory debugging, composite decisions, etc.) and when-not-to-use scenarios (long loops >30s, callback registration, long sessions). It also names alternatives: upload+run_project for long tasks and engineering mode for persistent sessions.

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

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

With no annotations, the description must disclose behavioral traits. It only explains parameter format but omits details like whether the operation is read-only, blocking, or requires permissions. No mention of side effects or return 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: one sentence for purpose, then parameter format. No extraneous text. Appropriate for the tool's simplicity.

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 fails to explain the return value or output format. Since there is no output schema, the description should clarify what the tool returns (e.g., coordinates, list). This gap reduces completeness for agent decision-making.

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

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

Schema coverage is 100%, baseline 3. The description adds significant value by explaining the colors format with anchors and offsets, which is more detailed than the schema's example. This helps the agent understand how to construct the parameter.

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

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

The description clearly states the tool finds coordinates on the screen matching color conditions, distinguishing it from siblings like compare_colors and screen_capture. The verb 'find' and specific resource 'colors' make purpose 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 like compare_colors. The description implies usage for multi-point color matching but does not provide explicit context or exclusions.

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

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

No annotations are provided, and the description is minimal. It does not disclose whether the operation is read-only, requires authentication, or any side effects. The agent has no behavioral context beyond the purpose.

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 concise and front-loaded. Every word is relevant.

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 lacks details on return format, limitations, or what constitutes a 'code example'. With two parameters and no output schema, more context is needed for an agent to understand the expected outcome.

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

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

Input schema covers both parameters with descriptions and enum, achieving 100% coverage. The description adds no extra meaning 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 'get runnable code examples for common automation tasks', which is a specific verb and resource. It distinguishes from sibling tools that perform other actions like auto_connect or compare_colors.

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

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

The description implies usage when needing code examples for a task, but does not provide explicit guidance on when not to use it or mention alternatives among siblings.

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

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

No annotations provided, so description carries full burden. It comprehensively describes the output structure and hints at read-only behavior (status retrieval). However, it does not explicitly state there are no side effects or mention any rate limits or authentication needs. Still, it is above average in transparency.

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

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

Description is well-structured with a clear front-loaded purpose and a detailed list of return categories. While somewhat lengthy, each part earns its place by providing meaningful information. Minor room for more concise phrasing.

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 no output schema, the description fully enumerates all returned fields and provides usage context (e.g., relevance of run_mode). This is complete for a status-reading tool and leaves no ambiguity about what the tool provides.

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

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

Input schema has zero parameters with 100% coverage. Baseline for high coverage is 3. The description adds no parameter info because there are none, which is acceptable but does not provide additional semantic value beyond the schema.

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

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

Description clearly states the tool retrieves complete device running status for Android devices. It lists all categories returned, distinguishing it from siblings like connect_device or observe_device which have different purposes.

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

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

Explicitly recommends calling this tool before generating scripts, explaining why: to check run_mode for API selection, permissions for authorization, and runtime to avoid conflicts. This provides clear guidance on when to use the tool.

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

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

No annotations are provided, so the description must fully disclose behavior. It mentions the return includes function signatures, parameter descriptions, and documentation, but does not specify if it is read-only, what the source of the docs is, or any authentication or side effects. 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?

Two sentences, no filler. The purpose and key functionality (fuzzy matching) are front-loaded. Every sentence serves a clear purpose.

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

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

For a relatively simple tool with two parameters and no nested objects, the description covers the main functionality. However, it lacks comparison to the sibling tool 'search_api' and does not explain the output format in detail (though it mentions what is returned). Minor but acceptable 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 100%, so the schema already documents both parameters. The description adds value by providing a concrete example ('screen' → 'ascript.windows.screen') that clarifies how fuzzy matching works for the 'module' parameter, going 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 tool retrieves complete API documentation for a specified module with fuzzy matching, using a specific example ('screen' matches 'ascript.windows.screen'). It distinguishes itself from siblings like search_api by focusing on module-level documentation.

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

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

The description mentions fuzzy matching and gives an example, but does not explicitly state when to use this tool versus alternatives like search_api or when not to use it. No context on prerequisites or exclusions is provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals the output composition (module names, descriptions, class and function listings) and implies a read-only operation. While it does not mention side effects, authentication, or rate limits, its explicit listing of returned data provides sufficient transparency for a non-destructive tool.

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

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

The description is a single, front-loaded sentence with no wasted words. It efficiently conveys the tool's action, resource, and output content. Every part of the sentence is necessary.

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

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

Given the tool's low complexity (1 required parameter, no output schema), the description adequately covers the purpose and expected output. It does not explain term 'API 模块概览' in detail, but the context is clear. No pagination or size constraints are mentioned, but these are not critical for this simple overview tool.

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

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

Schema coverage is 100% (parameter 'platform' has description and enum). The description adds minimal extra meaning beyond the schema, essentially repeating the parameter's allowed values and purpose. Baseline 3 is appropriate as the schema already documents the parameter well.

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 (指定平台的 API 模块概览, API module overview for specified platform) and specifies the platforms (android/ios/windows) and included content (模块名、描述、类和函数列表). This distinguishes it from sibling tools like get_module_apis which may provide more detail on individual modules.

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

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

The description implies usage when needing an API module overview for a specific platform, but does not explicitly state when to avoid it or provide alternatives. Given sibling tools like get_module_apis and search_api, the description could offer more guidance on selection, but it is adequate for a straightforward tool.

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

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

No annotations are provided, so the description carries full burden. It reveals the return contents (API, parameters, examples, version history) and implies a read-only operation. It does not mention error behavior or latency, but for a simple retrieval tool the disclosure 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 two sentences, immediately stating purpose and prerequisite. No superfluous words; efficiently structured for quick comprehension.

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

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

Given no output schema, the description lists what the documentation includes, compensating for missing structure. It also covers the prerequisite. It could mention response format (text, JSON) but is otherwise complete for a simple retrieval tool.

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

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

The input schema already describes the parameter as the plugin ID from list_plugins (100% coverage). The description reinforces this by naming list_plugins, adding context beyond the schema's field description. The only parameter is fully explained.

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 gets detailed documentation of a specified plugin, listing exact content (API, params, examples, version history). It is specific and distinguishes from sibling tools like get_code_example or search_api.

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 tells the user to first use list_plugins to obtain the plugin_id, providing clear prerequisite guidance. It does not mention when not to use or alternatives, but the instruction is sufficient for correct invocation.

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

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

No annotations exist, so the description must disclose behavioral traits. It does not mention what happens if the project name is invalid, whether a device must be connected, or if the operation is read-only. The single sentence only describes the function, not side effects or 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 a single concise sentence with no extraneous words. However, it lacks important behavioral details that would not be overly expansive; it is slightly under-specified for completeness.

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

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

Given the tool's simplicity (one required parameter, no output schema, no annotations), the description should cover basic context like error handling, return format, or prerequisites. It does not, leaving significant gaps for an agent invoking the tool.

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

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

The input schema covers the single parameter 'name' with a description, achieving 100% schema coverage. The description adds no additional meaning beyond referencing '指定的工程' (specified project), which aligns with the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool retrieves the file tree structure of a specified project on a device, using the verb '获取' (get) and explicitly naming the resource (project file tree). It is distinct from siblings like list_projects or deploy_and_run.

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 when to use list_projects for project listing or deploy_and_run for deployment. No prerequisites or contextual hints are 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 provided. Description only states real-time log collection for specified seconds, omitting side effects or read-only nature. Minimal disclosure of 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?

Three concise sentences: function, purpose, usage recommendation. No redundancy, front-loaded with key 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?

Covers when to use and what it does, but omits return format details. Given low complexity and no output schema, 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?

Schema fully describes seconds parameter with default. Description adds 'real-time' context beyond schema but does not significantly enhance semantics. Baseline 3 due to 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?

Description clearly states verb 'get' and resource 'run logs', specifies real-time collection and purpose to view output/errors. Differentiates from sibling tools like get_device_status.

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

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

Explicitly recommends calling after run_project to check script execution, providing clear context for use. Does not mention when not to use, but adequate 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, and the description only says 'get', implying a read operation but without explicitly stating it is safe or idempotent, nor mentioning any return format 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 a single clear sentence, appropriately sized for a simple tool, though it could include a bit more context without being verbose.

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 simplicity of the tool (single parameter, no output schema), the description adequately conveys the core functionality but lacks information about the return format or any dependencies.

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

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

The schema covers all parameter meaning (enum for platform), and the description adds no additional semantic value beyond restating the parameter name.

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

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

The description clearly states the tool retrieves a setup guide for a specified platform, using a specific verb and resource. However, it does not explicitly distinguish it from sibling tools like get_code_example or get_platform_overview, though the scope is 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, nor any prerequisites or context for its use.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It correctly indicates this is a read operation that returns a sorted list. However, it does not mention potential side effects, authentication requirements, or rate limits. Given the simplicity of the tool, this is adequate but not exceptional.

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, consisting of three sentences in Chinese. The first sentence states the primary function, the second lists example plugin capabilities, and the third specifies sorting and content. While efficient, it could be slightly more structured; however, it earns a 4 for being clear and front-loaded.

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

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

Given the tool has no parameters and no output schema, the description provides essential details: it lists all plugins, sorted by downloads, with name, author, and description. However, it does not specify the exact output format (e.g., JSON array) or mention pagination limits. For a simple list tool, this is moderately complete.

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

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

The input schema has 0 parameters with 100% schema description coverage. Since there are no parameters, the description adds value by explaining what the tool does. The baseline score of 3 is appropriate because the schema already fully describes parameter expectations, and the description adds no additional constraints or semantics beyond the schema.

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

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

The description clearly states the tool queries the AScript online plugin repository and returns a list of all available plugins. It specifies the sorting order (by downloads) and included fields (name, author, description). This distinguishes it from siblings like get_plugin_detail, which presumably retrieves details for a single plugin.

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 provide guidance on when to use this tool versus alternatives like get_plugin_detail or get_module_apis. While the purpose of listing all plugins is clear, it lacks any 'when to use' or 'when not to use' statements, leaving the agent to infer usage context from the tool name alone.

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

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

The description does not disclose any behavioral traits beyond the obvious listing action. Without annotations, it carries the full burden, but it fails to mention what the output looks like or any 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 a single, clear sentence with no unnecessary words. It is appropriately sized and front-loaded with the action.

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

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

Given the tool has no parameters and no output schema, the description is sufficient for a simple list operation. It provides enough context for an AI agent to understand its purpose.

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

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

There are no parameters, so the schema covers 100%. The description does not need to add parameter information. Baseline of 4 applies.

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

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

The description clearly states it lists all projects on the device, using a specific verb and resource. It is distinct from sibling tools like create_project or run_project.

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

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

The description provides no explicit guidance on when to use this tool vs. alternatives. It is implied that this is the tool for listing projects, but no when-not or alternative tools 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?

With no annotations, the description fully discloses behavior: it explains the platform-specific implementation (Android via /api/status, iOS via eval_python), lists common libraries, and emphasizes that results depend on version and plugins, providing real-time expectations.

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

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

The description is concise with two paragraphs, front-loading the purpose and recommendation. It could be slightly more structured, but it efficiently conveys necessary information without redundancy.

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

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

Given no output schema and zero parameters, the description fully covers what the tool does and returns. It explains both platforms and the dynamic nature of the library list, making it complete for an agent to understand the tool's function.

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, and schema coverage is 100%. The description does not need to explain parameters, so it meets the baseline expectation.

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: listing installed Python third-party libraries in the AScript App. It specifies the scope (Android + iOS) and emphasizes its utility before writing scripts to check import availability, distinguishing it from generic 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 recommends using this tool before writing scripts, providing clear context on when to use it. It does not mention alternative tools, but the recommendation is strong and contextually 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?

No annotations provided, so description carries full burden. Discloses return formats (PNG, JSON/XML) and performance benefit, but does not mention side effects, permissions, or error conditions. Adequate for a read-only observation tool.

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

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

Two sentences plus a bolded important note, all essential. Front-loaded with purpose and deliverables. 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?

Covers purpose, output format, and important usage guidance. Lacks prerequisites (e.g., device connection) and potential limitation details, but sufficient given tool simplicity and no output schema.

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

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

Input schema has no parameters, achieving 100% coverage. Baseline of 4 applies as no additional parameter information is needed.

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

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

Clearly states it retrieves both screenshot and UI tree, distinguishing from separate calls to screen_capture and dump_ui_tree. Specific verb 'observe' and resource 'device' with explicit deliverables.

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

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

Explicitly recommends using this tool instead of separate calls for speed. Includes important post-processing guidance about preferring selector-based interaction over coordinate clicks, but does not explicitly state when not to use the tool.

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

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

No annotations are provided, so the description carries the burden. It discloses the output (text, coordinates, confidence) but does not specify if the tool is read-only, requires permissions, or handles edge cases like no text found. The behavioral disclosure is adequate but not thorough.

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

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

The description is two concise sentences with no wasted words. It front-loads the core action and output, making it efficient for an agent to parse.

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

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

Despite no output schema, the description mentions the return values (text, coordinates, confidence). For a tool with four parameters that are well-documented in the schema, the description provides sufficient context for the agent to understand the tool's result structure.

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

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

All four parameters have descriptions in the input schema (100% coverage). The description adds minimal value beyond the schema (e.g., default engine, default region), so a baseline score of 3 is appropriate.

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

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

The description clearly states the tool's function: perform OCR on the device screen and return recognized text, coordinates, and confidence. It uses specific verbs ('执行 OCR') and nouns ('设备屏幕', '文字识别'), and distinguishes from sibling tools like screen_capture or dump_ui_tree.

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 for text recognition tasks but does not provide explicit guidance on when to use this tool versus alternatives (e.g., screen_capture or dump_ui_tree). No when-not-to-use or alternative references are 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?

Without annotations, the description should reveal behavioral traits such as side effects, prerequisites (e.g., device connection, project existence), or return values. It only states the basic action, leaving significant ambiguity.

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

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

The description is a single, front-loaded sentence that immediately conveys the tool's purpose with no extraneous information.

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

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

Given the complexity of the task (running a project on a device), the description lacks essential context such as expected state of the project, what 'running' entails (e.g., blocking or async), and how it differs from similar tools. The absence of output schema and annotations compounds this.

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 (parameter 'name' with description '工程名称'), and the tool description adds no further semantic value. Since the schema already explains the parameter, a baseline of 3 is appropriate.

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

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

The description '在设备上运行指定工程' clearly states the action (run) and resource (specified project on device). It is specific but does not explicitly differentiate from sibling tools like 'deploy_and_run' or 'run_project_debug', though the name alone suggests a simple run.

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 (e.g., deploy_and_run, run_project_debug). The agent receives no context about prerequisites or typical scenarios.

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

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

With no annotations provided, the description fully discloses all behavioral details: adb forwarding, device API call, blocking mode, return values (port and config snippet), and the attach workflow. It also explains how breakpoints are hit and how to stop, leaving no ambiguity about the tool's operation.

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

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

The description is well-structured but somewhat verbose, containing detailed step-by-step behavior. It front-loads the core purpose and prerequisites, but could be slightly more concise by omitting redundant operational details. Still, it remains 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?

Given the tool's complexity (debugging setup with multiple steps), the description is highly complete. It covers prerequisites, technical process, return values, usage tips, and stop instructions. No output schema exists, but the description compensates by detailing the return format.

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

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

The only parameter 'name' is fully documented in the input schema (100% coverage), so the description does not need to add extra semantics. It uses the parameter in context but does not elaborate on its format or constraints beyond the schema, which is acceptable but adds no additional 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 purpose: to start an Android project in debug mode for VS Code/Cursor attachment via debugpy. It uniquely identifies the action (debug startup) and resource (Android project), distinguishing it from siblings like run_project (non-debug) and stop_project (stop).

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 provides prerequisites (Android platform, ADB connection), usage context (debugging with IDE), and exclusions (iOS not supported). It also directs the user to call stop_project to stop debugging, offering clear when-to-use and when-not-to-use guidance.

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

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

With no annotations provided, the description carries the full burden. It describes the two scanning processes and states it returns a list, but does not disclose any side effects, safety profile, or return format details. It is decent but could be more explicit about being a read-only operation.

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

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

The description is extremely concise: two sentences, front-loaded with the main purpose, and includes key details (simultaneous scans) without any fluff. Every word adds value.

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

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

For a simple discovery tool with one optional parameter and no output schema, the description adequately covers what the tool does, the two scan methods, and the result. It could benefit from noting the return format (e.g., list of device identifiers), but it is still sufficiently complete.

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

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

Schema coverage is 100% for the single parameter 'port', and its description in the schema already explains it. The tool description does not add additional meaning beyond what the schema provides, so it meets the baseline.

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

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

The description clearly states the tool scans and discovers all AirScript devices via two methods (LAN and ADB), distinguishing it clearly from siblings like connect_device or get_device_status. The verb 'scan' paired with 'devices' is specific and unambiguous.

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

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

The description implies usage for discovering devices before connecting, but it does not explicitly state when to use or when to avoid this tool, nor does it mention alternatives like auto_connect. The guidance is implicit 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 must carry the full burden. It states the tool captures the screen and returns a PNG, but does not disclose any behavioral traits such as whether it is read-only, required permissions, or potential side effects. For a simple capture tool, this is minimal but insufficient for full transparency.

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

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

The description is only two sentences, both front-loaded with the core action and return type. Every word is informative and there is no redundancy. It is well-structured for quick understanding.

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

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

Given no parameters and no output schema, the description is mostly complete for a simple screen capture tool. It covers purpose, output, and use case. However, it could be slightly more detailed (e.g., whether it captures full screen or active window, or any limitations). Overall, it meets minimum viability but leaves minor gaps.

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

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

The input schema has zero parameters, so no parameter information is needed from the description. The description does not add parameter details, but that is acceptable because none exist. According to guidelines, baseline is 4 with 0 params, and the description adds context about the tool's function.

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 (截取屏幕, capture screen), the resource (设备当前屏幕, device current screen), and the output (返回 PNG 图片, returns PNG image). It also mentions the use case (查看设备当前界面状态, view current interface state). This effectively distinguishes it from sibling tools like dump_ui_tree or observe_device.

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 includes the purpose '用于查看设备当前界面状态' (used to view current interface state), which implies when to use it. However, it does not explicitly state when not to use it or provide alternatives among the many sibling tools. Some guidance is present 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?

No annotations are provided, so the description must carry the full burden. It states the search scope (function names, class names, documentation) but does not mention that it is read-only, any limits, or what happens if no results.

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

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

Two short sentences in Chinese, approximately 30 characters, no filler. Front-loaded with action and purpose.

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

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

For a simple tool with no output schema, the description explains purpose and usage but omits what the search returns (e.g., list of API names or full docs). Could provide more context on output format.

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

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

Input schema covers 100% of parameters with descriptions. The tool description adds value by explaining the search scope, which gives meaning to the 'query' parameter by hinting it matches against multiple 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?

Description states '按关键词搜索 API，覆盖函数名、类名和文档说明' (search APIs by keyword covering function names, class names, and documentation), with a clear verb and resource. It also distinguishes from sibling tools by adding '当不确定功能在哪个模块时使用' (use when unsure of the module).

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?

Explicit usage context is given: '当不确定功能在哪个模块时使用' (use when unsure of which module). While it doesn't list alternatives or when not to use, this single condition provides clear 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, and the description only says 'stop the project' without elaborating on side effects, error conditions (e.g., what happens if no project is running), or whether it requires authentication. The behavioral disclosure is minimal.

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 unnecessary words. It is front-loaded with the action and target.

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

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

For a simple stop action with no parameters and no output schema, the description is nearly adequate but lacks details on error states (e.g., no running project) and whether the action is synchronous or asynchronous. Given the sibling tools, more context could help.

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 no parameters, so description is not required to explain them. Since schema description coverage is 100% (no params), the baseline is 4. The description adds no redundant parameter info.

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 stops a running project on the device, using a specific verb and resource. This distinguishes it from siblings like 'run_project' or 'deploy_and_run' which start projects.

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

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

The description implies usage when a project is running and needs to be stopped, but it does not provide explicit guidance on when not to use it or alternatives. No prerequisites or context 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 must disclose behavioral traits. It states the tool tests selectors and returns matching controls, implying a read-only operation. However, it does not explicitly confirm no side effects or destructive actions, which would strengthen transparency.

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

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

The description is four concise sentences, each serving a purpose: stating the primary function, listing filters, explaining the use case, and demonstrating combination. 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?

Given no output schema, the description adequately explains that the tool returns matching controls with complete attributes. It covers the tool's purpose, parameters (via schema), and usage context, making it complete for the AI agent.

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

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

Schema coverage is 100%, providing baseline 3. The description adds value by explaining how parameters can be combined (e.g., text and clickable) and contextualizing their use for selector verification, going beyond schema descriptions.

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

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

The description clearly states the tool tests a selector on a device to verify it matches the correct control, with specific filter parameters. It distinguishes itself from sibling tools like dump_ui_tree by focusing on live selector testing.

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 notes this is for verifying selector statements before writing code, providing a clear use case. While it doesn't mention when not to use it or list alternatives, the context is sufficient for an AI agent to understand appropriate 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?

Without annotations, the description carries the full burden but only states the action. It does not disclose whether the operation is destructive, overwrites files, requires authentication, or has 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 a single, concise sentence that front-loads the key purpose. However, it sacrifices necessary detail 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?

No output schema and missing behavioral details. For an upload tool, information about return values, error handling, and file overwrite behavior is absent.

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

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

Schema coverage is 100% with inline descriptions. The description adds minimal value beyond restating that content is base64 encoded. Baseline 3 is appropriate.

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

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

The description clearly states the action (upload a file) and the target (specified project on device). It is specific and distinct from sibling tools like create_project or deploy_and_run, though sibling differentiation is not explicitly addressed.

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 vs alternatives, no prerequisites (e.g., project must exist), and no exclusions or conditions provided.

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