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

No annotations are present, so the description must carry the transparency burden. It only says 'adds a file', but does not disclose that this modifies the Xcode project file, what happens if the file already exists, or whether the file is copied or referenced. The createGroups default is hidden in the schema, not described.

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 filler or redundancy. It is front-loaded with the verb and object, making it easy to scan.

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

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

Despite having 4 parameters and no output schema, the description provides minimal context. It omits important details such as return behavior, side effects on the project file, and how optional parameters affect the outcome. With no annotations or output schema, the description leaves significant gaps.

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

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

Schema coverage is 100%, so the schema already documents all parameters with descriptions. The tool description adds no extra parameter semantics beyond the schema, which is the baseline expectation. A 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 verb 'adds' and the object 'a file to the active Xcode project', which distinguishes it from sibling tools like add_project_to_workspace. It lacks explicit differentiation from all siblings, but the core purpose is unambiguous.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention prerequisites (e.g., active Xcode project), when to prefer add_file_to_project over write_file or create_directory, or any exclusions. The context is implied but not 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the mutation ('adds') but does not disclose prerequisites (e.g., workspace must exist), side effects (e.g., modifies workspace file), or what happens if the project is already added. No output schema exists to clarify the result.

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 of eight words, with no fluff or redundancy. It is front-loaded and directly states the core 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?

This is a mutation tool with no annotations and no output schema, yet the description provides only the basic action. It lacks details about return values, failure modes, or behavioral nuances, making it incomplete for an agent to fully understand the tool's behavior.

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 provides 100% coverage with clear descriptions for both projectPath and workspacePath, so the baseline is 3. The description adds no additional parameter semantics beyond echoing the 'active workspace' concept already in 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 uses a specific verb ('Adds') and resource ('existing project') with target ('active workspace'), clearly differentiating from sibling tools like add_file_to_project and create_workspace.

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

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

No guidance is provided about when to use this tool versus alternatives such as create_workspace or add_file_to_project. The description merely states the action without 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?

With no annotations, the description carries the burden of behavioral disclosure. It discloses the prerequisite (existing Package.swift) and directs to init_swift_package otherwise, but it does not mention side effects such as modifying Package.swift or running 'package update' by default. This is useful context but incomplete for a mutation tool.

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

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

Two tightly packed sentences: the first states the core action, the second provides a critical prerequisite and alternative. No wasted words, and the most important info is front-loaded.

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

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

The tool is relatively simple with 4 well-documented parameters and no output schema. The description covers the primary prerequisite and alternative, which is sufficient for most use cases. It could be improved by noting the default behavior around package update, but the schema's skipUpdate parameter hints at that.

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% for all 4 parameters, and the schema provides detailed descriptions (e.g., version requirement syntax). The description adds no parameter-level information, but per the baseline for high coverage, a 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 uses a specific verb 'Adds' and identifies the resource ('Swift Package dependency') and scope ('active project'), clearly distinguishing it from sibling tools like init_swift_package and remove_swift_package.

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 guidance on when to use the tool (must have Package.swift) and names the alternative tool (init_swift_package) if the prerequisite isn't met, offering clear exclusions and next steps.

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 does not disclose whether the analysis is read-only, what side effects it might have (e.g., creating derived data), or what the output looks like. 'Analyzes' implies non-mutation but lacks explicit confirmation.

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, clearly worded sentence that states the tool's purpose without unnecessary filler. It is front-loaded and easy to parse.

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

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

The tool has no output schema and no annotations, leaving the description to cover return values, required environment, and side effects. It only says it analyzes a file, but does not explain how results are returned or what prerequisites exist (e.g., needing an Xcode project). This is a significant 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% with each parameter (sdk, scheme, filePath) having a descriptive text, so the baseline is 3. The description itself adds no parameter-specific information, but the schema already documents them adequately.

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

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

The description uses a specific verb 'analyzes' with a specific resource 'source file' and names the tool 'Xcode's static analyzer', making its function clear and distinct from sibling tools like build_project, run_tests, or read_file.

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

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

The description gives no guidance on when to use this tool instead of alternatives like build_project or run_tests, nor does it mention exclusions. The only implied usage is for checking files, but no explicit context or alternative comparisons are 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?

With no annotations, the description carries full burden but provides only the basic action. It does not disclose side effects (e.g., creating an .xcarchive file), prerequisites (e.g., active project, valid scheme), or potential failures. The description adds no behavioral context beyond the verb itself.

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?

Single sentence, front-loaded with the verb and resource, no fluff. However, it is so brief that it sacrifices completeness for conciseness.

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

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

For a 5-parameter tool with no annotations and no output schema, the description is insufficient. It omits key context like output format, required project state, and relation to export operations. The schema covers parameters but not tool behavior or workflow.

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 descriptions cover 100% of parameters with clear definitions. The description does not add extra parameter-level semantics, so the baseline of 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?

Description clearly states the action ('Archives'), the resource ('active Xcode project'), and the purpose ('for distribution'). This distinguishes it from sibling tools like build_project or export_archive.

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 on when to use this tool versus alternatives. The phrase 'for distribution' provides some context but does not indicate when not to use it or when to prefer a different tool (e.g., export_archive).

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 fails to mention what happens if the simulator is already booted, whether the command waits for boot completion, or any side effects. The only extra behavioral detail ('will use the most recent iOS version if multiple match') is in the schema, not the description.

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

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

The description is a single concise sentence with no filler. It front-loads the action and resource immediately, and every word contributes meaning.

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

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

For a simple boot operation with three well-documented parameters and no output schema, the description is minimally adequate. It lacks guidance on expected output, error conditions, or preconditions, but given the tool's simplicity this is a moderate gap rather than a severe one.

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 the schema already documents all three parameters with descriptions. The description adds minimal semantic value by naming the two identification modes (UDID or name), but this is already reflected in the parameter descriptions. 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 uses a specific verb ('Boot') with a clear resource ('iOS simulator') and identifies the two targeting methods (UDID or name). This clearly distinguishes it from sibling tools like list_simulators or shutdown_simulator.

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

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

The description implies the primary use case: booting a simulator by UDID or name. It does not explicitly state when not to use it or mention alternatives (e.g., list first), but the context is clear enough for most agents.

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

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

No annotations are provided, so the description carries the full burden. It discloses the primary behavior (building the project) but does not mention prerequisites like having an active project, potential failure modes, or what the tool returns. This is minimal but not misleading; a 2 would be too harsh for a straightforward build 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 a single sentence that is front-loaded with the verb and resource, and contains zero unnecessary words. Every phrase ('active Xcode project', 'specified configuration and scheme') adds value and directly maps to the tool's purpose.

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

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

Given the rich input schema and the simplicity of a build operation, the description is largely complete. It clearly indicates what is built and the essential parameters. However, it does not define what an 'active Xcode project' is, which might require knowledge from sibling tools like get_active_project, but this is a minor gap.

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

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

The input schema has 100% coverage, with every parameter fully described. The description itself adds no parameter-specific meaning beyond what the schema already provides (e.g., that scheme and configuration are required). Baseline of 3 is appropriate since the schema does all 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 action ('Builds'), the resource ('active Xcode project'), and the key inputs ('configuration and scheme'). This distinguishes it from sibling tools like build_swift_package, run_tests, or archive_project, making its specific purpose immediately clear.

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

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

The description provides clear context for when to use this tool: building an Xcode project. However, it does not explicitly mention when not to use it or call out alternatives (e.g., build_swift_package for Swift packages or archive_project for releasing). The absence of exclusions keeps it at a 4 rather than a 5.

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

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

There are no annotations, so the description must fully disclose behavioral traits. It only states the build mechanism ('swift build') but omits side effects like generating .build artifacts, whether it cleans before building, required permissions, or output format. This is a significant gap for a build 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 a single, focused sentence that conveys the essential purpose and method without any wasted words. It is front-loaded and easy to parse.

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

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

