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

No annotations are provided, so the description carries full behavioral disclosure burden. It notes the optional nature of advancing time ('optionally advance'), but fails to disclose that the tool also retrieves data (the requestConcentrations/requestPathFlows boolean flags), potential side effects of adjustments, or idempotency characteristics. For a complex 30-parameter mutation tool, this is insufficient.

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

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

The description is a single, efficient sentence with no redundant words. It front-loads the action ('send control/weather adjustments') and qualifies it appropriately. While arguably too brief for the tool's complexity, it demonstrates good structural efficiency.

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 30 parameters with nested objects, 0% schema coverage, no output schema, and no annotations, the description is radically underspecified. It fails to explain what ContamX is, what data is returned by the request* flags, how the adjustment parameters interact, or prerequisite conditions for the required sessionId parameter.

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

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

With 0% schema description coverage across 30 complex parameters, the description attempts to compensate by categorizing parameters as 'control/weather adjustments' and 'advance' parameters. However, it completely omits semantics for the majority of parameters including zone temperature/humidity adjustments, flow requests, element adjustments, and timeout behavior. It provides minimal value beyond the schema structure.

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 sends 'control/weather adjustments' and optionally 'advance[s] ContamX to a new simulation time.' It distinguishes from sibling tools like start_contam_bridge_session by specifying 'running bridge session,' implying this operates on existing sessions rather than creating them. However, it does not explicitly name sibling alternatives or contrasts.

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 begins with 'Use this when you want to...' providing explicit usage intent, but lacks 'when-not' guidance or explicit mention of prerequisite steps (e.g., requiring start_contam_bridge_session first). The guidance is present but minimal for a tool with 30 parameters.

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 successfully discloses resource cleanup (releasing spawned process and socket) but fails to mention critical behavioral traits: whether the operation is irreversible/destructive, idempotent (safe to call twice), error conditions if session doesn't exist, or whether data is persisted before closure.

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 wasted words. However, the 'Use this when you want to...' framing is slightly meta and indirect; a more direct 'Ends an active session...' would front-load the action more effectively while being more 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?

