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 says 'bounded' but does not explain the bound, error handling, or return format. Even though 'read' implies a safe operation, it does not confirm whether the tool is read-only or describe what happens with invalid targets.

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, front-loading the verb and resource. It is appropriately concise, though it could benefit from a brief clause about parameter usage 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?

Despite having only 2 parameters and an output schema, the description leaves critical gaps: it does not clarify what 'target' should be, what 'bounded' means, or what the output contains. It is insufficient for an agent to correctly select and invoke this tool without additional information.

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, and the tool description does not explain the meaning of 'target' or 'max_chars'. While 'max_chars' is somewhat inferable, 'target' is ambiguous—it could be a file path, symbol name, or query. The description fails to 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 uses a specific verb ('Read') and identifies the resource as 'bounded static ChimeraX API documentation content', making the core purpose clear. It does not explicitly differentiate from sibling tools like chimerax_api_search, but the name and wording imply a distinction between reading content and searching it.

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 chimerax_api_search or chimerax_guide. The description lacks any context about prerequisites, typical use cases, or situations where another tool would be more appropriate.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It reveals that the search operates on static metadata and can work offline via a packaged index, but does not explicitly confirm read-only behavior, error conditions, or other operational nuances. The output schema helps cover return values.

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

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

The description is two concise sentences with no fluff. The first sentence states the purpose, and the second adds a useful operational note about the packaged index. 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?

For a moderate-complexity search tool with an output schema, the description gives a clear high-level overview but lacks parameter semantics and usage guidance relative to the many sibling tools. The context is adequate but not complete, leaving gaps in how to effectively invoke the tool.

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

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

Schema description coverage is 0% and the description provides no explanation of the parameters (query, kind, limit). While 'query' and 'limit' are self-explanatory, 'kind' with default 'all' is ambiguous, and the description fails to clarify what kinds are searchable.

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 'Search' and clearly specifies the resource as 'static ChimeraX command/tutorial/Python API metadata'. This distinguishes it from sibling tools like chimerax_api_read (read) and chimerax_script_recipe_search (recipes), making its 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 implies usage for searching static metadata and mentions it works without optional local skills via a packaged index, which hints at a fallback use case. However, it does not explicitly state when to use this tool versus alternatives, nor does it name any exclusions or alternative 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 discloses the destructive nature, the meaning of the age threshold, and the special case of 0 to delete all. It also states the return value. It does not mention irreversibility or permission requirements, but the core behavior is well covered.

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

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

The description is concise and well-structured, starting with a clear purpose, followed by the parameter explanation and return value. Every sentence adds required information without redundancy.

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

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

Given the tool's simplicity (one parameter, no annotations, output schema present), the description covers purpose, parameter behavior, and return values completely. An agent can invoke it correctly without needing additional 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 only lists the parameter type and default with no description. The description fully explains the parameter's meaning: delete screenshots older than this many days, with the explicit note that 0 deletes all. This fully compensates for the 0% 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 opens with a clear, specific action: 'Delete old screenshots to free up disk space.' It names the exact resource (old screenshots) and the purpose (freeing space), making it distinct from sibling tools like listing or taking screenshots.

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 clear usage context: use this tool when you need to free disk space by deleting old screenshots. It does not explicitly name alternatives or exclusions, but the purpose and trigger are clear enough for an agent to decide when to invoke it.

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

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

With no annotations, the description must disclose behavioral traits. It only states the action without noting side effects such as model removal from the session or irreversibility, which are important for a 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 brief and well-structured with Args and Returns sections. It is front-loaded with the core action and avoids unnecessary verbosity, though it could be more informative while maintaining 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?

Despite the tool's simplicity and the presence of an output schema, the description lacks essential context about model_spec usage and potential side effects. It is not complete enough for an agent to invoke the tool reliably without additional inference.

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%, and the description only repeats the parameter name and default from the schema. It does not explain valid values or formats for model_spec (e.g., 'all', '#1', ranges), leaving the agent with insufficient 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 a specific verb ('close') and resource ('models in ChimeraX'), making the tool's purpose unambiguous. It clearly distinguishes from sibling tools like chimerax_stop, which likely targets 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?