The tool has moderate complexity with four optional parameters and no output schema or annotations. The description covers the basic purpose but lacks details about build outputs, prerequisites, or how it relates to similar sibling tools like `build_swift_package`, making it only minimally complete for an agent to use confidently.

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

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

Schema description coverage is 100%, with all four parameters already documented in the input schema. The description adds no additional meaning to the parameters, so the 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 builds a Swift Package Manager package using `swift build` rather than Xcode, providing a specific verb, resource, and method. However, it does not distinguish itself from the sibling tool `build_swift_package`, which may serve a similar or identical role, so it falls short of full differentiation.

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

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

The phrase 'instead of Xcode' implies when to use this tool versus an Xcode-based build, offering clear context. However, it does not explicitly name alternative tools or provide exclusions, such as when to prefer `build_swift_package` or `build_project`.

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

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

No annotations are present, and the description only says 'Builds a Swift Package' without disclosing side effects (e.g., creating build artifacts), required permissions, or potential failures. This is minimal behavioral disclosure, leaving the agent unaware of what happens beyond the action itself.

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 fluff. It efficiently states the action and target, earning its place without redundancy.

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

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

With 7 parameters, no output schema, and several similar sibling tools, the description is too brief to provide adequate context. It omits information about relationships to sibling tools, expected outputs, or usage nuances, leaving the agent underinformed in ambiguous scenarios.

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 7 parameters have descriptive text in the schema, covering 100% of parameter semantics. The description itself adds no extra meaning beyond the schema, so the 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 it builds a Swift Package using Swift Package Manager, identifying the tool's primary function with a specific verb and resource. However, it does not distinguish itself from sibling tool 'build_spm_package', so it lacks sibling differentiation.

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

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

No guidance is provided on when to use this tool versus alternatives such as 'build_project' or 'build_spm_package'. The description gives no context on suitable scenarios, 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, the description must disclose behavioral traits. It states the primary effect but omits side effects such as validation behavior, persistence across calls, interaction with the directory stack, or failure modes. This is a state-changing operation, so more transparency is expected.

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 zero wasted words. It clearly communicates the core action and effect, achieving maximum brevity without losing meaning.

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

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

The tool is simple (one parameter, no output schema), and the description covers the primary function. However, given the sibling tools for directory navigation, it omits context about how this relates to push_directory/pop_directory and whether the change is persistent or scoped. This leaves a minimal but acceptable level of completeness.

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 covers 100% of the parameter, providing detailed guidance on accepted path forms (absolute, relative, ~). The description itself adds no parameter information, but the schema carries the burden. Baseline 3 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 uses a specific verb ('Changes') and resource ('active directory') with a clear scope ('for relative path operations'). This distinguishes it from siblings like get_current_directory (read) and push_directory/pop_directory (stack-based navigation), making its 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?

The description implies usage for setting the base directory for subsequent relative path operations, but it does not explicitly state when to prefer this over push_directory/pop_directory or provide exclusions. No alternative tools are mentioned, leaving the agent to infer the context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state whether the check is read-only, whether the includeOutdated parameter triggers network operations or additional processing, or what exactly 'setup information' contains. This leaves important behavior undisclosed.

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 front-loads the verb and resource. There is no redundancy or unnecessary detail, making it highly concise and efficient.

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

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

For a simple check with one optional parameter and no output schema, the description is adequate but leaves gaps. It does not explain what 'setup information' includes or how includeOutdated modifies the output, and it lacks an explicit read-only guarantee. More detail would improve completeness.

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 100% of the parameters and includes a clear description for includeOutdated ('Check for outdated pods and include update information. Default: false'). The tool description itself adds no parameter-specific meaning, but the schema already documents the parameter, so the 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 specific action ('Checks') on a specific resource ('active project') regarding CocoaPods usage, and indicates it returns setup information. This distinguishes it from sibling tools like pod_install, pod_update, or pod_outdated, which perform different 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 clear context for when to use this tool: to verify whether the active project uses CocoaPods and to get setup information. It implies a diagnostic role before using other pod tools, but it does not explicitly mention alternatives or state when not to use it, so it falls short of a 5.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It correctly implies a read-only existence check but does not specify the return format (e.g., boolean vs exception), behavior on inaccessible paths, or symlink handling. It adds no detail about side effects, though none are expected.

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 one sentence, front-loaded with the action, and contains no unnecessary words. It is appropriately sized for a simple tool.

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

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

The tool is simple with one well-documented parameter and no output schema. The description is largely complete, but the absence of an output schema means it should clarify the return behavior (e.g., boolean vs error), which it does not. Still, for a trivial existence check, the description provides sufficient context.

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

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

The input schema already documents the single parameter 'path' with full coverage (100%), including accepted formats (absolute, relative, ~). The description adds no parameter-specific details beyond the schema, so the baseline of 3 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 the tool's function with a specific verb ('Checks') and resource ('file or directory'), and specifies the scope ('exists at the specified path'). It distinguishes itself from sibling file operations like read_file, get_file_info, and list_directory by focusing solely on existence.

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 such as get_file_info or find_files. It does not mention exclusions, prerequisites, or context for decision-making, leaving the agent to infer 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?

With no annotations provided, the description carries the full burden of disclosing behavior. It states the action ('Cleans the build directory') but does not mention side effects, such as whether the action is destructive, whether it affects derived data, or whether it requires a specific project state. The brevity leaves the agent without important safety context for a potentially destructive 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 a single, clear sentence that directly states the tool's purpose. It is concise and front-loaded with the action, containing no unnecessary words or filler.

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

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

For a simple tool with no output schema and fully documented parameters, the description covers the primary purpose. However, the lack of behavioral details (e.g., destructiveness, dependency on the active project) and the absence of annotations leave some contextual gaps. The description is adequate but not rich enough to fully compensate for the missing annotation support.

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

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

The schema descriptions cover 100% of parameters, so the baseline is 3. The description adds no parameter-specific meaning beyond what the schema already provides. The schema is sufficient, but the description does not enhance understanding of the parameters' purpose or interactions.

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 ('Cleans') and the target ('the build directory for the active Xcode project'). It distinguishes itself from related tools like clean_swift_package (which targets Swift packages) and build_project (which builds rather than cleans).

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

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

The description implies the tool is used for cleaning Xcode build artifacts, and the phrase 'active Xcode project' distinguishes it from Swift package cleaning. However, it does not explicitly state when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only states the action without mentioning that cleaning is destructive, removes derived data, or affects global cache. This is a significant gap for a mutation tool.

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

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

A single concise sentence that is front-loaded and contains no filler. 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?

The tool is simple with two optional boolean parameters fully described in the schema. The description states the purpose adequately for selection and invocation. No output schema is needed. Minor lack is not mentioning side effects, but that is covered under behavioral transparency.

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 parameters are already well-documented (e.g., 'Reset the complete build directory', 'Also purge the global cache'). The description adds no additional parameter meaning, but the baseline of 3 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 uses a specific verb ('Cleans') and resource ('build artifacts of a Swift Package'), clearly distinguishing it from sibling tool 'clean_project' which targets Xcode 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?

No explicit guidance on when to use this tool versus alternatives. The description implies usage for Swift Package build artifacts but does not mention exclusions or compare with sibling tools like 'clean_project'.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does not state side effects, output format, whether outputDir is created/overwritten, or system requirements like Xcode. This is a significant gap for a compilation tool.

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

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

The description is a single, direct sentence with no filler. It is appropriately concise for the tool's simplicity, though it forgoes any structured detail that could aid 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?

The tool has six parameters, no annotations, and no output schema. The one-line description does not explain the compilation outcome, return value, or how it fits into a build workflow, leaving substantial gaps for an agent to invoke it correctly.

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

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