Given this is a resource-terminating operation with no output schema, the description adequately covers the basic action but leaves gaps regarding safety implications and cleanup verification. The lack of parameter documentation and absence of destructive/safety annotations (which don't exist here) leaves the agent under-informed about operational risks.

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

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

The input schema has 0% description coverage for the sessionId parameter, and the description text adds no information about what constitutes a valid sessionId, its format, or how to obtain it. While the parameter name is somewhat self-explanatory, the description does not compensate for the lack of schema 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 explicitly states the tool 'end[s] an active ContamX bridge-mode session and release[s] the spawned process and socket.' This provides a specific verb (end/release), clear resource targets (session, process, socket), and distinguishes itself from siblings like start_contam_bridge_session and get_contam_bridge_session through its focus on termination and cleanup.

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 'Use this when you want to end...' provides explicit guidance on when to invoke the tool. However, it lacks explicit guidance on when NOT to use it (e.g., during active operations) or mention of alternatives like get_contam_bridge_session for merely checking status without closing.

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 specify whether the comparison is destructive, what output format to expect, performance characteristics, or what 'simcomp' specifically analyzes (e.g., numerical differences, file structure).

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 single-sentence structure is appropriately front-loaded, though slightly verbose with the phrase 'when you want to' rather than a direct imperative. No redundant information is present, but the sentence could be more direct.

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 4-parameter tool with 0% schema coverage, no annotations, and no output schema, the one-sentence description is inadequate. It omits critical context such as the comparison methodology, output format, and semantics for the optional verbosity and timeout parameters.

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

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

Schema description coverage is 0%, requiring the description to compensate. While 'two CONTAM .sim result files' implies the purpose of firstSimPath and secondSimPath, it provides no information about verbosity (range 0-3) or timeoutSeconds (range 1-600), leaving half the parameters undocumented.

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 compares 'two CONTAM .sim result files' using 'simcomp', providing specific verb, resource, and method. It implicitly distinguishes from siblings like run_contam_simulation or export_contam_sim_text by focusing on result comparison rather than generation or export.

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 'Use this when you want to compare' provides a basic when-to-use signal, but lacks explicit when-not-to-use guidance, prerequisites (e.g., files must exist), or named alternatives for different comparison scenarios.

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

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

No annotations are provided, so the description carries full disclosure burden. It states the tool 'inspects' but fails to clarify if it's read-only (likely) or produces side effects, and omits what the tool returns (file list? diagnostics report? missing references?).

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 is efficiently structured with the conditional clause first. However, it may be overly terse given the lack of schema documentation; an additional sentence explaining parameter relationships would improve utility without violating 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 4-parameter diagnostic tool with zero schema descriptions and no output schema, the description is incomplete. It covers the high-level purpose but lacks necessary details about how to use the parameters (e.g., relationship between projectPath and workingDirectory) or what diagnostic output to expect.

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

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

With 0% schema description coverage, the description must compensate for all 4 parameters. While 'referenced support files' hints at projectPath and 'nearby candidate matches' implies workingDirectory/searchRecursively, it provides no explicit parameter documentation, types, or constraints (e.g., maxMatchesPerReference is completely unaddressed).

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 trigger condition ('when a CONTAM project fails to run') and specific actions ('inspect referenced support files and nearby candidate matches'). It implicitly distinguishes from sibling 'inspect_contam_project' by focusing on failure diagnosis and candidate file resolution rather than general inspection.

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 when-to-use guidance ('Use this when...') with a specific failure condition. While it doesn't explicitly name alternatives, the context ('fails to run') naturally routes away from successful-run tools like 'run_contam_simulation' or general 'inspect_contam_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 provided, so description carries full burden. States what information is retrieved (installation location, executables) but omits disclosure of safety traits (read-only nature), idempotency, or specific output format/structure.

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 efficient sentence with zero waste. Front-loaded with both usage intent and purpose.

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

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

Adequate for a simple discovery tool with no parameters. Describes what is discovered, though would benefit from explicit return value description given the lack of 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?

Tool accepts zero parameters. Per rubric, 0 params = baseline 4.

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

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

States specific action (confirm/discover) and resource (CONTAM installation path and accessible executables). Clearly distinguishes from siblings which operate on specific projects or simulation sessions.

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 states when to use ('Use this when you need to confirm...'), providing clear contextual trigger. Lacks explicit alternatives or when-not-to-use guidance.

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

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

With no annotations provided, the description carries full disclosure burden. It successfully reveals that the underlying tool involves 'interactive prompts' requiring scripted responses, but fails to mention side effects (file creation?), timeout behavior implications, or what output format to expect.

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

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

The description is a single, efficient sentence with no redundant words. However, given the complete lack of schema documentation and annotations, the extreme brevity becomes a liability rather than a virtue, as critical information is omitted.

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 4 parameters, complex interactive behavior, and zero supporting documentation (no annotations, no output schema, 0% schema coverage), a one-sentence description is insufficient. It lacks parameter details, output specification, and error/timeout behavior explanation.

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

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

Schema coverage is 0%, requiring the description to fully compensate. While it conceptually alludes to '.sim file' and 'response-script text' (mapping loosely to simPath and responsesText), it completely omits responsesFilePath and timeoutSeconds, and doesn't explicitly map concepts to parameter names or formats.

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 core action (run simread on a .sim file) and the specific condition for use (having response-script text ready). However, it doesn't explicitly clarify what 'export' in the tool name refers to, leaving the exact output behavior slightly ambiguous.

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 when-to-use guidance ('Use this when you need to run simread... and you already know the response-script text'). It implicitly distinguishes from siblings like run_contam_simulation by emphasizing the prerequisite of knowing the interactive prompt responses, though it doesn't explicitly name the alternative 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. It successfully conveys the read-only nature through 'inspect' and adds valuable behavioral context by specifying 'last-known state' (implying potential staleness/caching). However, it omits error handling (what if the session isn't active?), side effects, and return format details.

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. While 'Use this when you want to' is slightly wordier than a direct verb construction ('Inspects...'), it avoids redundancy and earns its place by establishing usage context.

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

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