No guidance is provided on when to use this tool versus alternatives. There is no mention of scenarios where this should be preferred over chimerax_stop, chimerax_reset, or other related 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 explicitly states that it returns the path if found or an error message if not, which is transparent for a detection operation. It implies a read-only action, though it does not explicitly mention lack of side effects.

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

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

The description is two sentences, front-loaded with the verb and purpose. It includes only essential information about the return value, with no redundant or extraneous 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 simple parameterless detection tool, the description fully covers the purpose, expected outcome, and failure mode. The output schema likely supplies any additional format details, so the description 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 tool accepts zero parameters, and schema coverage is 100% (empty schema). Baseline 4 applies since there are no parameters, and the description adds no parameter details because 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 starts with a specific verb-resource pair 'Detect ChimeraX installation' and clearly distinguishes its function from sibling tools by focusing on installation detection. It also states the return value (path or error), 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?

There is no guidance on when to use this tool versus alternatives like chimerax_status or chimerax_start. The description only explains what it does without indicating appropriate conditions or exclusions, so the agent must 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?

No annotations are present, so the description carries the full burden. It discloses the tool's behavioral role (returning workflow guidance), its content (how to avoid direct shell launches, how to start/inspect/control ChimeraX), and implies it is a safe, read-only informational tool. This is adequate for a guide 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 two sentences long, front-loaded with the primary action, and every clause adds value. It avoids unnecessary detail and is perfectly scoped for a guide 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 has an output schema, so the description needn't explain return values. It covers the essential context: when to call, why it matters (avoiding MCP bypass), and what topics the workflow covers. This is complete for a no-parameter guide tool.

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

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

The input schema has zero parameters, so the baseline is 4. The description appropriately makes no attempt to document parameters, and no parameter semantics 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 opens with a clear verb and resource: 'Return the recommended workflow for AI clients using ChimeraX MCP.' It specifies the tool's exact role and clearly differentiates it from siblings that perform actual ChimeraX operations (start, stop, open, etc.).

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: 'Call this before operating ChimeraX from an AI client.' It doesn't name alternatives or exclusions, but as a foundational meta-guide with no sibling counterpart, this is sufficient.

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?

As a list operation, the behavior is inherently read-only and the description discloses the return contents (path, size, modification time). With no annotations provided, it carries the transparency burden adequately by stating the output details and avoiding any implication of mutation or deletion.

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 short sentences with the main action front-loaded ('List all screenshots...'). Every word earns its place, and the return fields are listed efficiently 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?

This is a simple zero-parameter read-only list with an output schema present. The description states both the scope ('all screenshots saved by chimerax-mcp') and the key return fields, which is fully sufficient for this complexity level.

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 the baseline is 4. The description appropriately does not attempt to document parameters that do not exist.

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 'List all screenshots saved by chimerax-mcp', using a specific verb and resource. It is clearly distinct from sibling tools like chimerax_screenshot (capture) and chimerax_cleanup_screenshots (delete).

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—listing screenshots saved by this MCP—and implicitly indicates a read-only management operation. It does not explicitly name alternatives or when-not-to-use, but for a simple zero-parameter list, no exclusions are necessary.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. While 'Get list' implies a read-only operation, the description does not state whether a ChimeraX session must be running, what happens if no models exist, or any error conditions. It adds no behavioral context beyond the basic return value, which is insufficient 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 appropriately brief and front-loaded, stating the core action in the first sentence. The subsequent 'Returns:' line is slightly redundant but not verbose. Every sentence is short and purposeful, though the return statement could have been omitted or expanded with 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?

Given the tool's simplicity (0 parameters) and the presence of an output schema, the description is largely sufficient. It lacks any mention of session prerequisites or potential failure modes, but for a straightforward list-query tool with an output schema, the core purpose is covered. The absence of usage guidance is the main gap, but it is minor for this 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 tool has zero parameters, so the schema description coverage is trivially 100%. According to the rubric, 0 parameters warrant a baseline of 4. The description adds no parameter-related information, but none is needed given the absence of parameters.

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

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

