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 effectively describes the tool's workflow (detects file type, runs matching tools), performance characteristics (time estimates for each depth level), and constraints (use 'deep' only when needed). However, it doesn't mention error handling, output format, or system requirements.

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

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

The description is well-structured and front-loaded with the core purpose, followed by implementation details and usage guidance. Every sentence adds value: the first explains the automated workflow, the second provides concrete examples, and the third offers practical depth recommendations. 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?

For a tool with 3 parameters, 100% schema coverage, and no output schema, the description provides good context about behavior and usage. However, without annotations or output schema, it could better explain what the analysis returns (e.g., report format, success/failure indicators) and any authentication or system dependencies.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds some context about depth levels (e.g., 'quick' for triage, 'standard' sufficient for most files) but doesn't provide significant additional meaning beyond what's in the schema descriptions. This meets the baseline for high schema coverage.

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

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

The description clearly states the tool's purpose with specific verbs ('auto-analyze a file') and resources ('REMnux tools'), distinguishing it from siblings like 'get_file_info' (which likely provides basic metadata) or 'run_tool' (which requires manual tool selection). It specifies the automated workflow of file type detection followed by appropriate tool execution.

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

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

The description provides explicit guidance on when to use different depth levels: 'standard' for most files, 'deep' only when standard isn't sufficient, and 'quick' for fast triage. It also implicitly distinguishes from siblings by emphasizing automated analysis versus manual tool execution (e.g., 'run_tool').

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It describes the tool's function and output ('Returns a summary of installed vs missing tools'), which is adequate for a read-only operation, but does not cover aspects like performance, error handling, or system impact. No contradiction with annotations exists.

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

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

The description is a single, well-structured sentence that efficiently conveys the tool's purpose and output without unnecessary details. It is front-loaded with the core action and resource, making it easy to understand quickly.

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

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

Given the tool's simplicity (0 parameters, no annotations, no output schema), the description is complete enough for a basic read operation. However, it lacks details on output format or potential errors, which could be useful for an agent. It meets minimum viability but has gaps in behavioral 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 tool has 0 parameters, and schema description coverage is 100%, so no parameter documentation is needed. The description appropriately omits parameter details, focusing on the tool's purpose and output, which aligns with the baseline for zero parameters.

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

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

The description clearly states the specific action ('check which... are installed and available') and resource ('REMnux analysis tools'), distinguishing it from siblings like 'run_tool' or 'suggest_tools' that involve different operations on tools. It precisely defines the scope as checking installation status across all file type categories.

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 'suggest_tools' or 'get_tool_help', nor does it mention prerequisites or exclusions. It implies usage for checking tool availability but lacks explicit context for selection 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: the tool returns base64-encoded content, files are wrapped in password-protected archives by default to prevent AV/EDR triggers, and it can save directly to the host filesystem. This covers security implications and output handling well, though it doesn't mention error conditions or performance characteristics.

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 perfectly structured and concise. The first sentence states the core purpose and return format. Subsequent sentences provide essential behavioral context and parameter guidance. Every sentence earns its place with no wasted words, and information is front-loaded appropriately.

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 3-parameter tool with no annotations and no output schema, the description does an excellent job covering the tool's behavior, security implications, and parameter usage. The main gap is the lack of information about return values beyond 'base64-encoded content' - no details about error responses, success indicators, or output structure. This prevents a perfect score.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaningful context beyond the schema: it explains WHY the archive parameter exists ('to prevent AV/EDR triggers'), provides usage guidance ('Pass false for harmless files like text reports'), and clarifies the purpose of output_path ('to save directly to the host filesystem'). This elevates the score above baseline.

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

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