For a single-parameter inspection tool without output schema, the description adequately explains the core action but leaves gaps regarding error scenarios (inactive sessions) and return value structure. The 'last-known state' qualification adds necessary nuance, but without annotations or output schema, more behavioral 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 has 0% description coverage for the required 'sessionId' parameter. While the description mentions 'active ContamX bridge session,' it fails to explicitly document the parameter (e.g., expected format, where to obtain the ID from start_contam_bridge_session, or constraints). With zero schema coverage, the description inadequately compensates for the missing 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 uses specific verbs ('inspect') and resources ('metadata or last-known state of an active ContamX bridge session'). It implicitly distinguishes from siblings like start_contam_bridge_session and advance_contam_bridge_session by emphasizing read-only inspection versus lifecycle management, though it could explicitly name these contrasts.

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 'Use this when you want to...' provides basic contextual guidance for when to invoke the tool. However, it lacks explicit guidance on when NOT to use it (e.g., 'do not use if you need to modify state') and fails to reference sibling alternatives like inspect_contam_project for different resource types.

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

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

No annotations provided, so description carries full burden. It discloses the return type ('usage text') and implies read-only discovery behavior, but lacks explicit safety statements, format details, or side effect warnings. Adequate but 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?

Single sentence with zero waste. Front-loaded with the 'Use this when...' trigger, immediately followed by what is retrieved ('built-in command-line usage text'), for what target ('CONTAM executable'), and contextual purpose ('before deciding which 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?

Appropriate for tool complexity: explains what is returned despite lack of output schema, identifies the executable parameter, and establishes workflow context. Could improve by listing the specific supported executables or describing the text format returned.

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 has 0% description coverage with four enum values (contamx, prjup, simread, simcomp) undocumented. Description references 'CONTAM executable' which maps to the 'program' parameter, providing conceptual semantics, but fails to explain what each enum value represents or their differences.

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?

Excellent specificity: 'built-in command-line usage text' identifies the exact resource, 'CONTAM executable' identifies the target, and the help-seeking purpose clearly distinguishes this from action-oriented siblings like run_contam_simulation or upgrade_contam_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?

Strong guidance with 'Use this when...' framing and explicit workflow positioning ('before deciding which tool or arguments to use'). Would score 5 if it explicitly named specific sibling tools as alternatives to avoid, but effectively signals this is a prerequisite discovery step.

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 but only states it provides a 'quick structural summary.' It fails to specify return format, whether the operation is read-only (implied but not stated), potential errors, or what 'structural' encompasses (e.g., zones, flows, controls).

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, efficient sentence with no waste. It front-loads the usage context ('Use this when...') and immediately specifies both the action and target file type. Every word earns its place.

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

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

Given the tool's simplicity (single path parameter) and lack of output schema, the description adequately covers the basics but leaves gaps. It should specify what structural elements are summarized (e.g., building zones, airflow paths) and the output format since no output schema exists to document the return value.

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

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

Schema description coverage is 0%, leaving the projectPath parameter undocumented in the schema. The description compensates by specifying the target is a 'CONTAM .prj file,' giving clear semantic meaning to the path parameter despite the lack of schema 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 identifies the action (structural summary) and resource (CONTAM .prj file). It effectively distinguishes this from siblings like run_contam_simulation and update_contam_project_references by positioning it as a preliminary inspection 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?

It provides explicit timing guidance ('before editing or running it'), implicitly directing users toward diagnose_contam_project for troubleshooting or run_contam_simulation for execution. However, it doesn't explicitly contrast with diagnose_contam_project or mention when to prefer those alternatives.

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 disclosure burden. It offers minimal behavioral context beyond 'concise list' and doesn't specify safety (read-only vs. destructive), error conditions for invalid sessionIds, or return format structure. The mention of 'active' session hints at state requirements but remains superficial.

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 single-sentence structure is appropriately concise and front-loaded with the usage intent. No words are wasted, though the density leaves room for parameter documentation that isn't present.

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, the description partially compensates by specifying the return contains 'names and ids.' However, with zero parameter descriptions in the schema and no annotations, the description leaves significant gaps in understanding the category filtering options and required session prerequisites.

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

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

With 0% schema description coverage, the description fails to compensate adequately. While 'active ContamX bridge session' implicitly maps to the sessionId parameter, the category parameter (with 8 enum values) is completely undocumented in the description. The agent receives no guidance on what filtering by category entails or how to select valid values.

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

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

The description clearly identifies the tool retrieves a 'concise list of names and ids' (specific resource) from 'an active ContamX bridge session' (scope). It effectively distinguishes this entity-listing function from sibling session management tools like get_contam_bridge_session by emphasizing the listing of available entities 'inside' a session.

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 uses an explicit usage trigger ('Use this when you want...') which provides clear selection guidance. However, it lacks negative constraints (when not to use), prerequisites beyond the implied 'active' session status, or references to sibling alternatives for different use 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 of behavioral disclosure. It mentions 'directory tree' implying recursive capability, but fails to disclose whether the operation is read-only, what format results are returned in, pagination behavior, or performance characteristics for deep directory searches.

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 structure is appropriately concise and front-loaded with usage intent ('Use this when...'). No redundant or wasted language, though the 'when you want to' construction is slightly weaker than a direct verb.

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 4 parameters with 0% schema coverage and no output schema, the description is insufficient. It fails to document the maxResults parameter, does not explain the return value structure (file paths, metadata?), and omits behavioral constraints necessary for a filesystem traversal 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?

With 0% schema description coverage, the description must compensate for all four parameters. It implicitly covers 'directory' and 'recursive' via 'directory tree', and hints at 'extensions' through 'project files, result files, or weather files', but provides no information about 'maxResults' or parameter formats/validation rules.

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 (lists) CONTAM project, result, and weather files within a directory tree. It uses specific verbs and resources that distinguish it from siblings like run_contam_simulation or list_contam_bridge_entities (which lists session entities, not filesystem files).

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 temporal context ('before running a simulation') establishing when to use the tool. However, it lacks guidance on when NOT to use it (e.g., if files are already loaded in a bridge session) and does not mention alternatives like list_contam_bridge_entities for already-loaded resources.

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 successfully discloses that files are generated/collected and mentions the external ContamX engine. However, it omits critical behavioral details: timeout behavior, whether file collection is destructive (overwrites), bridge integration semantics, and error handling for failed simulations.

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 18 words with no redundancy. However, it uses the indirect phrasing 'Use this when you want to' instead of the more direct imperative style ('Validates or runs...'), which slightly weakens the front-loading.

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 this is a complex simulation tool with 7 parameters (including bridge integration and timeout controls), no output schema, and no annotations, the description is insufficient. It lacks explanations for the majority of parameters and doesn't describe the return value or file collection mechanism despite the complexity of the domain.

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

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

The schema has 0% description coverage across 7 parameters. The description only implicitly hints at 'testInputOnly' through the word 'validate', but provides no semantics for 'timeoutSeconds', 'workingDirectory', or the three bridge-related parameters ('bridgeAddress', 'windFromBridge', 'volumeFlowBridge'). It fails to compensate for the schema gap.

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 ('validate or run'), the specific resource ('CONTAM .prj model'), the engine used ('ContamX'), and the side effect ('collect the generated files'). However, it doesn't explicitly distinguish this execution tool from siblings like diagnose_contam_project or inspect_contam_project.

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

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

The phrase 'Use this when you want to' provides implied context, and it distinguishes between 'validate' and 'run' modes. However, it lacks explicit guidance on when to choose validation over full simulation, and doesn't mention alternatives like diagnose_contam_project for error checking without execution.

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 successfully conveys the session persistence aspect ('keep an interactive socket session open across multiple MCP calls'), but omits critical lifecycle information such as the need to close the session, what happens when timeoutSeconds is reached, or what the tool returns (likely a session identifier).

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 redundant words. It efficiently combines purpose and behavioral context, though the 'Use this when you want to...' construction is slightly verbose compared to direct imperative descriptions.

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

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

Given the complexity of session management (sockets, persistence, timeouts) and the lack of both output schema and annotations, the description is insufficient. It omits what the tool returns (session handle?), cleanup obligations (sibling 'close_contam_bridge_session'), and parameter details necessary for correct invocation.

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

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

The schema has 0% description coverage, requiring the description to compensate for all 5 parameters. While 'bridge mode' provides context for 'windFromBridge' and 'volumeFlowBridge', the description fails to explain 'workingDirectory', 'timeoutSeconds', or the format/expectations for 'projectPath', leaving most parameters undocumented.

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 launches 'ContamX in bridge mode' and establishes the core resource being managed (an interactive socket session). The mention of 'bridge mode' and 'start' effectively distinguishes it from siblings like 'get_contam_bridge_session' or 'run_contam_simulation', though it assumes domain knowledge of what ContamX is.

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

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

The description includes an explicit 'Use this when you want to...' clause that signals the intent (persistent multi-call session). However, it lacks explicit alternatives (e.g., when to use 'run_contam_simulation' instead) or prerequisites (e.g., requiring ContamX installation), which are important given the sibling tools available.

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. While 'edit' implies mutation, the description fails to mention critical safety aspects: the existence of the createBackup parameter, whether invalid file paths are validated, if the operation is atomic, or side effects on simulation state. For a tool that mutates project files, this is a significant gap.

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

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

The description is a single, front-loaded sentence with no redundancy. However, given the complexity (8 undocumented parameters) and mutation risk, it is arguably underspecified rather than optimally 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?

Given 8 parameters with 0% schema coverage, no annotations, and no output schema, the description is inadequate. It fails to explain the majority of parameters, the return value, error conditions, or backup behavior necessary for safely invoking a file-mutation operation.

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

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

Schema description coverage is 0%, requiring the description to compensate. It implicitly maps 'weather' and 'contaminant' to weatherFile and contaminantFile, and vaguely groups the remaining file parameters as 'library files.' However, it completely omits projectPath (required) and createBackup (boolean), and provides no guidance on parameter formats, valid paths, or that null values likely remove references.

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

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

The description states the tool edits 'referenced weather, contaminant, or library files inside a CONTAM .prj file,' which identifies the resource and action. However, it is ambiguous whether 'edit the referenced files' means modifying the external files' contents or updating the references/pointers within the project file (the latter is correct based on the tool name). It does not explicitly differentiate from siblings like inspect_contam_project or upgrade_contam_project.

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

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

The description provides a clear 'Use this when...' trigger for editing specific file references. However, it lacks guidance on when NOT to use the tool (e.g., for editing project geometry) and does not mention alternatives like inspect_contam_project for viewing current references versus updating them.

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 the external tool 'prjup' but fails to disclose critical mutation behaviors: whether the upgrade is destructive, what happens if the process fails, whether the original file is preserved or overwritten, or the significance of the createBackup parameter.

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 structure with no redundant information. The 'Use this when...' construction is slightly more verbose than imperative mood ('Upgrade...'), but remains efficient and front-loaded with the trigger condition.

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 file-mutation tool with four undocumented parameters and no output schema, the description is insufficient. It omits error handling, return value description, and behavioral details for half the parameters, leaving significant operational 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?

With 0% schema description coverage, the description inadequately compensates. It implicitly maps 'older .prj file' to projectPath and 'newer format' to targetVersion, but provides no semantic guidance for createBackup (despite its behavioral importance) or timeoutSeconds.

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 (upgrade), resource (older .prj file), target state (newer CONTAM project format), and mechanism (prjup). It effectively distinguishes from sibling 'update_contam_project_references' through the specific terminology of 'upgrade' and 'format' versus 'update' and 'references'.

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 when-to-use guidance ('Use this when you need to upgrade...'), but lacks when-not-to-use guidance, prerequisites (e.g., file permissions), or explicit references to alternatives like update_contam_project_references for different use cases.

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