The description clearly states the tool's action and resource: 'Get list of currently open models in ChimeraX.' It uses a specific verb (Get) and resource (models), which distinguishes it from sibling tools like chimerax_status or chimerax_open. The purpose is unambiguous and immediately understandable.

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 when-to-use guidance or alternatives. It does not mention when this tool should be preferred over siblings like chimerax_status or chimerax_api_read. There is no exclusion criteria or context beyond the basic action, leaving the agent without direction on selecting this tool among similar ones.

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 says 'Result of the open command' without detailing potential side effects (e.g., loading into the current session, overwriting existing models, network access for PDB fetch, or error handling). This is insufficient for an agent to fully anticipate the tool's impact.

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

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

The description is concise and well-structured with a summary, Args, and Returns sections. The Returns line is generic and adds little value, but the overall layout is efficient and front-loaded with the core purpose.

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

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

For a one-parameter tool, the input semantics are well covered, and the presence of an output schema means return details are not required. However, without annotations, the description omits behavioral context about session state changes, network dependencies, or failure modes, making it only moderately complete.

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

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

The input schema has zero description coverage for the only parameter. The description compensates fully by defining 'path_or_id' as a local file path, a PDB ID (with example '1a0s'), or a URL, giving clear semantics that the schema lacks.

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: 'Open a structure file or fetch from PDB.' It specifies the resource (structure files, PDB entries) and the verb (open/fetch), and it is distinct from sibling tools like 'chimerax_models' (list models) and 'chimerax_run' (execute commands).

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 basic context about what the tool does (open files or fetch PDB) but does not explicitly state when to use it versus alternatives such as 'chimerax_session_open' or 'chimerax_view'. No exclusions, prerequisites, or preference conditions are mentioned, leaving usage to be implied from the name.

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 says the listing is 'live', which hints at querying a running session, but it does not disclose whether this is read-only, what happens if the symbol doesn't exist, or any side effects. With no annotations, the description carries the full burden and falls short.

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 conveys the core purpose without padding. It is front-loaded with the 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?

The tool has 3 parameters and no annotations, but does have an output schema. The description clearly states the primary action but lacks usage guidance and parameter details. For a simple listing tool this is borderline adequate, but gaps prevent a higher 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?

The description mentions 'for a symbol', providing minimal context for the `symbol` parameter, but does not explain `limit` or `filter`. Schema description coverage is 0%, so the description fails to compensate for the undocumented 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 ('List') and resource ('ChimeraX Python API attributes') for a symbol, clearly indicating a directory-listing operation. It doesn't explicitly distinguish from sibling tools like chimerax_api_search or chimerax_python_inspect, so it's clear but not fully differentiated.

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. There are no example scenarios, prerequisites, or exclusions, leaving the agent to infer 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 bears the full burden of behavioral disclosure. 'Inspect' suggests a read-only operation, but it does not explicitly state that it is non-destructive, what side effects it may have, or what kind of response it returns. The description is too minimal to provide meaningful 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, front-loaded sentence with no filler or redundant information. It is appropriately concise, though the extreme brevity leaves little room for needed details; still, this dimension is about efficiency, which it handles well.

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 three parameters, zero schema descriptions, no annotations, and sibling tools that need differentiation, the one-line description is insufficient. It does not explain the optional parameters, return behavior, or how it compares to related tools, leaving the agent without enough context 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 0%, so the description must compensate. It adds some meaning by indicating that 'symbol' refers to a ChimeraX Python API symbol, but it does not explain the other two parameters ('include_dir', 'max_doc_chars') at all. This leaves significant gaps in parameter understanding.

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 'Inspect a live ChimeraX Python API symbol' uses a specific verb ('inspect') and identifies the resource ('live ChimeraX Python API symbol'). It clearly distinguishes this tool from siblings like chimerax_api_read or chimerax_python_dir by emphasizing 'live' runtime 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?