The description clearly states the action ('Download a file') and resource ('from the output directory'), distinguishing it from sibling tools like 'download_from_url' (which downloads from URLs) and 'list_files' (which only lists files). The specific verb+resource combination makes 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 description provides clear context for when to use the tool ('to retrieve analysis results') and guidance on when to modify default behavior ('Pass archive: false for harmless files like text reports'). However, it doesn't explicitly state when NOT to use it or name specific alternatives among siblings, keeping it from a perfect 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 full burden. It discloses key behavioral traits: file destination ('samples directory'), return format ('file metadata'), and special capabilities ('custom HTTP headers', 'thug mode for JavaScript execution'). However, it doesn't mention potential side effects like network usage, security implications, or error handling for failed downloads.

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 efficiently structured in two sentences: the first states core functionality and return value, the second adds advanced features. Every phrase adds value with zero redundancy or filler content.

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

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

For a 6-parameter tool with no annotations and no output schema, the description provides good context about what the tool does and its key features. However, it doesn't fully compensate for the lack of output schema by detailing the metadata structure (hashes, type, size) or addressing potential failure modes.

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

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

Schema description coverage is 100%, so the schema fully documents all 6 parameters. The description adds marginal value by mentioning 'custom HTTP headers' and 'optional thug mode', but these are already covered in the schema's parameter descriptions. No additional parameter semantics are provided beyond what's in the structured schema.

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

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

The description clearly states the action ('Download a file from a URL'), the destination ('into the samples directory for analysis'), and the return value ('Returns file metadata'). It distinguishes from sibling tools like 'download_file' by specifying URL-based downloading rather than local file 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 clear context for usage ('for analysis') and mentions 'thug mode for sites requiring JavaScript execution' as a specific use case. However, it doesn't explicitly state when NOT to use this tool or name alternatives among siblings like 'upload_from_host' for local file operations.

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

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

With no annotations, the description carries the full burden and provides good behavioral context: it discloses the automatic password-trying behavior for malware analysis, specifies the return value (list of extracted files), and implies mutation (extraction creates files). However, it doesn't mention error handling, rate limits, or permissions needed for file operations.

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

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

The description is two sentences, front-loaded with the core purpose, followed by behavioral details. Every sentence adds value: the first defines the tool, the second explains password handling and return value. Zero waste or redundancy.

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

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

Given no annotations and no output schema, the description does well: it covers the purpose, key behavior (password handling), and return value. However, it lacks details on error cases (e.g., unsupported formats, extraction failures) and doesn't specify the format of the returned list, leaving some gaps 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?