Schema description coverage is 100%, so the schema fully describes all six parameters. The description adds no additional parameter semantics, yielding the baseline score of 3.

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

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

The description clearly identifies the action ('Compiles'), the resource ('asset catalog (.xcassets)'), and the mechanism ('using actool'). This is specific and distinguishes it from sibling tools like generate_icon_set.

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

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

No guidance is provided about when to use this tool vs alternatives, prerequisites, or expected input/output context. The description is purely a statement of function without usage 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, the description carries the full burden of behavioral disclosure. It does not mention overwrite behavior, recursive requirements for directories, handling of existing destinations, or any side effects. The only extra info is the 'allowed directories' constraint, but it is vague.

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 core purpose. It is appropriately sized, 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 the lack of annotations and output schema, the description is insufficiently complete. It fails to explain key behaviors such as recursive copying requirements for directories, overwrite semantics, or how allowed directories are enforced. This is a mutation tool that requires more detail.

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 parameters are well-documented in the schema. The description does not add additional meaning beyond the schema, 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 copies a file or directory to a new location, with a specific verb and resource. It distinguishes from move_file by indicating a copy operation, and the 'within allowed directories' constraint adds useful scope.

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

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

The description provides no guidance on when to use this tool versus alternatives like move_file, nor any preconditions or exclusions. It merely states what it does, leaving the agent to infer usage context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the "allowed directories" constraint but omits critical behaviors such as whether parent directories are created, what happens if the directory already exists, and what return value or error is produced.

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

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

The description is a single, direct sentence that states the purpose without unnecessary words. It is appropriately sized for such a simple tool, though it could include more detail without becoming 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?

With no annotations and no output schema, the description leaves key operational details unstated: what defines "allowed directories," whether recursive creation is supported, and error behavior. The single parameter is well-documented, but the overall context is insufficient for a mutation 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 schema provides 100% description coverage for the single 'path' parameter, explaining absolute, relative, and '~' forms. The tool description adds no parameter-specific information beyond the schema, so the baseline score of 3 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 the action "Creates a new directory" and the resource, with the constraint "within allowed directories." It distinguishes from sibling tools like change_directory or delete_file, though it does not explicitly differentiate from higher-level creation tools such as create_workspace.

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

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

No guidance is provided about when to use this tool versus alternatives, no exclusions, and no prerequisites. The only implied context is the tool's name and the vague restriction to "allowed directories," which is not explained.

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 disclosure. It fails to mention the default setAsActive=true behavior that changes the active project, nor does it address error conditions like existing workspace conflicts. The optional addition of projects is a behavioral detail, but significant side effects are omitted.

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, front-loaded with the primary action, and contains no waste. It efficiently conveys the core purpose and the optional project addition.

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

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

The tool is fairly simple, but the description omits important context such as the side effect of setting the workspace as active by default and guidance on distinguishing from add_project_to_workspace. The schema covers parameters well, but behavioral and usage context is incomplete for a tool with no annotations or output schema.

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

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

Schema coverage is 100% with each parameter described. The description adds minimal value by mentioning the optional project addition, but it does not elaborate on semantics beyond what the schema already provides. Baseline 3 is appropriate since schema handles the parameter documentation.

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

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

The description clearly states the tool creates a new Xcode workspace and optionally adds existing projects, which is a specific verb+resource. It distinguishes from siblings like create_xcode_project (creates a project) and add_project_to_workspace (adds to an existing workspace) by focusing on workspace creation.

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

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

The description implies the tool is for creating workspaces, but it does not explicitly state when to use it over alternatives such as add_project_to_workspace or create_xcode_project. No exclusion criteria or context for when not to use it is provided, leaving the usage guidance implicit.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the core creation action but does not mention side effects such as setting the project as active, creating test targets, or filesystem modifications. Important behavioral details like whether existing projects are overwritten or what output is produced are omitted.

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 directly names the action and resource. Every word earns its place, with no filler, repetition, or unnecessary detail.

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

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

Given the tool's complexity (9 parameters) and the absence of annotations or an output schema, the one-sentence description is not sufficient. It fails to explain return behavior, side effects, or how the various optional parameters (like setAsActive or includeTests) affect the outcome, leaving the agent to infer crucial context.

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

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

Schema description coverage is 100%, so all 9 parameters are already documented in the input schema with meaningful descriptions. The tool description adds no additional parameter semantics, which keeps this at the baseline score 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 specific action ('Creates a new Xcode project') and the mechanism ('using a template'). This unambiguously distinguishes it from sibling tools like create_workspace or init_swift_package, which target different artifact types.

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 versus alternatives, no prerequisites, and no exclusions. It simply states what the tool does without contextualizing it among the many other project, workspace, and package management 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 full burden. It mentions 'within allowed directories' but fails to disclose that deletion is permanent, that recursive behavior is required for non-empty directories, or any failure modes—critical omissions for a 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 filler. It efficiently states the action and scope, earning a perfect score for conciseness.

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

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

For a simple two-parameter tool with no annotations or output schema, the description covers the core action but lacks important details about permanence and directory behavior. The parameter schema fills gaps, making this minimally viable 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 descriptions cover both path and recursive parameters at 100%, so the schema does the heavy lifting. The description adds the 'allowed directories' restriction, which provides some extra context but does not substantially enhance parameter 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 'Deletes a file or directory' with a specific verb and resource, and adds 'within allowed directories' to define scope, distinguishing it from sibling tools like read_file, write_file, or move_file.

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

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

Usage is implied by the delete verb but no explicit guidance is given about when to use this tool instead of move_file or copy_file, nor are exclusions or conditions mentioned. The 'within allowed directories' constraint gives minimal context but no proactive direction.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It only says 'Attempts to automatically detect', hinting at possible failure but not explaining side effects, whether it can overwrite an existing active project, or what happens after detection. The forceRedetect parameter indicates a skip behavior that is not mentioned in the description.

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

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

The description is a single sentence with no redundant words, front-loaded with the verb and resource. Every word contributes meaning, making it highly concise.

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

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

With no output schema and no annotations, the description should at least hint at return values or behavioral outcomes. It does not explain what the tool returns, when it might fail, or the difference between an already-set project and a forced redetect. The low complexity is offset by the lack of essential behavioral context for an agent to invoke it correctly.

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

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

The description does not discuss the 'forceRedetect' parameter, but the input schema provides a clear description and default value, giving 100% schema coverage. The baseline of 3 is appropriate because the description adds no 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?

The description uses the specific verb 'detect' and resource 'active Xcode project', clearly distinguishing it from siblings like get_active_project (which likely returns current setting) and find_projects (which searches broadly). The word 'automatically' clarifies it performs discovery rather than requiring 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?

No explicit when-to-use or alternative guidance is provided. The implication is that it is used when the active project needs to be discovered automatically, but it does not tell the agent when to prefer this over get_active_project or set_project_path, 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.

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not mention any side effects, prerequisites, or output destination (e.g., stdout), leaving behavioral traits ambiguous.

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

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

The one-sentence description is highly concise and front-loaded, with no wasted words. It effectively communicates the tool's core function in a single clause.

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

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

Given the tool's simplicity (no parameters, no output schema, no annotations), the description is minimally adequate but lacks contextual detail such as whether the dump is read-only, requires an active package context, or writes to stdout. This leaves some gaps for an agent deciding between this and similar tools.

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

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

The input schema has zero parameters, so there are no parameter semantics to clarify. The description correctly focuses on the tool's action rather than parameter details, earning the baseline score for tools with no 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 uses a specific verb 'Dumps' and clearly identifies the target resource as the Package.swift manifest, with output format specified as JSON. This distinguishes it from sibling Swift package tools like get_package_info, which likely serve a different purpose.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor any exclusion criteria. It simply states what the tool does without contextualizing its use case relative to other package management tools.

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

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