The word 'live' implies this tool is intended for inspecting a runtime symbol in the active ChimeraX session, offering some usage context. However, there is no explicit guidance on when to use this tool versus alternatives, nor 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly lists the operations performed: hides pseudobonds, atoms, and surfaces, shows cartoon representation, applies heteroatom coloring and soft lighting, and fits the view. It also clearly states the return value (summary of reset commands executed), which adds transparency about output. However, it does not mention potential side effects like whether the session state is permanently altered or if the camera/scene is fully reset beyond what is listed.

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

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

The description is concise and well-structured: a one-sentence summary followed by a bulleted list of actions and a return value section. Every sentence provides useful information without redundancy. It is appropriately sized for a simple no-parameter 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 (no parameters, clear reset operation) and the presence of an output schema, the description is complete. It covers the action, the visual result, and the return value. There is no missing critical context that would prevent an agent from using 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 tool has zero parameters, and the schema is an empty object with 100% coverage. Since there are no parameters to explain, the description does not need to add parameter semantics. The baseline for zero parameters is 4, and the description is consistent with that—it doesn't introduce any parameter-related ambiguity.

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

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

The description clearly states the tool's purpose with a specific verb ('Reset') and resource ('display'), and details the exact actions taken: hiding pseudobonds, atoms, and surfaces, then showing cartoon representation with heteroatom coloring, soft lighting, and view fitting. This distinguishes it from siblings like chimerax_view or chimerax_turn by focusing on resetting to a clean default state.

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 of what the tool does but does not explicitly state when to use it versus alternatives. It implies usage for resetting the display to a clean state, but there is no mention of exclusions or alternative tools for specific scenarios. For example, it doesn't say 'use this instead of chimerax_view' or 'when you need to clear the scene'.

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 reveals that HTML is passed through with is_html=True, warns about trusted input, notes that the title is escaped, and explains save/overwrite behavior. This is strong disclosure for a write operation.

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

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

The description is well-structured: a one-sentence summary, a security note, an Args block, and a Returns line. Every sentence is purposeful, and there is no redundant or filler text.

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 5 parameters and no annotations, the description fully covers the purpose, security implications, parameter semantics, and return status. The presence of an output schema means detailed return-value descriptions are unnecessary. This is complete for a tool of this 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?

Schema description coverage is 0%, so the description fully compensates by defining all five parameters: html, level (with allowed values), title, save_html_path, and overwrite. It adds meaning beyond the schema's types and defaults, such as the escaping behavior of title and the replacement logic for overwrite.

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 begins with a specific action verb 'Write' and a clear resource 'the ChimeraX Log', and further specifies 'trusted HTML'. This clearly distinguishes it from siblings like chimerax_run or chimerax_rich_report by identifying the exact destination and content type.

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 security note 'Only use with trusted input' provides an explicit usage condition. The overall context clearly indicates this tool is for writing rich HTML to the ChimeraX log, but it does not explicitly name alternative tools or state when not to use it. Still, the context is sufficiently 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It explicitly states that plain text fields are escaped, raw html blocks are inserted as-is, and explains the difference between external_link_target modes. It also documents overwrite behavior and the return status, giving a complete picture of side effects and trust boundaries.

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 with a leading summary sentence followed by Args and Returns sections. Despite covering 9 parameters, it remains focused and avoids fluff. Each parameter explanation is concise and meaningful, and the security-relevant notes are included without excess.

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 covers the tool's purpose, all parameters, security behavior, and return value. For a write operation without annotations, it is quite complete. The only notable gap is the under-specified 'blocks' parameter, which prevents a perfect score. The existence of an output schema is noted, but the description still provides the essential return status.

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 schema description coverage at 0%, the description is the only source of parameter meaning. It explains all 9 parameters in the Args section, adding clarity about defaults, optionality, and behavior. However, 'blocks: Ordered rich content blocks' is vague and does not explain the structure or possible values of these blocks, leaving some ambiguity.

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 opens with a specific verb+resource: 'Compose a themed rich HTML report for the ChimeraX Log.' This clearly distinguishes it from sibling tools like chimerax_rich_log and chimerax_structure_report, and the title reinforces the intent.

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 by specifying this is for composing a themed rich HTML report for the ChimeraX Log. It does not explicitly name alternative tools or state when not to use it, but the context is strong enough to infer its primary use. The parameter-level details also clarify behavior, such as how external links are handled.

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 and does well by warning about arbitrary command execution including Python via 'runscript' and shell commands via 'shell', plus stating the return type. It does not elaborate on other potential side effects or state changes, but the security warning is valuable and goes beyond a basic read/write hint.

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 compact and well-structured: a one-sentence purpose, a clear preference statement, a critical security note, and an Args/Returns block. Every sentence earns its place, 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?