Schema description coverage is 100%, so the schema already documents all three parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema (e.g., it doesn't explain 'common malware passwords' in more detail). Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the specific action ('Extract files'), the resource ('from a compressed archive'), and the supported formats (.zip, .7z, .rar). It distinguishes from siblings like 'analyze_file' or 'get_file_info' by focusing on extraction rather than analysis or metadata 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 implies usage for extracting archives, including password-protected ones, but doesn't explicitly state when to use this vs. alternatives like 'download_file' for non-archives or 'extract_iocs' for specific content extraction. It provides some context (handles password-protected archives) but lacks explicit exclusions or comparisons.

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 effectively describes key behavioral traits: the tool returns deduplicated IOCs with confidence scores, mentions handling of low-confidence items via parameters, and implies processing of forensic/memory analysis data. It doesn't cover rate limits, authentication needs, or error conditions, but provides substantial operational context.

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

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

Three tightly constructed sentences with zero waste. The first states the core purpose, the second provides usage context and integration points, the third describes output characteristics. Every sentence earns its place by adding distinct value.

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

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

For a 3-parameter tool with no annotations and no output schema, the description provides strong context about what the tool does, when to use it, and what to expect in results. It could be more complete by explicitly describing the output format (beyond 'deduplicated IOCs with confidence scores') or error conditions, but covers the essential operational context well.

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

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

Schema description coverage is 100%, so the schema already fully documents all three parameters. The description mentions 'include_noise' indirectly ('low-confidence known-good IOCs') but doesn't add meaningful semantic context beyond what the schema provides. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the specific action ('extract') and resource ('IOCs from text'), listing concrete indicator types (IPs, domains, URLs, hashes, registry keys). It distinguishes from siblings by specifying its role in the workflow (processing output from run_tool or analyze_file) rather than performing analysis or file operations directly.

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 ('Pass output from run_tool or analyze_file to identify indicators') and mentions specific compatible data sources ('Works well with Volatility 3 plugin output'). However, it doesn't explicitly state when NOT to use it or name alternatives among siblings for similar extraction tasks.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions what information is retrieved but lacks details on permissions, rate limits, error handling, or whether this is a read-only operation. For a tool with no annotations, this leaves significant gaps in understanding its behavior.

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

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

The description is extremely concise and front-loaded, consisting of a single, clear sentence that directly states the tool's purpose without any unnecessary words. Every part of the sentence earns its place by specifying what is retrieved.

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

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

Given the lack of annotations and output schema, the description is incomplete. It doesn't cover behavioral aspects like safety, permissions, or output format, which are crucial for a tool that retrieves file metadata. This leaves the agent with insufficient context for reliable use.

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

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

The input schema has 100% description coverage, with the 'file' parameter clearly documented in the schema. The description adds no additional parameter semantics beyond what's in the schema, so it meets the baseline of 3 for adequate but not enhanced parameter explanation.

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

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

The description clearly states the tool's purpose with specific verbs ('Get') and resources ('file type, hashes, and basic metadata'), making it easy to understand what it does. However, it doesn't explicitly differentiate from sibling tools like 'analyze_file' or 'list_files', which might offer overlapping functionality.

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

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

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'analyze_file' and 'list_files' available, there's no indication of the specific context or scenarios where 'get_file_info' is preferred, leaving the agent to guess based on the tool name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It describes the output ('Returns the tool's --help output') and purpose, but lacks details on potential errors (e.g., if the tool doesn't exist), rate limits, or authentication needs. It adds some context but does not fully compensate for the absence of annotations.

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

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

The description is appropriately sized and front-loaded, with two concise sentences that directly state the purpose and output without unnecessary details. Every sentence earns its place by clarifying the action and result, making it efficient and easy to understand.

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

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

Given the tool's low complexity (1 parameter, no output schema, no annotations), the description is reasonably complete for its purpose. It explains what the tool does and what it returns, though it could benefit from more behavioral details (e.g., error handling) to fully compensate for the lack of annotations and output schema.

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

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

Schema description coverage is 100%, so the schema already documents the single parameter 'tool' with its description. The description adds minimal value beyond the schema by reinforcing that it returns help output, but does not provide additional semantics like examples of valid tool names or constraints beyond what the schema states.

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 ('Get usage help') and resource ('for a REMnux tool'), distinguishing it from siblings like 'run_tool' or 'check_tools' by focusing on documentation retrieval rather than execution or verification. It explicitly mentions what is returned ('the tool's --help output') to clarify the output format.

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

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

The description provides clear context for when to use this tool ('to understand available flags, options, and usage patterns'), implying it's for learning about tool capabilities before execution. However, it does not explicitly state when not to use it or name alternatives like 'run_tool' for actual tool execution, which would be helpful for differentiation.

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

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

No annotations are provided, so the description carries full burden. It states the action but lacks behavioral details: no mention of output format (e.g., list of filenames, metadata), pagination, permissions required, rate limits, or error conditions. This is a significant gap for a tool with no annotation coverage.

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

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

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

Given no annotations and no output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., file list format), error handling, or behavioral constraints. For a tool with 1 parameter and simple context, it should provide more context about output and usage.

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

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

Schema description coverage is 100%, with the parameter 'directory' fully documented in the schema (enum values, default). The description adds minimal value beyond the schema by mentioning 'samples or output directory', but doesn't explain semantics like what these directories represent or usage implications. Baseline 3 is appropriate given high schema coverage.

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

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

The description clearly states the verb ('List') and resource ('files'), and specifies the scope ('in samples or output directory'). It distinguishes from siblings like 'get_file_info' or 'download_file' by focusing on listing rather than detailed operations. However, it doesn't explicitly differentiate from all siblings (e.g., 'check_tools' is unrelated).

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, when-not scenarios, or compare with sibling tools like 'get_file_info' for metadata or 'download_file' for file retrieval. Usage is implied by the name but not explicitly 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It describes what the tool does (execute commands, support pipes, string extraction techniques) but doesn't mention important behavioral aspects like security implications, error handling, output format, or execution environment constraints that would be crucial for an agent to use it effectively.

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

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

The description is extremely concise with just two sentences, both of which earn their place. The first sentence states the core purpose and key capability (piped commands), while the second provides specific guidance for string extraction scenarios. No wasted words or redundant information.

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

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

For a command execution tool with 3 parameters, 100% schema coverage, but no annotations and no output schema, the description provides adequate basic information but lacks crucial context about what the tool returns, error conditions, security considerations, or execution environment details that would help an agent use it correctly.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters thoroughly. The description adds some value by providing command examples that illustrate how parameters might be used together, but doesn't add significant semantic meaning beyond what's already in the 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 clearly states the tool's purpose with specific verbs ('execute a command in REMnux') and distinguishes it from siblings by focusing on command execution rather than file analysis, extraction, or management. It provides concrete examples that illustrate its unique functionality.

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

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

The description offers clear context on when to use this tool (for executing commands in REMnux, including piped commands and string extraction), but doesn't explicitly state when not to use it or name specific alternatives among the sibling tools. The examples imply usage scenarios without formal exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively communicates key behavioral traits: that the tool only recommends tools without executing them, returns specific structured information (tool names, descriptions, depth tiers, expert hints), and serves a planning function. However, it doesn't mention potential limitations like file size constraints or error conditions.

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 efficiently structured in three sentences that each serve distinct purposes: stating the core function, providing usage guidance, and specifying return values. There's no wasted language, and the most important information (what the tool does) is front-loaded.

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

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

For a tool with no annotations and no output schema, the description does a good job covering the essential context: purpose, usage pattern, and return value structure. However, it could provide more detail about what 'expert analysis hints' contain or how the tool handles different file types, which would be helpful given the absence of structured output documentation.

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

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

With 100% schema description coverage, the baseline is 3. The description doesn't add significant parameter semantics beyond what's already in the schema descriptions for 'file' and 'depth'. It mentions file type detection which relates to the 'file' parameter but doesn't provide additional context about path resolution or depth tier implications.

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 ('Detect file type and return recommended REMnux analysis tools') and distinguishes it from sibling tools by explicitly contrasting with 'run_tool' for execution. It specifies the tool's role in planning analysis strategies rather than performing analysis directly.

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

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

The description provides explicit guidance on when to use this tool ('to plan an analysis strategy') and when to use alternatives ('then run individual tools with run_tool'). It clearly positions this as a planning/pre-analysis tool versus execution tools in the sibling set.

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 effectively describes key traits: the MCP server reads locally and transfers, file size limits (200MB), and the option to bypass upload. However, it doesn't mention error handling, permissions needed, or what happens on success/failure.

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

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

The description is well-structured and front-loaded with the core purpose. Each sentence adds value: first states the action, second explains the mechanism, third sets constraints, and fourth provides alternatives. 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?

For a tool with no annotations and no output schema, the description does a good job covering purpose, constraints, and alternatives. However, it lacks details on return values or error conditions, which would be helpful given the mutation nature of uploading files.

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

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

Schema description coverage is 100%, so the schema fully documents all parameters. The description adds no additional parameter-specific information beyond what's in the schema, such as format examples or edge cases. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the specific action ('Upload a file'), resource ('from the host filesystem to the samples directory'), and purpose ('for analysis'). It distinguishes from siblings like 'download_file' and 'download_from_url' by specifying the direction and source of transfer.

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

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

The description provides explicit guidance on when to use this tool (uploading for analysis) versus alternatives (bypassing upload by referencing absolute paths in analysis tools like 'get_file_info', 'analyze_file', or 'run_tool'). It also mentions the maximum file size constraint (200MB).

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