No annotations are present, so the description must carry the behavioral transparency burden. It only says 'directly edit' without disclosing that the entire file is overwritten, that a backup is created by default, or any error handling or permission requirements. The mutation behavior is not fully disclosed.

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, compact sentence with no unnecessary words. It front-loads the primary action and additional context efficiently, earning every word.

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 gives purpose and usage but lacks behavioral details that would be expected given the absence of annotations and output schema. It does not mention backup behavior, file overwrite implications, or project prerequisites. The schema partially compensates, but the description remains moderately complete for a simple file-editing 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?

All three parameters are fully documented in the schema (100% coverage), so the baseline is 3. The description adds no new parameter-specific information beyond what is already in the schema, such as the meaning of packagePath or createBackup.

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 directly edits the Package.swift file of the active SPM project, using a specific verb and resource. It also distinguishes itself from siblings by noting it handles changes not supported by other SPM tools, making the purpose unmistakable.

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 to use this tool for changes not supported by other SPM tools, providing a clear when-to-use condition. It implies that dedicated tools should be used for supported changes, but does not enumerate specific alternative tool names or provide exhaustive when-not-to-use 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 must carry the burden. It only states the high-level export action without disclosing side effects (e.g., file creation, code signing requirements, potential overwrites) or any error/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?

Single sentence that is immediately understandable and contains no filler. The parenthetical list of distribution methods is useful 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?

For an operation with 8 parameters and no output schema, the description is too sparse. It doesn't mention what the output looks like (IPA location), prerequisites (e.g., valid archive, signing), or failure modes. The schema covers parameter details but not overall behavior.

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 descriptions for all 8 parameters, including defaults and behaviors for optional ones (e.g., teamId, signingCertificate). The description adds no extra parameter meaning beyond the method list, which duplicates the enum.

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 (export), the resource (Xcode archive), and the purpose (for distribution with four methods). It distinguishes from siblings like archive_project (which creates archives) by focusing on the export step.

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 distribution scenarios (App Store, Ad Hoc, etc.) but does not explicitly say when to use this tool vs alternatives like validate_app or archive_project. No exclusion criteria or alternative tool names 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?

With no annotations, the description carries full responsibility for behavior. It only says 'searches for files' without disclosing return format, recursion behavior, or hidden file defaults (though schema covers parameters). No context on side effects or output, leaving the agent to infer.

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?

Single sentence, no fluff. Front-loaded with action and object. Efficient.

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

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

Despite having 4 params and no output schema, the description gives minimal information. It doesn't describe what is returned (e.g., list of matching paths) or any default behaviors. A tool-calling agent would need to infer from schema or test. Incomplete for a tool with no annotations 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?

Schema provides 100% parameter descriptions, so description adds no extra meaning. It doesn't elaborate on path resolution or glob syntax beyond 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 finds files via pattern matching in a directory. 'Searches for files' is a specific verb+resource, and the schema clarifies pattern as glob. It differentiates from sibling search_in_files (content search) and list_directory (listing).

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 on when to use this tool vs alternatives. The description implies usage for pattern-based filename lookup but doesn't mention exclusions or alternatives such as search_in_files for content or list_directory for full listings.

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

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

With no annotations, the description carries the full burden of disclosure. It does not explain what exactly constitutes an Xcode project (e.g., .xcodeproj directories), whether the search is recursive, what the output format is, or how the includeSPM and includeWorkspaces parameters alter the default behavior.

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

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

The description is a single sentence, direct and free of redundancy. It is appropriately sized for a simple tool and front-loads the core action and object.

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 an output schema, the description does not explain what the tool returns (paths? names?), nor does it describe the impact of the optional parameters. The behavior of including/excluding workspaces and SPM packages is left entirely to the schema, which is insufficient for an agent to use the tool correctly.

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

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

The schema provides complete descriptions for all three parameters, so the baseline is 3. The description adds no additional meaning beyond the existence of the directory parameter; it does not clarify the semantics or default values of includeSPM and includeWorkspaces.

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 specific action (finds) and resource (Xcode projects) with a location qualifier, clearly distinguishing it from generic file search tools like find_files. However, it doesn't explicitly mention that it can also include workspaces or Swift Package Manager projects, which are key differentiators.

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

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

The phrase 'in the specified directory' implies a scoped search, and the tool's purpose suggests it is for locating project roots before using tools like get_project_configuration. However, it lacks explicit guidance on when to prefer this over alternatives like find_files or list_directory, and no exclusion criteria are 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?

With no annotations, the description carries the full burden, but it only states the action. It does not disclose side effects (e.g., creating directories, writing files), overwrite behavior, or any failure conditions. This is a significant transparency gap for a generative 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 that conveys the core purpose without wasted words. It is appropriately concise for a simple tool.

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

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

The description plus schema explains the inputs but not the full scope of what 'generate an icon set' entails, such as the output structure or requirements for the source image. No output schema exists, but the tool's simplicity and strong schema descriptions keep it from being completely inadequate.

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

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

Schema coverage is 100%, so all parameters are described in the input schema. The description adds no additional parameter context, but given the high schema coverage, the 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 tool's function with a specific verb ('Generate') and resource ('app icon set'), and the source input ('from a source image'). It distinguishes itself from siblings like compile_asset_catalog by focusing on generating icon sets rather than compiling them.

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

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

The description implies when to use it (when you need an app icon set from an image) but provides no explicit context, prerequisites, or alternatives. There is no mention of when not to use it or comparisons to other tools.

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

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

With no annotations provided, the description must fully disclose behavior. It only states the basic action and method, without mentioning potential side effects, output format, required environment, or failure modes. This is minimal disclosure for a generation tool that likely creates files.

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 says exactly what the tool does with no redundant words or filler. It is concise 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?

Despite having a well-documented schema, the description lacks essential context about prerequisites, expected behavior, or return values. With no annotations and no output schema, the agent has to infer too much about how to invoke and interpret this tool in real workflows.

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 4 parameters with descriptions, so the baseline is 3. The description adds no additional parameter semantics beyond the schema, but since schema coverage is 100%, this is acceptable.

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 ('Generates') and specific resource ('documentation for a Swift Package using DocC'). It distinguishes itself from sibling tools like build_spm_package and test_swift_package, which perform other operations on Swift packages.

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 versus alternatives. While it is the only documentation-generation tool among the siblings, it does not state prerequisites or situational context, such as needing an initialized Swift package or Xcode.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a read-only operation but does not mention what 'detailed information' includes, whether any errors can occur (e.g., no active project), or any side effects. This is a significant gap for a tool with no structured safety hints.

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 redundant words. It is appropriately front-loaded and efficient.

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

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

Given the tool's simplicity (one optional parameter, no output schema), the description is minimally adequate. However, it lacks essential context such as what the return value looks like, error handling when no project is active, and how this tool relates to siblings. More detail would be expected for a tool whose output is not otherwise specified.

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% for the single parameter, so the baseline is 3. The parameter description ('If true, include additional detailed project information') adds some meaning, but the tool description itself does not clarify what 'detailed' means or the difference between true and false. The schema does the heavy lifting here.

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: retrieving detailed information about the active Xcode project. It uses a specific verb ('retrieves') and a specific resource. However, it does not explicitly distinguish itself from the sibling tool 'detect_active_project', which could be confused as a similar operation.

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

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

No guidance is provided on when to use this tool versus alternatives like 'detect_active_project' or 'get_project_configuration'. The description only states what the tool does, not the context or conditions under which it should be used.

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 states 'Returns the current active directory.' It does not disclose potential side effects, error behavior, or what 'active directory' means in context. This leaves the agent without important behavioral information.

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 directly states the tool's function with no unnecessary words. It is highly concise and structurally clear.

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

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

For a zero-parameter getter tool, the description is largely sufficient. It states the purpose and return value. Minor ambiguity about 'active directory' and lack of output format details prevent a perfect score, but overall completeness is good for its simplicity.

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

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