Given the tool's generic nature and the presence of an output schema, the description covers the core aspects: purpose, usage preference, security, parameter, and return value. It lacks explicit mention of prerequisites like a running ChimeraX session, but given sibling tools include chimerax_start and chimerax_status, 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 zero parameter descriptions, but the tool description compensates thoroughly by explaining the 'command' parameter as 'The ChimeraX command to execute' with two illustrative examples. This adds essential meaning beyond the bare schema for the single string parameter.

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

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

The description clearly states 'Execute a ChimeraX command through the MCP-managed REST connection' and provides concrete examples like 'open 1a0s' and 'color red'. This specific verb+resource combination distinguishes it from sibling tools that target narrower operations such as chimerax_open or chimerax_screenshot.

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 'Prefer this tool over shelling out to ChimeraX for routine commands', offering clear usage context. However, it does not mention when to avoid this tool in favor of dedicated sibling tools (e.g., using chimerax_open for opening structures) or that a running session may be required, so exclusions are missing.

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

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

With no annotations, the description fully discloses the behavior: it saves an image, returns the path, specifies the default directory, and notes that a failed view command still allows capture. This adequately covers the operation's side effects and edge cases.

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 with clear Args and Returns sections, using concise bullet-like text. No unnecessary fluff; all information is actionable.

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 the presence of an output schema, the description covers the tool's purpose, parameters, return value, and post-capture workflow. It is self-contained and sufficient for an agent to use the tool effectively.

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

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

Although the schema provides little to no parameter descriptions, the tool description compensates fully. Each parameter (width, height, format, output_path, auto_fit) is explained with defaults, constraints, and behavior, giving the agent everything needed to invoke correctly.

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 opens with a specific verb+resource: 'Capture a screenshot of the current ChimeraX view.' It clearly conveys the action and scope. However, it does not distinguish this from the sibling chimerax_tool_screenshot, so it misses the top score for 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?

The description provides clear usage guidance, including the instruction to use the Read tool on the returned path and explaining the auto_fit behavior. It does not explicitly discuss when to prefer this over sibling screenshot tools but gives enough context for typical use.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It only says 'Read', which is too vague; it doesn't state whether this is read-only, what happens if the recipe_id is missing, whether it returns the script content, or any side effects. The description provides essentially no behavioral context beyond the verb.

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 with no fluff. It is appropriately concise for a simple read operation, though the lack of detail prevents a perfect 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?

Despite having an output schema, the description is incomplete for a tool with three parameters, no annotations, and zero schema descriptions. It doesn't explain what a recipe is, how the ID is obtained, what max_chars and include_script control, or any error behavior. The complexity is moderate, and the description does not sufficiently compensate.

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%, so the description must compensate. The phrase 'by ID' provides meaning for recipe_id, but max_chars and include_script are completely unexplained in both the schema and the description. The description adds minimal value for one parameter and none for the other two.

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 'Read a bundled ChimeraX Python script recipe by ID' clearly identifies the action (read), the resource (bundled ChimeraX Python script recipe), and the access pattern (by ID). It is distinguishable from sibling tools like chimerax_script_recipe_search, though it does not explicitly name alternatives, which keeps it from a 5.

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. The description implies that the user must already have a recipe_id, but it doesn't mention that the ID might come from a search tool or provide any exclusion criteria. This is minimal to 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?

With no annotations provided, the description carries full burden for behavioral disclosure. It adds a critical safety trait: this tool does not execute Python code, and describes recipes as static. However, it does not mention whether the operation is read-only, what happens with no results, or any pagination/performance details, so transparency is limited.

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, with the purpose front-loaded in the first sentence and a clarifying note in the second. Every sentence adds value with no 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?

The tool is relatively simple and has an output schema, but the description fails to explain the purpose of the 'category' and 'output_kind' parameters, and does not clarify how 'limit' interacts with the query. Given the 0% schema coverage, the description is not complete enough for an agent to select correct parameter values 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?

The input schema has 0% description coverage, and the description does not explain any of the parameters (query, limit, category, output_kind). The agent is left to infer meanings from names alone. This is a significant gap that the description fails to fill.

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 ('Search') and resource ('bundled ChimeraX Python script recipes'), and clearly distinguishes itself from execution tools by stating 'does not execute Python code.' This effectively differentiates it from sibling tools like chimerax_run and chimerax_script_recipe_read.

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 'Recipes are static examples for trusted runscript workflows' implies a read-only, non-executing use case. The explicit exclusion 'does not execute Python code' tells the agent when not to use this tool, but it does not name alternative tools (e.g., chimerax_run), so it lacks fully explicit 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?

With no annotations, the description must disclose behavioral traits. It only states 'Open a saved ChimeraX session' and mentions the return value, but does not describe side effects, requirements (e.g., running ChimeraX instance), state changes, or error conditions. This is insufficient for a tool that likely modifies the application state.

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

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

The description is concise and well-structured: a one-sentence purpose statement followed by clear Args and Returns sections. No unnecessary information is included.

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?

While the tool is simple and has an output schema, the description lacks usage guidelines and behavioral context (no annotations, no alternatives). It is adequate for understanding what the tool does but not fully complete for an agent to select and invoke it appropriately in all situations.

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 adds meaning to the sole parameter 'path' by specifying it as a path to a .cxs session file, which is not present in the schema. This compensates for the 0% schema description coverage and clarifies the expected input format.

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 opens a saved ChimeraX session file (.cxs), which is a specific verb+resource. It does not explicitly contrast with sibling tools like chimerax_open or chimerax_session_save, but the focus on 'session' makes the purpose clear enough for 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 such as chimerax_open or chimerax_session_save. There is no mention of prerequisites, scenarios, or exclusions, leaving the agent without decision-making 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, the description carries the full burden of behavioral disclosure. It mentions that the command saves a session and returns a result, but it does not disclose whether existing files are overwritten, whether a running ChimeraX instance is required, or what specific side effects occur. This is a significant gap for a mutation-like save operation.

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

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

The description is extremely concise, consisting of a single purpose sentence plus clearly labeled Args and Returns sections. Every word earns its place with no filler or redundancy.

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

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

For a simple one-parameter tool, the description covers purpose, parameter, and return value. However, it omits any context about prerequisites (e.g., ChimeraX must be running) or behavioral edge cases (e.g., file overwrite behavior), which would be expected given the lack of annotations. It is minimally complete but not thorough.

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 only lists 'path' as a string with no description, so schema coverage is 0%. The description compensates by explaining that 'path' is the file path for a .cxs session file, adding crucial meaning. It does not exhaustively cover all aspects (e.g., absolute vs relative paths), but it provides the core semantic meaning.

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 'Save' and the resource 'current ChimeraX session', making the tool's purpose unambiguous. It does not explicitly distinguish from sibling tools like chimerax_session_open, but the save/open distinction is clear from the verb.

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 usage is implied: users should call this when they want to save the current session to a file. However, there is no explicit guidance on when to use this tool versus alternatives or any exclusions, so it only meets the 'implied usage' criterion.

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

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

With no annotations, the description fully carries the behavioral burden. It discloses that the tool enables and tracks REST control, supports background startup with immediate return, and explains why include_version defaults to false: "to avoid writing version checks to the ChimeraX Log." This goes beyond a simple 'start' command and covers side effects and state implications.

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 with an introductory purpose sentence, a clear Args list, and a Returns note. Every sentence adds value; no filler or redundant content. The parameter explanations are necessary and appropriately detailed for the tool's complexity.

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

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