The tool has zero parameters, and schema coverage is 100%, so the description does not need to explain parameter semantics. The baseline of 4 applies because there are no parameters to describe.

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

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

The description uses a specific verb ('Returns') and resource ('current active directory'), making the purpose clear. However, it does not explicitly distinguish itself from sibling tools like 'get_active_project' or 'resolve_path', though the resource is reasonably distinct.

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

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

No guidance is provided on when to use this tool versus alternatives. While it is a simple getter, there is no mention of why it might be preferred over 'change_directory' or 'resolve_path'.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not explain what 'detailed information' includes (e.g., size, permissions, timestamps), whether the path must exist or if errors are handled, or what the return value looks like. The only behavioral hint is the path flexibility, which is already in the 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, front-loaded sentence with no unnecessary words. It is efficiently written, though it could benefit from specifying what 'detailed information' means. Still, it earns its place as a concise summary.

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

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

The tool is simple (one parameter, no output schema), but the description leaves significant gaps. The agent does not know what 'detailed information' entails or how it differs from sibling tools like 'resolve_path' or 'list_directory'. Given no annotations and no output schema, the description should clarify the return format and distinguishing behavior, which it does not.

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%, and the schema description already documents the path parameter well (absolute, relative, ~). The tool description adds no additional semantics beyond restating 'file or directory', which is also in the schema. 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 uses a clear verb+resource ('Gets detailed information about a file or directory') which states the tool's core function. However, it does not distinguish this from sibling tools like 'check_file_exists' or 'list_directory', and 'detailed information' is vague as to what specific data is returned.

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

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

No guidance is provided on when to use this tool versus alternatives such as 'list_directory', 'resolve_path', or 'check_file_exists'. The description gives no context or exclusions, leaving the agent to guess the appropriate use case.

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 itself. It only says 'gets detailed information', which implies a read operation but does not explicitly state safety, side effects, return format, or potential errors. This is minimal disclosure for a tool with zero annotation coverage.

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

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

The description is a single, concise sentence with no redundant phrases. It front-loads the action and object, making it immediately clear what the tool does. Every word contributes meaning.

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

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

The description is vague about what 'detailed information' includes and what the return format is. Since there is no output schema and no annotations, the description fails to provide essential context such as the nature of the information, potential side effects, or when to prefer this tool over similar ones. It is minimally viable but incomplete for an agent.

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

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

The schema already covers the sole parameter "packagePath" with a description, achieving 100% schema coverage. The tool description adds no additional semantics or context about the parameter, so it doesn't improve on the schema but also doesn't need to. 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 ('gets') and the resource ('detailed information about a Swift Package Manager package'), making the purpose easy to understand. However, it doesn't distinguish itself from sibling tools like dump_swift_package or show_swift_dependencies, which could also provide package-related information.

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 lacks context about use cases, prerequisites, or exclusions, leaving the agent to infer appropriate usage from the tool name alone.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. The verb 'Retrieves' implies a read-only operation, and the phrase 'including schemes and targets' adds useful scope. However, it does not disclose potential error conditions (e.g., what happens if no active project exists) or whether the result contains all configuration details or only selected ones.

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 efficiently conveys the tool's purpose. There is no redundant information or filler; 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?

The tool has no output schema and no annotations, so the description must carry the burden of explaining what is returned. It provides the core purpose but not the return format or details about edge cases like a missing active project. Given the tool's low complexity, this is minimally adequate but leaves some 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 tool has zero parameters, which earns a baseline score of 4. The description does not need to explain parameter syntax, but it does reference 'active project' as a contextual state that determines behavior, adding slight meaning beyond the empty 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 uses the specific verb 'Retrieves' paired with a clear resource ('configuration details for the active project') and concrete examples ('schemes and targets'). This clearly distinguishes it from sibling tools like get_active_project (which returns the project itself) and list_available_schemes (which lists only schemes).

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 implicitly communicates when to use the tool—when you need configuration details of the currently active project—but it does not explicitly mention any prerequisites (e.g., needing an active project first) or alternatives. There is no exclusion guidance to help decide between this and related tools like list_available_schemes or list_available_destinations.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the tool 'gets' information, which implies a read-only operation, but does not disclose what specific details are returned (e.g., paths, versions), whether any system changes occur, or if certain permissions are needed.

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

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

The description is a single, focused sentence that conveys the tool's core purpose without unnecessary words. It is appropriately concise and front-loads the key action and resource.

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

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

Given the absence of an output schema and the simplicity of the tool, the description provides enough to understand its primary function but lacks detail about the content and structure of the returned information. For an agent selecting the tool, it is minimally viable but could benefit from specifying what 'information' includes (e.g., version, path, SDKs).

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

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

The tool has zero parameters, and the schema confirms this with an empty properties object. Since there is nothing to describe, the baseline of 4 is appropriate. The description adds no parameter-specific semantics, but none are 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?

The description uses a clear verb 'Get' and specific resource 'information about Xcode installations', making the tool's purpose immediately understandable. It also distinguishes from siblings like switch_xcode, which changes Xcode versions, by focusing on informational retrieval.

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, such as checking Xcode before switching or building. There are no explicit use cases, prerequisites, or exclusions, leaving the agent to infer appropriateness from context.

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

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

No annotations are provided, so the description carries the full burden. It mentions initialization in the current directory and implies creation of Package.swift, but does not disclose potential side effects like overwriting existing files, whether the directory must be empty, or exactly what files are generated. For a straightforward init tool this is adequate but leaves some 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, first gives the core action, second gives usage guidance. No redundant information, front-loaded and efficient.

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

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

For a simple init tool with 4 optional parameters fully described in the schema, the description is complete enough: it states what it does, where, and when to use it. It doesn't cover edge cases like overwrite behavior, but the core information needed to select and invoke the tool is present.

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

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

Schema description coverage is 100% and every parameter has a clear description, so the schema already communicates names, types, defaults, and enums. The description adds no parameter-specific information, so the baseline of 3 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 'Initializes a new Swift Package Manager project in the current directory', with a specific verb (initializes), resource (Swift Package Manager project), and location (current directory). This distinguishes it from sibling tools like add_swift_package or create_xcode_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?

Explicitly says 'Use this tool first if your project doesn't have a Package.swift file yet and you want to start using Swift packages', providing a clear condition for when to use it. This implies it is a prerequisite for other package operations and differentiates it from tools that modify existing packages.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action and does not explain side effects, requirements (e.g., booted simulator, .app bundle format), or behavior on existing installations. This is a minimal description that leaves critical behavior undisclosed.

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

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

The description is a single, direct sentence that efficiently states the purpose without unnecessary words. It is front-loaded and easy to scan, making every word count.

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

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

Given the tool's simplicity (two straightforward parameters, no output schema), the description is minimally acceptable but incomplete. It fails to mention important usage context like the requirement for a booted simulator or the .app bundle format, which could lead to incorrect usage if the agent assumes too much.

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 documents both parameters (udid and appPath) with clear descriptions, achieving 100% schema coverage. The description adds no extra meaning beyond the schema, which is the baseline case.

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 'Install an app on a simulator' uses a specific verb and resource, clearly distinguishing it from sibling tools like launch_app (which runs an installed app) and list_installed_apps. It conveys the tool's core function without ambiguity.

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

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

The description gives no guidance on when to use this tool versus alternatives, nor does it mention prerequisites such as the simulator needing to be booted. There is no mention of exclusions or context to help the agent decide between install_app and related simulator tools.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states the core action ('Launch') without revealing what happens if the app is not installed, whether the tool is blocking, or if any side effects occur. No additional behavioral context is given.

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

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