Given the tool has 5 parameters, no annotations, and an output schema, the description covers all necessary aspects: purpose, usage context, parameter semantics, background behavior, and return status. It also references a sibling tool for follow-up status checks. The presence of an output schema reduces the need to detail return values, but the description still provides a sufficient summary: "Status of the startup attempt."

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%, so the description is the sole source of parameter meaning. The Args section meticulously explains each of the 5 parameters, including defaults, behavioral impact (e.g., "If True, return immediately and let ChimeraX start in background"), and rationale for defaults (e.g., include_version). This fully compensates for the schema's lack of 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 starts with a specific verb and resource: "Start ChimeraX with REST API enabled." It clearly distinguishes from siblings like chimerax_stop and chimerax_status by explaining the unique purpose of launching the application and enabling REST control. The additional note about the MCP server tracking REST control reinforces the tool's distinctive role.

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

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

The description explicitly provides usage guidance: "AI clients should use this tool instead of launching ChimeraX directly from a shell, so the MCP server can enable and track REST control." It also mentions an alternative follow-up path with "Use chimerax_status to check if ready" for background startup, which helps the agent choose the correct sequence of 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, and it does well by disclosing the optional version check side effect (writing to the ChimeraX Log) and the default false to avoid it. It also describes the return value ('Connection status and version if running'). However, it does not explicitly state whether the status check itself is read-only or has any side effects, leaving a slight gap in transparency.

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

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

The description is concise, with a clear first sentence stating the purpose, followed by essential usage guidance, args, and returns sections. Every sentence earns its place with no redundant content, and the structure is well-organized and readable.

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), the description covers all essential aspects: purpose, when to call, parameter behavior, and return type. The existence of an output schema covers detailed return structure, so the text description is sufficiently complete 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 coverage is 0%, so the description fully compensates by explaining the sole parameter (include_version) with its effect, default, and rationale. The description provides complete semantic meaning that the schema lacks, making this exemplary.

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: 'Check if ChimeraX REST server is running.' It uses a specific verb ('check') and resource ('ChimeraX REST server'), and mentions the optional version inclusion. This distinguishes it from sibling tools like chimerax_start or chimerax_detect, as it is explicitly positioned as a pre-check before other control tools.

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

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

The description provides explicit guidance on when to use the tool: 'AI clients should call this before chimerax_start or other control tools rather than probing ChimeraX by launching it directly.' It also explains the default behavior of include_version to avoid writing to the ChimeraX Log, offering clear context for making the right call.

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 stop action and return status, but it does not disclose potential side effects, whether the operation is reversible, or how it affects the server/session state. For a destructive lifecycle operation, 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 extremely concise and front-loaded: it states the core action in the opening line and then lists the return value in a clear 'Returns:' section. Every word earns its place 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?