The description is a single, front-loaded sentence with zero wasted wording. It is exactly as concise as possible while still stating the primary 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 has no annotations, no output schema, and a very terse description, the context is sparse. The description omits important conditions such as requiring the app to be installed and simulator to be booted, and gives no hints about failure modes or expected outcomes. This is insufficient for an agent to use the tool safely in a workflow.

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 all four parameters, so the baseline is 3. The description adds no information beyond the schema; it does not even mention parameters such as udid or bundleId, but the schema already provides clear per-parameter descriptions.

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

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

The description uses a specific verb ('Launch') and identifies the resource ('installed app on a simulator'). It clearly distinguishes the tool from siblings like install_app, terminate_app, or open_url by stating exactly what action it performs.

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 install_app or boot_simulator. The description offers no context about prerequisite conditions (e.g., app already installed, simulator booted) 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, the description is the sole source of behavioral information. 'Lists' clearly indicates a read-only, non-mutating operation, and the optional scheme behavior is disclosed. It does not mention error conditions or output formats, but for a simple listing operation this is not a major gap.

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

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

The description is a single, focused sentence that states what the tool does and its context. Every word contributes to understanding the tool's purpose and scope, with no redundancy or filler.

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

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

The tool is simple with one optional parameter and no output schema. The description covers the core action, the scope (active project/workspace), and the optional scheme behavior, making it complete for effective selection and invocation.

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

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

The schema covers the single parameter 100%, including its optional nature and default behavior ('Optional scheme to show destinations for. If not provided, uses the active scheme.'). The description does not add material meaning beyond the schema, so the baseline score of 3 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 uses a specific verb ('Lists') and names the resource ('available build destinations') with the scope ('active Xcode project or workspace'). It clearly distinguishes from sibling tools like list_available_schemes by targeting a different resource.

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

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

The description clearly identifies when to use the tool: to list build destinations for the active project or workspace. It also explains the scheme parameter's default behavior, which gives useful context, though it does not explicitly compare against alternatives or state exclusion cases.

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

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

No annotations are provided, so the description carries the full burden. It discloses a read-only behavior via 'list' and scopes to the active project/workspace, but doesn't mention potential edge cases (e.g., no active project, private schemes omitted) or the exact return format. For a simple list operation, this is adequate but not comprehensive.

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 conveys the essence without any filler. Every word adds value, making it highly concise and well-structured.

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 parameters, no output schema, and no annotations, the description is complete. It states the action, the resource, and the relevant context (active project/workspace), which is sufficient for an agent to select and invoke the tool correctly.

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

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

The tool has zero parameters, so the baseline is 4. The description correctly implies no inputs are required, and the schema confirms an empty object with no properties.

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

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

The description clearly states a specific action: lists all available schemes in the active Xcode project or workspace. The verb 'list' and resource 'schemes' are precise, and the scope (active project/workspace) distinguishes it from sibling tools like list_project_files or list_available_destinations.

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 context 'in the active Xcode project or workspace' implies when to use the tool, but there is no explicit guidance on alternatives or when not to use it. The usage is understood from the purpose, but a more explicit note about using it to enumerate schemes before building or testing would earn a higher score.

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

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

With no annotations provided, the description carries the full burden. It communicates that the operation is a read-only listing and the 'currently booted' qualifier is meaningful. However, it does not disclose the output format, whether an empty list is possible, or any error conditions. For a simple list tool this is adequate but not rich.

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

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

The description is a single clear sentence with no wasted words. It is appropriately sized and front-loaded with the key action and scope.

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

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

For a zero-parameter tool with no output schema, the description is nearly complete. It clearly states what is listed and the filter. It does not describe the return format, but 'List' implies a list result, and the simplicity of the tool makes this a minor gap.

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

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

The tool has zero parameters and the schema has no properties, so there is nothing to explain. The baseline for 0-param tools is 4, and the description adds no unnecessary parameter information.

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

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

The description states a specific verb ('List'), a specific resource ('iOS simulators'), and a clear filter ('currently booted'). This clearly distinguishes it from sibling tools like list_simulators, which likely lists all simulators.

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

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

The description implies the use case (need to see only booted simulators) but provides no explicit guidance about when to prefer this over list_simulators or other simulator-related tools. There are no exclusions or alternatives 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 carries the full burden of behavioral disclosure. It only reveals that the tool shows files and subdirectories, but omits behaviors such as whether hidden files are shown by default (controllable via the showHidden parameter), what the 'simple' vs 'detailed' formats entail, and how errors like nonexistent paths are handled. The description adds minimal context beyond the tool's name.

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

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

The description is a single, concise sentence that conveys the core function without any redundant information. Every word contributes to the meaning, making it an exemplary model of efficiency. This earns a 5.

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 should compensate by explaining return format, defaults, or edge-case behavior. It does none of this. The tool has three parameters and could reasonably be expected to describe its output structure or sorting behavior. The description is minimal and leaves important usage context unaddressed, so a score of 2 reflects its incomplete nature.

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 each parameter having a clear description. Per the rubric, baseline is 3 when the schema covers parameters fully. The tool description itself adds no parameter semantics beyond what the schema already provides, so a 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 purpose: 'Lists the contents of a directory, showing both files and subdirectories.' It uses a specific verb (lists) and resource (directory contents), and the inclusion of both files and subdirectories distinguishes it from file-specific tools like read_file and get_file_info. This meets the 5-point criterion of specific verb+resource with clear differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. Sibling tools like list_project_files and find_files likely overlap in functionality, but the description does not mention any distinguishing use cases or exclusions. An agent receives no direction on tool selection, resulting in a score of 2 (no guidance).

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

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

No annotations are provided, so the description carries full burden. It discloses no behavioral traits beyond the basic action, such as whether the simulator must be booted, whether it returns bundle IDs or display names, or any special prerequisites. The simplicity of a list operation mitigates this, but key context is missing.

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 filler. It communicates the tool's purpose efficiently without wasting 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?

For a simple read-only tool with one required parameter and no output schema, the description is adequate: it clearly states what the tool does and the parameter is fully described. It could mention return format or prerequisites, but the low complexity and available schema make it 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 description coverage is 100% for the single parameter 'udid', so the schema already explains it. The description adds no additional meaning beyond the schema, matching the baseline of 3.

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

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

The description uses a specific verb ('List') and resource ('installed applications on a simulator'), clearly distinguishing it from sibling tools like list_simulators and list_booted_simulators which list simulators, not 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?

Usage context is implied by the description (you use this when you need to see installed apps), but there is no explicit guidance about when to use this versus alternatives, nor any exclusions or prerequisites 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 carry the burden of behavioral disclosure. It only says 'Lists all files within an Xcode project' and does not mention return format, whether the listing is recursive, whether directories are included, or any error/permission behavior. This is minimal for a tool without annotation support.

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

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

The description is a single concise sentence, front-loaded with the core action. It is not overly verbose, though it could add useful details (e.g., 'recursively') without losing conciseness. Still, its brevity is appropriate for a simple listing tool.

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

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

Given the tool's simplicity, high schema coverage, and no output schema, the description is adequate but not complete. It does not specify what the tool returns (e.g., a list of paths) or whether it handles invalid project paths. For an agent to invoke it correctly, the purpose is clear, but the expected output and edge-case behavior are left unspecified.

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 (projectPath and fileType) clearly documented in the input schema. The tool description itself does not add extra parameter context, but the schema already provides adequate semantics, so the baseline score of 3 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 the action ('Lists') and the target ('all files within an Xcode project'), using a specific verb and resource. It is distinguishable from sibling tools like list_directory by focusing on Xcode projects, though it does not explicitly differentiate its scope or mention recursion.

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

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

There is no guidance on when to use this tool versus alternatives such as list_directory, find_files, or get_project_configuration. The description only states what it does, not when it is appropriate, so agents receive no decision-making support.

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

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

No annotations are provided, so the description carries the burden. It states a read-only listing operation which is transparent, but it does not detail the return format, what 'available' means, or any dependencies like Xcode. The description is not misleading, but it lacks depth.

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 immediately conveys the tool's purpose and key capability. No redundant words or phrases, making it highly concise 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?

For a simple listing tool with four optional parameters fully covered by schema, the description is adequate. It does not explain the return structure, but the absence of an output schema is offset by the tool's straightforward nature. Could mention defaults or examples, but current completeness is good.

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 fully documents all four parameters with descriptions and enums, so the description's mention of 'filtering options' adds no extra semantic value. With 100% schema coverage, 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 uses a specific verb 'List' and a clear resource 'all available iOS simulators', which distinguishes it from the sibling 'list_booted_simulators' tool. It also mentions filtering options, indicating the tool's scope.

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

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

The description implies usage by stating 'all available' and 'filtering options', but it does not explicitly compare with alternatives like 'list_booted_simulators' or state when not to use this tool. General context is clear, but exclusions are absent.

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

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

With no annotations, the description carries the full burden. It adds the constraint 'within allowed directories' but fails to disclose important behaviors such as overwrite semantics, cross-filesystem support, permission requirements, or success/error return behavior. This is minimal for a mutating 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 a single, clear sentence with no filler. It delivers the core purpose and a key constraint efficiently.

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 absence of annotations and output schema, the description should explain more about behavior, return values, and edge cases. It only states the move capability and the directories restriction, leaving unclear what happens on success or failure, and whether any side effects (e.g., overwriting) occur.

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 parameters have descriptions in the input schema. The tool description does not add parameter-specific information beyond the schema, so the baseline of 3 applies. The 'allowed directories' hint indirectly affects possible values but is not parameter-specific.

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

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

The description clearly identifies the action 'Moves' and the target 'a file or directory to a new location,' distinguishing it from siblings like copy_file (copy) and delete_file (remove). The scope 'within allowed directories' adds specificity.

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

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

The description implies usage for relocating files/directories but does not explicitly state when to choose this over copy_file or delete_file, nor does it mention exclusions/alternatives. The context is clear but not explicitly differentiated.

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

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

No annotations are present, so the description carries the full burden. It states the action but omits whether the simulator must be booted, which app handles the URL, or any side effects or return values. Minimal behavioral disclosure.

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

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

Extremely concise, consisting of a single sentence with no wasted words. The description is front-loaded and easy to read.

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

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

Despite having only 2 parameters, the description lacks important context such as prerequisites (booted simulator), behavior (opens default browser), and output. This makes it insufficient for an agent to use the tool correctly in all scenarios.

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 url and udid clearly described. The tool description adds little beyond the schema, simply confirming that the URL is opened in the simulator specified by udid. 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 (open) and the resource (a URL) in a specific environment (simulator). It distinguishes from siblings like launch_app, which launches an app, as opening a URL is a distinct operation.

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

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

No guidance is provided on when to use this tool versus alternatives, prerequisites such as a booted simulator, or typical use cases. The description is a bare statement of the action.

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. While 'removing all traces of CocoaPods' hints at a destructive operation, it does not specify what exactly gets removed (e.g., Podfile, Pods directory, workspace) or whether the operation is reversible. This lack of detail is a significant gap for a 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, concise sentence that front-loads the action ('Deintegrate') and immediately clarifies scope. Every word earns its place, with no unnecessary filler.

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

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

Given the tool's simplicity (no parameters, no output schema, no annotations), the description provides the core purpose but misses important destructive context. It does not mention prerequisites, side effects, or post-conditions, making it only partially complete for safe 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?

The tool has zero parameters and the schema is empty, so there are no parameter semantics to explain. The baseline for 0 params is 4, and the description does not need to add parameter information.

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

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

The description uses the specific verb 'Deintegrate' with the resource 'CocoaPods' and the scope 'active project', clearly differentiating it from sibling tools like pod_install or pod_update. The action is unambiguous and not a tautology.

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 you need to remove CocoaPods from the active project, but it does not explicitly state when to use this tool versus alternatives such as pod_install or pod_update. There are no exclusions or clear when-not-to-use guidance, only implied context.

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

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

Without annotations, the description must carry the burden of behavioral disclosure. It only says 'Generate a Podfile' with no details about side effects (e.g., creating/overwriting a file), potential prompts, or required environment setup. This is insufficient for a tool that creates artifacts.

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 communicates the core purpose without any redundancy. It is appropriately sized for a tool with zero parameters.

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 large set of sibling tools, the description lacks contextual positioning (e.g., that this is a precursor to pod_install) and does not explain what a Podfile is or what subsequent steps are needed. No output schema exists, so the description should provide more context about the result of generating a Podfile.

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

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

The tool has no parameters, and the empty input schema with 100% coverage means the description adds value by specifying the target directory ('current project directory'). This context is helpful and goes beyond the schema, though no parameter explanation 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?

The description states a specific verb ('Generate') and resource ('Podfile') with a clear location scope ('current project directory'). It clearly distinguishes from sibling tools like pod_install and pod_update, which perform different operations.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention prerequisites (e.g., CocoaPods installed) or relationship to other tools like pod_install. Usage is only implied by the action itself.

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

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

With no annotations, the description carries the full burden of disclosing side effects. It only states that the command runs, omitting that it modifies Podfile.lock and the Pods directory, may require network access, or could fail if CocoaPods is missing. This significant gap in mutation behavior reduces transparency.

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

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

The description is a single, focused sentence that states the command and its purpose. There is no redundant or irrelevant information, making it highly concise and well-structured.

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

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

The tool is simple with three self-documenting boolean parameters, but the missing annotation coverage and lack of side-effect disclosure leave the description incomplete. It does not mention what changes occur or prerequisites, though the simplicity of the tool mitigates this somewhat.

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 each parameter (verbose, repoUpdate, cleanInstall) already having descriptive text. The tool description adds nothing about parameter behavior or syntax, so the baseline of 3 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 specifies the action ('Runs pod install') and the resource ('in the active project directory to install CocoaPods dependencies'). This distinguishes it from sibling tools like pod_update and pod_repo_update by focusing on the install action.

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 implicitly suggests use when installing dependencies in the active project directory, but it does not explicitly compare to alternatives such as pod_update or pod_init, nor does it mention when not to use it. The context is clear but lacks explicit 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, the description carries the full burden. It claims a read-only 'shows' behavior but does not disclose that setting repoUpdate=true will update spec repositories (a side effect). It also does not describe the output format or network interactions.

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 directly states the tool's function without unnecessary words or repetition.

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

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

The tool is simple with only two optional boolean parameters and no output schema. The description conveys the core purpose but omits the fact that repoUpdate modifies repository state and does not describe the return format. Still, for a list-oriented tool, it is largely complete.

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

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

Schema description coverage is 100% and each parameter has a descriptive comment. The description adds no extra meaning beyond the schema; 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 uses a specific verb ('Shows') and resource ('outdated pods in the current project') and explicitly mentions 'available updates', which clearly distinguishes it from sibling tools like pod_update (which actually performs updates) and pod_repo_update (which updates repos).

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 states it works on the current project, giving context for use, but does not provide explicit guidance on when to use this tool vs alternatives, such as whether to run pod_repo_update first or use pod_update to apply updates. The distinction is implied by the name but not stated.

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

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

No annotations are provided, so the description must fully disclose behavior. It only says 'Updates the local clone,' but doesn't specify side effects (e.g., modifies local cache, requires network), potential reversibility, or failure modes. This is similar to the update_drive example.

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, front-loaded sentence that immediately states the tool's purpose. No unnecessary words or redundancy.

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

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