For a zero-parameter lifecycle tool with an output schema present, the description adequately covers the primary purpose and return value. It lacks deeper behavioral context (like consequences of stopping), but given the simplicity of the tool, the description is largely 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 tool has zero parameters, so the baseline for this dimension is 4. The description does not need to add parameter semantics because there are none to document.

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 ('Stop the ChimeraX process') with a specific resource scope ('started by this server'), which distinguishes it from sibling tools like chimerax_start and chimerax_close. This is a specific verb+resource pair that fully clarifies what the tool does.

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 the tool (when you need to stop the server's ChimeraX process), but it does not explicitly state situations where alternatives should be used or when not to use it. It provides context but no exclusions or comparative 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 burden of disclosing behavior. It explains how UniProt positions are mapped to ChimeraX residue specs via chain_mappings, which is valuable. However, it does not mention other behaviors like saving HTML, altering the session, or side effects, leaving significant gaps.

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

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

The description is concise and well-structured, with a clear first sentence and a focused technical paragraph on mapping details. It avoids unnecessary words and is 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?

For a 14-parameter tool, the description covers only a small subset of functionality, omitting output options and other configuration. The output schema handles return values, but the lack of explanation for most parameters makes the description incomplete for confident 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?

Schema description coverage is 0%, so the description must compensate. It only explains external_features and chain_mappings, while the other 12 parameters (e.g., pdb_id, model_spec, theme, include_db_links) remain undocumented. This is insufficient for a tool with 14 parameters.

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

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

The description clearly states the tool renders a structure report with DB URLs and mapped feature links, which is a specific verb+resource combination. This distinguishes it from sibling tools like chimerax_view or chimerax_rich_report, 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 description provides clear context for using external_features and chain_mappings, implying this tool is appropriate when mapping external annotations to structure reports. However, it does not explicitly state when to avoid this tool or name alternatives, so it lacks exclusions but still offers useful guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains that it captures only tool windows (not the 3D view), that width/height resize the widget, that padding is applied, and that output_path has a default save location. It also describes the return dict. However, it does not mention prerequisites like whether the tool window must already be open, or error handling if the tool is not found, leaving a small transparency 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 well-structured as a docstring with a concise introduction and a detailed Args/Returns section. Every sentence adds value, but the parameter descriptions are somewhat verbose, preventing a perfect score. Overall, it is appropriately sized 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?

Despite having an output schema (so return values need not be explained), the description covers purpose, usage guidance, thorough parameter semantics, and even the error return format. This is complete for a tool of this complexity, with no 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 description coverage is 0%, so the description must compensate. It thoroughly documents all 5 parameters with semantic meaning beyond types: tool_name includes examples, width/height specify purpose and range, padding explains default and constraint, and output_path describes default behavior. This fully compensates for the missing schema descriptions.

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

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

The description states 'Capture a screenshot of a ChimeraX tool window' and explicitly differentiates from the sibling tool by saying 'This captures separate tool panels, not the main 3D view. Use chimerax_screenshot for the main 3D view.' This clearly identifies the resource and distinguishes it from its sibling.

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?

Directly provides an alternative: 'Use chimerax_screenshot for the main 3D view.' This explicitly tells the agent when to use this tool versus the sibling, satisfying the requirement for usage guidance.

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

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

With no annotations, the description carries the burden. It discloses that frames=1 results in an instant rotation and that frames must be >= 1, which is useful behavioral context. However, it does not mention whether the rotation affects the session state, requires an active session, or has side effects.

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

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

The description is compact and well-structured with an Args and Returns section. Every sentence adds information, and the format is 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?

For a simple rotation tool, the description covers purpose, all parameter semantics, and basic return. It is missing some context about prerequisites (e.g., need an open session) but remains sufficient given the low complexity. An output schema exists, so return details are not fully required.

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%, but the description fully compensates by explaining each parameter: axis accepts x/y/z, angle is in degrees, frames is an integer >= 1 with default 1. It even explains the meaning of frames=1 (instant), adding clear semantic value beyond the raw 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 a specific verb and resource: 'Rotate the view around an axis.' This is unambiguous and distinguishes it from sibling tools like chimerax_view or chimerax_reset.

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 rotating the view but does not explicitly state when to use it over alternatives or what other tools might be better for related tasks. No exclusions or alternative references 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 provided, the description is the only source of behavioral information. It states the action and the return value but does not disclose potential side effects, reversibility, or prerequisites. For a view manipulation tool, this is a minor 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 concise and well-structured: a one-sentence summary followed by clear Args and Returns sections. Every sentence adds value and there is no verbosity.

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 one optional parameter and an output schema, the description covers the core behavior and parameter semantics sufficiently. It doesn't mention edge cases or prerequisites, but these are not critical for this tool.

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

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

The input schema provides no description for the 'target' parameter (0% coverage). The description fully compensates by explaining it is optional, giving example atom specifications ('#1', ':MK1'), and describing the default behavior when omitted.

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 ('Adjust') and resource ('view'), and clarifies that it fits either all models or a specific target. This distinguishes it from sibling tools like chimerax_turn (rotate) and chimerax_reset (reset).

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 on when to use the tool (to fit models or a target) and explains the default behavior. However, it does not explicitly mention alternatives or exclusions relative to sibling tools.

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