For a simple tool with two optional boolean parameters, the description conveys the core purpose. However, it lacks usage context and behavioral details, and with no annotations or output schema, it relies on the description alone. It's minimally viable but has 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 provides descriptions for both boolean parameters ('silent' and 'verbose'), achieving 100% coverage. The description itself adds no additional parameter context, so the 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 states a specific action ('Updates') and resource ('local clone of the CocoaPods spec repositories'). It clearly distinguishes from sibling tool pod_update, which updates project Pods rather than the spec repos themselves.

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

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

No guidance is provided on when to use this tool versus alternatives like pod_update, pod_outdated, or pod_install. There is no mention of prerequisites, expected usage, 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, the description carries full responsibility for disclosing behavior. It merely states that the command is run and that dependencies are updated, without mentioning side effects such as modifying Podfile.lock, network access, or potential need to install pods first.

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 is appropriately concise. It contains no filler and directly states the tool's primary 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's moderate complexity (5 optional parameters) and lack of annotations or output schema, the description is too sparse. It doesn't explain command behavior beyond the raw command, its side effects, or how it fits with sibling tools, leaving the agent to infer important context.

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

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

The input schema provides 100% coverage with descriptions for all five parameters, so the baseline is 3. The tool description adds no additional parameter semantics beyond what the schema already provides.

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 executes the 'pod update' command to update CocoaPods dependencies, providing a specific verb and resource. However, it doesn't explicitly distinguish itself from sibling tools like pod_install or pod_outdated beyond the inherent meaning of 'update'.

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

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

No guidance is given on when to use this tool versus alternatives such as pod_install or pod_outdated. The only context provided is that it runs in the active project directory, which is a location rather than a usage condition.

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 core side effect of changing the current directory and mutating the stack, but does not mention behavior on an empty stack, error handling, or whether the operation is reversible.

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

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

One front-loaded, concise sentence with no filler. Every word contributes to understanding the operation.

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 parameterless navigation tool with no annotations and no output schema, the description is mostly complete. It could mention empty-stack behavior, but the simplicity of the operation makes this a minor gap rather than a major deficiency.

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

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

The tool has zero parameters, so the schema carries no parameter semantics. The description adds useful context by explaining the directory-stack mechanism, which is the only semantic needed here.

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 specific verb 'pops' and resource ('a directory from the stack') and says it changes to that directory. This distinguishes it from sibling tools like change_directory and pairs naturally with push_directory.

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 when-to-use or alternative guidance is given, but the phrase 'from the stack' implies it should be used after a push_directory and for LIFO navigation. This is implied usage rather than explicit direction.

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

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

No annotations are provided, so the description carries the full burden. It clearly discloses the two side effects: pushing the current directory onto a stack and changing to a new directory. It does not mention error behavior or stack lifetime, but the core behavioral traits are transparent.

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

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

The description is a single concise sentence that effectively conveys both the push action and the directory change. It avoids redundancy and gets straight to the point.

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

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

The tool is simple, with one fully documented parameter and no output schema. The description covers the core operation adequately. It could mention the paired pop_directory or failure conditions, but those are minor gaps given the tool's low 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?

The schema provides a complete description of directoryPath (absolute, relative, ~), so coverage is 100%. The tool description adds no additional parameter detail beyond 'new directory', so it does not exceed the schema 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 uses specific verbs 'pushes' and 'changes to' to clearly state the stack push operation and the resulting directory change. This distinguishes it from siblings like change_directory (which simply changes) and pop_directory (which pops), making the 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?

The stack semantics imply a usage pattern of saving the current directory before changing, but the description does not explicitly say 'use this when you need to return later' or compare with alternatives like change_directory. No exclusions 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 carries the burden of behavioral disclosure. It reveals a path scope restriction but does not mention return format, error handling, or permission requirements. 'Reads' implies a safe read operation, but missing details like binary/text handling are left to the 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 sentence that front-loads the verb and resource, with no redundant or extraneous text. It is concise and well-structured.

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

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

The tool is simple with three well-documented parameters, but with no annotations or output schema, the description could more fully address usage guidance (e.g., when to prefer it over search_in_files) and output/error behavior. It is minimally viable for a straightforward read operation but leaves gaps.

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

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

Schema coverage is 100% with clear descriptions for filePath, asBinary, and encoding. The description adds valuable meaning beyond the schema by specifying that the file must be within the active project or allowed directories, qualifying the filePath 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 uses the specific verb 'Reads' and resource 'contents of a file', clearly distinguishing it from sibling tools like write_file, copy_file, and delete_file. The added scope constraint 'within the active project or allowed directories' provides precision beyond the tool name.

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

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

The description gives a context constraint (active project/allowed directories) but does not specify when to use this tool versus alternatives like search_in_files or get_file_info. No explicit alternatives or exclusions are mentioned, leaving usage to be inferred.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Removes a Swift Package dependency' without mentioning side effects like modifying Package.swift, irreversibility, or the need for confirmation. The confirm parameter exists in the schema but the description adds no context about why it's needed.

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

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

The description is a single sentence with zero redundancy. Every word contributes to the purpose, making it appropriately concise 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?

For a destructive mutation tool with no annotations and no output schema, the description is too thin. It fails to mention what files are modified, whether the action is reversible, or any prerequisites. The schema covers parameters but not operational context.

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

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

Schema coverage is 100%: both url and confirm are described with clear meanings. The description itself adds no parameter information, but with full schema coverage the 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 (removes), the resource (Swift Package dependency), and the scope (from the active project). This distinguishes it from sibling tools like add_swift_package or update_swift_package.

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

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

The description gives clear context: it operates on the active project. However, it does not explicitly mention alternatives or when not to use it, but the context makes the intended use clear.

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 explicitly discloses the destructive nature of the operation by stating it erases 'all content and settings.' This is the critical behavioral trait. However, it does not explicitly mention that the reset is irreversible, that confirmation is required (though schema covers it), or what happens to running apps. Still, the core risk is well conveyed.

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 filler words. It front-loads the action and defines the scope with 'all content and settings,' making it efficient and easy to parse.

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

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

For a destructive tool with two parameters and full schema coverage, the description covers the essential behavior. It omits mention of the confirm parameter (handled by schema) and does not describe return values, but for this tool the description is largely adequate. It could be enhanced by explicitly noting that the operation is irreversible, but the current text is sufficient.

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 provides complete descriptions for both parameters (udid and confirm, with confirm explicitly required to be true). The description adds no additional paramter-specific semantics, providing no further detail beyond what the schema contains. Thus 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 uses the specific verb 'Reset' with a direct object 'a simulator' and elaborates 'by erasing all content and settings,' clearly distinguishing it from sibling tools like boot_simulator or shutdown_simulator which do not erase 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?

No guidance is provided on when to use this tool versus alternatives. It does not mention that this is destructive and should be used sparingly, nor does it reference alternative reset options or prerequisites. The description simply states the action without contextual placement among sibling tools.

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

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

No annotations are provided, so the description carries the full burden. It states that the path is resolved 'taking into account the active directory and current project,' but does not disclose whether the tool accesses the filesystem, checks existence, or what the return value looks like. 'Resolves' remains vague.

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

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

A single sentence that is direct and free of redundancy. It efficiently communicates the core behavior and context, earning a top score.

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 no annotations, the description should explain return values and side effects. It does not, but for a simple path resolution tool, the purpose is largely conveyed. The missing details about output and error behavior leave 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?

The schema already documents the path parameter with examples (absolute, relative, ~). The description adds 'current project' as an additional resolution context, which goes beyond the schema's mention of 'active directory.' This is a meaningful value-add, though not extensive.

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

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

The description uses the specific verb 'resolves' with 'path' as the resource, and adds context about active directory and current project. This makes the core purpose clear, though it doesn't explicitly state that the result is an absolute path or distinguish it from sibling tools like change_directory or get_current_directory.

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 on when to use this tool versus alternatives. The mention of 'active directory and current project' implies a use case, but there are no direct comparisons or exclusions. The agent is left to infer when path resolution is needed.

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