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

With no annotations provided, the description must disclose behavioral details. It only states the core action and does not mention side effects, requirements, or what 'align' does in terms of output or state changes. The description is too terse to provide adequate 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 that is direct and free of fluff. It is concise but not overly terse to the point of being a tautology. However, it could be more informative without losing 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?

Given the tool's low complexity and full schema coverage, the description is minimally adequate. An output schema exists, so return values are not required. However, the description does not fully convey the alignment behavior or context, making it average in completeness.

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

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

The schema description coverage is 100%, so all parameters are already documented. The description adds no new meaning beyond the schema's own property descriptions. It meets the baseline but does not enhance understanding beyond the schema.

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

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

The description clearly states the tool's function: 'Aligns one selection to another' – a specific verb and resource. It distinguishes alignment from similar operations like superposition or fitting, though it does not explicitly name alternatives. It is a clear, plain-language statement.

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

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

No guidance is provided on when to use this tool versus alternatives like 'super' or 'intra_fit'. The schema hints at usage (e.g., target stays put), but the description itself offers no explicit adoption criteria or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It merely states that atomic properties are altered but does not explain how the assignment expression is evaluated, whether the operation is reversible, or any side effects on the selection or molecular state. This is insufficient for a mutating tool.

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

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

The description is a single, focused sentence with no filler or redundancy. It is appropriately sized for the tool's simplicity, conveying the essence without unnecessary words, which earns a high score for conciseness and structure.

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?

Although the schema documents both parameters, the description lacks essential context about the expression language, selection behavior, and relationship to sibling tools. An agent would not know when to choose 'alter' over 'alter_state' or 'set', nor understand the impact of the assignment, leaving the description incomplete for a mutating tool.

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

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

The schema already describes both parameters with clear titles and examples (e.g., ``b=0``, ``chain='B'``), achieving 100% coverage. The description adds no param-specific meaning beyond what the schema provides, so it meets the baseline for high schema coverage.

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

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

The description uses the specific verb 'Alters' and identifies the resource as 'atomic properties in a selection,' clearly conveying the tool's core function. It distinguishes from siblings like 'alter_state' (which likely modifies state-level properties) by indicating the target scope, though it does not explicitly name alternatives.

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

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

No guidance is provided about when to use this tool versus alternatives such as 'set' or 'alter_state'. The description only states what the tool does without offering context, exclusions, or preferred scenarios, leaving the agent to infer usage.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that coordinates are altered, which is the core behavior, but doesn't disclose side effects, reversibility, or any caveats. This is minimal for a mutation tool.

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

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

The description is a single sentence with no redundancy and is appropriately concise. However, it's a bit too sparse to fully explain the tool's capabilities.

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 is a mutation with three required parameters and no annotations, the description is insufficiently complete. It doesn't explain the expression syntax, effect on the state, or any prerequisites. The minimal text leaves significant gaps.

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

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

The schema covers all three parameters with descriptions, so the baseline is 3. The tool description adds no additional parameter information beyond what the schema already provides.

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

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

The description clearly states the tool modifies atomic coordinates in a state, which is a specific verb+resource. However, it doesn't distinguish it from sibling tools like 'alter' or other modification commands, so it doesn't earn 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?

The description provides no guidance on when to use this tool versus alternatives. It simply states the action with no mention of context, prerequisites, or exclusions.

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

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

The description explains what the tool displays (all altloc groups with distinct colors and occupancy labels) and why that matters, but does not disclose that it modifies the current PyMOL display state (colors/labels) or any potential side effects such as overwriting existing visual settings. With no annotations, the description carries the full burden and only partially discloses behavior.

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

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

The first sentence is front-loaded with the core function. The subsequent rationale is useful for context but could be slightly more concise; still, every sentence adds value and the length is appropriate for the tool's purpose.

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

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

For a simple two-parameter tool, the description covers the purpose, rationale, and core behavior. It lacks explicit mention of side effects or prerequisites (e.g., object must have altloc groups), but the overall context is sufficient. The output schema reduces the need to describe return values.

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?

Both parameters are already fully described in the schema with 100% coverage. The description reiterates the labeling behavior but adds little meaning beyond the schema, such as clarifying the role of obj_name or label. This is baseline for high schema coverage.

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

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

The description opens with a specific verb and resource: 'Show every altloc group at once, one colour per group, occupancies labelled.' This clearly identifies the tool's function and distinguishes it from PyMOL's default single-conformer display, as explained in the following rationale.

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 second paragraph explains when this tool is valuable—when a multiconformer model contains discrete alternatives that PyMOL's default view hides. While it does not name alternative tools or explicit exclusions, it gives clear context about the problem it solves.

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

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

No annotations are provided, so the description carries the burden. It discloses a key side effect (draws a named angle object) and the return unit (degrees), but does not mention prerequisites, failure modes, or scene mutation details beyond the drawn object.

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, front-loaded with the core purpose and an additional side effect. Every word adds value with no fluff.

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 measurement tool with full schema coverage and an output schema, the description adequately covers purpose and the significant drawing side effect. It could be improved by noting the vertex order semantics, but the schema already provides this.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds minimal param meaning beyond 'three selections' and 'named object', which the schema already covers with field descriptions like 'Second selection (the vertex)'.

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 measures the angle between three selections and returns it in degrees. It also mentions it draws the measurement as a named angle object, which distinguishes it from sibling tools like distance or dihedral.

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

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

No explicit guidance is given on when to use this tool versus alternatives such as dihedral or distance. The description implies usage by the domain (measure angle) but does not state exclusions or alternative conditions.

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 core behavior (one shown, all others hidden) and scoping to a selection, but does not mention side effects like whether this is reversible, affects camera, or applies to all objects. This is acceptable but not rich.

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

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

The description is a single concise sentence that front-loads the primary purpose. Every word adds value with no extraneous information.

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

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

This is a simple tool with two parameters, an output schema, and a clear core purpose. The description is sufficient for an agent to understand the tool's function, though it could benefit from a brief note about when to prefer 'as' over 'show'/'hide'.

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

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

Schema description coverage is 100%, so the schema already documents both parameters well. The description adds no additional semantic detail beyond what the schema provides, hence the baseline score.

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+resource structure: 'Shows one representation while hiding all others for the specified selection'. This clearly distinguishes it from siblings like 'show' or 'hide' by describing the combined action of isolating a single representation.

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

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

The context is clear: use this when you want to display exactly one representation for a selection. However, it does not explicitly mention alternatives or exclusions, though the sibling list includes related tools like 'show' and 'hide' that could serve similar purposes.

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 behavioral burden. It discloses that properties are evaluated by PyMOL per atom and accepts iterate expressions, which is useful operational context. It also hints at a technical limitation ('returns an object that cannot cross the bridge'). However, it does not mention potential cost (e.g., slow for large selections) or details about the result format, though the output schema likely covers the latter.

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 clear lead sentence, a differentiation paragraph, usage examples, and a technical note. It is a bit longer than strictly necessary—some repetition of the 'cannot reach/other route' idea—but every paragraph serves a purpose and the content is front-loaded.

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

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

Given the moderate complexity, an output schema exists, and no annotations, the description is exceptionally complete. It covers purpose, alternative tools, concrete use cases, and parameter semantics. The only minor gaps are performance/return details, but those are either in the schema or not critical for a read operation. This matches the high end of the calibration examples.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by explaining that the 'properties' parameter is a PyMOL iterate expression and provides a list of common properties. It also gives guidance on narrowing the 'selection'. This goes beyond the schema's short field descriptions, especially for 'properties', which could otherwise be ambiguous.

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: 'Reads per-atom properties.' It immediately distinguishes itself from siblings by stating 'nothing else in the tool set can reach' and contrasts with object-level and per-residue tools. This makes the purpose unmistakable.

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

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

The description explicitly names alternatives: 'Object-level facts come back through structure_info and list_chains, and per-residue values through get_sequence or the view presets.' It then provides concrete use cases ('partial occupancy...', 'per-atom pLDDT...', 'formal charge...'). This clearly tells the agent when to choose this tool and when other routes are 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 must stand alone. It states the action but does not disclose boundary behavior (e.g., if on the first frame) or side effects.

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

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

A single sentence that is direct and contains no extraneous information.

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

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

Given the simplicity of the tool (no parameters, single action), the description fully covers what the tool does.

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 100% schema description coverage, so baseline is 4. The description does not need to add parameter info.

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

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

The description uses a specific verb 'goes back' and resource 'one frame', clearly stating the action and distinguishing it from sibling tools like 'forward' and 'frame'.

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 navigating backward in a frame-based context but provides no explicit guidance on when to use it versus alternatives or any exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses the color scheme (blue/white/red), the display mode (cartoon), and background (black), which are the key behavioral traits. It does not mention potential side effects like overwriting existing colors, but the view-tool nature and description are sufficiently transparent.

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

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

The description is four sentences, each earning its place: it states the purpose, explains the color legend, gives use cases, and notes the display style. It is front-loaded and free of fluff.

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 visualization tool with an output schema present, the description is complete. It covers purpose, visual interpretation, applications, and rendering details, which is all the agent needs to decide on and invoke the tool correctly.

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

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

Schema description coverage is 100%, so the sole parameter obj_name is already well-documented in the schema. The description adds no additional information about the parameter, so it does not exceed the baseline of relying on the schema.

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

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

The description clearly states a specific verb ('Colors') and resource ('the structure by crystallographic B-factor'), immediately distinguishing it from sibling view tools like plddt_view or conservation_view. The naming and details about color mapping remove ambiguity about 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 provides explicit use cases ('identifying dynamic loops, disordered termini, and rigid structural cores'), giving the agent context for when to invoke this tool. It does not explicitly mention when-not-to-use or name alternative tools, but the specificity of B-factor makes the intended scenario 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?

With no annotations, the description carries full responsibility for behavioral disclosure. It only says 'creates a bond' and does not mention atomicity, whether existing bonds are replaced, required atom selection behavior (exactly one atom each), or any side effects on the molecular structure. The schema describes selections, but the description does not state these are required or how they are validated.

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

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

The description is one short sentence, extremely concise and front-loaded with the key information. However, it is so brief that it under-delivers on context, but for pure conciseness it earns a high 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?

The tool is a structural mutation operation with no annotations and only a one-line description. While an output schema exists and parameters are documented, the description fails to provide essential behavioral context such as how the bond creation affects the structure, prerequisites, or relationship to sibling tools. For a simple tool, this is a minimal but incomplete description.

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

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

The schema description coverage is 100%, with each parameter (atom1, atom2, order) having its own description in the input schema. The tool description itself adds no additional meaning, so it does not go above the baseline for fully covered schemas.

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 'Creates a bond between two atoms' clearly states the action (creates) and the resource (a bond), and the two-atom target is explicit. While it doesn't explicitly differentiate from siblings such as 'unbond' or 'distance', the primary purpose is unambiguous.

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

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

No guidance is provided on when to use this tool instead of alternatives. For example, there is no mention that 'unbond' is the inverse operation, or that bonds should be created before using distance or angle tools. The description simply states what it does with no contextual usage advice.

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 for behavioral disclosure. It simply states 'Sets the cartoon type' without mentioning side effects, reversibility, or what happens to existing cartoon settings. The tool's mutating behavior is implied but never elaborated.

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 or extraneous information. Every word contributes to the core purpose, making it highly concise and well-structured.

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

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

The tool is simple with a rich input schema and an output schema, yet the description lacks any usage context or exclusionary guidance. It is adequate for a minimal tool but does not fully address the broader context of when or how to use it beyond the literal action.

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

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

Schema coverage is 100%, so the input schema already provides detailed descriptions for both parameters (item_type and selection). The tool description adds nothing beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description 'Sets the cartoon type for the specified selection' uses a specific verb ('sets') and resource ('cartoon type'), clearly distinguishing it from sibling tools like 'show', 'set', or 'as'. The target 'selection' is also specific, leaving no ambiguity about the tool's function.

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

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

No guidance is given on when to use cartoon versus alternative representations or how it relates to other tools. The description is purely declarative and offers no exclusions, prerequisites, or comparisons to siblings, leaving the agent without usage context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action without mentioning side effects, session-scoped state changes, or error conditions, which is a significant gap for a state-mutating command.

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 words. It is as concise as possible, though it sacrifices useful context, which is acceptable given the simplicity of the 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?

For a very simple tool, the description covers the core purpose, and the parameter schema adds necessary detail. However, it lacks usage context and behavioral caveats (e.g., that this changes the working directory for the PyMOL session), making it merely adequate rather than complete. The presence of an output schema reduces the need to explain return values, but the overall context is thin.

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 100% coverage for the single 'path' parameter, which includes a clear description of how PyMOL resolves relative paths from the new directory. The tool description adds no parameter-specific information, but the schema already does the heavy lifting, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool changes the current directory, which is a specific verb+resource operation. It does not explicitly distinguish from sibling tools like 'pwd', but the purpose is unambiguous and goes beyond a tautology.

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

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

No guidance is provided on when to use this tool, prerequisites, or alternatives. The description does not mention that this affects relative path resolution for subsequent PyMOL commands or any exclusions, leaving the agent to infer usage.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only states the primary function but does not reveal whether the operation modifies the selection, preserves zoom, is reversible, or has any side effects. For a view operation, these details matter for safe invocation.

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

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

The description is a single sentence that directly states the action and target, with no redundant information. 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?

For a simple one-parameter view tool, the description plus schema covers the basic function, but the lack of annotations and absence of guidance on when to use it relative to similar sibling tools leaves gaps. The output schema exists, so return values need not be described.

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

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

The schema already has 100% coverage with a clear description for the 'selection' parameter. The tool description adds no additional parameter information beyond what is in the schema, so the baseline score of 3 applies.

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

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

The description uses a specific verb 'centers' and resource 'view' on a 'selection', clearly stating the tool's function. It does not explicitly differentiate from sibling view tools like 'orient' or 'zoom', but the action is distinct enough to infer purpose. This is clear but lacks explicit 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?

There is no guidance on when to use this tool versus alternatives such as 'orient' or 'zoom'. The description only states what it does, leaving the agent to infer usage context without any exclusions or comparisons.

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

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

With no annotations, the description carries the full burden of disclosing side effects. It explicitly mentions 'deep shadows, fog, depth-cueing', a 'dark background', and that 'Protein uses standard coloring but with altered material properties.' It does not describe reversibility or effects on other settings, but the main behavioral changes are transparently 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 three sentences in two short paragraphs. The first sentence front-loads the primary purpose, while the next two add illustrative detail and material specifics. Every sentence earns its place with no repetition or unnecessary words.

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

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

For a single-parameter configuration tool, the description covers the visual outcome, gives a concrete use case, and notes the change to material properties. It omits prerequisites (e.g., object must be loaded) or how to reset, but these are minor given the simple scope and the presence of an output schema.

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

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

Schema description coverage is 100% and the only parameter 'obj_name' has a clear description ('PyMOL object name (e.g. "1abc")'). The tool description does not add any parameter-specific details beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool 'Configures PyMOL for a depth-cued, cinematic look with dramatic lighting' — a specific verb, resource, and particular style. It distinguishes itself from sibling view tools by describing a unique aesthetic (shadows, fog, dark background), so there is no ambiguity about what it 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 provides clear context for when to use the tool: it 'emphasizes volume and scale' and is suited for 'massive complexes (like ribosomes or viral capsids)' to look dramatic. It does not explicitly name alternatives or state when not to use it, but the use case is well implied.

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 only states 'Adjusts the clipping planes' without disclosing that this changes visibility/rendering, how distance interacts with modes, or any side effects. This is minimal but not misleading.

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

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

The description is a single concise sentence, front-loaded with the action and target, with no unnecessary words.

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

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

For a simple 2-parameter tool with full schema coverage and an output schema present, the description is minimally viable. However, it lacks usage context and is too terse to fully guide an agent 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?

Schema description coverage is 100%, with mode and distance clearly explained in the input schema. The description itself adds no extra parameter semantics, so baseline 3 is appropriate.

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

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

The description uses a specific verb 'Adjusts' and a clear resource 'clipping planes,' making the tool's function evident. It is distinct from sibling tools like zoom or orient, which affect the view but not the clip planes directly.

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

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

The description provides no guidance on when to use this tool versus alternatives such as viewport, zoom, or orient. There is no mention of exclusions, prerequisites, or specific scenarios.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It merely says 'Sets the color' which restates the purpose. It does not disclose whether existing colors are overridden, how it interacts with representations, or any side effects.

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

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

The description is one sentence with no wasted words. It is concise and front-loaded. However, it is extremely terse and lacks any additional context, which slightly reduces effectiveness despite being well-structured.

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

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

Given the low complexity and rich schema, the description is still incomplete. It lacks usage guidance, differentiation from siblings, and any behavioral context. The presence of an output schema does not compensate for the missing information about when and how to use 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?

Schema description coverage is 100% (both 'selection' and 'color_name' have descriptions). The tool description adds no parameter information beyond the schema, so the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource: 'Sets the color for a selection.' This is clear and unambiguous. However, it does not differentiate from sibling tools like 'spectrum' or 'util_color_by_element' that also deal with coloring.

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 does not mention any context, prerequisites, or exclusions. For example, it does not say when to use 'color' instead of 'util_rainbow' or 'spectrum'.

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 an excellent job. It discloses the external MMseqs2 API call, potential 30-second-to-minutes latency, in-memory caching by sequence, the effect on B-factor and spectrum coloring, and the color-mapping semantics. This is far beyond minimal and gives the agent a realistic expectation of side effects and performance.

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 paragraph-structured but each sentence earns its place: purpose, pipeline, caching, color mapping, and a latency note. It is front-loaded with the primary function, remains readable, and avoids 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 complexity (external API, caching, B-factor modification) and the existence of an output schema, the description covers all critical aspects: the full pipeline, the color interpretation, performance expectations, and caching behavior. It leaves no major 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?

Schema coverage is 100% with detailed parameter descriptions, providing a baseline of 3. The description adds value by explaining that changing the scale does not trigger a new API call and that re-runs are cached, which directly informs understanding of 'scale', 'force_refresh', and 'server_url'. This extra context justifies a score above baseline.

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

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

The description opens with a clear, specific verb+resource statement: 'Colors the structure by evolutionary conservation using Shannon entropy.' This explicitly distinguishes it from sibling view tools like bfactor_view or plddt_view, and the detailed pipeline further clarifies its unique function.

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 (for evolutionary conservation coloring) and includes practical usage guidance about the first-call latency and caching. However, it does not explicitly name alternatives or state when not to use it, so it stops short of full exclusion 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 openly states the tool relies on heavy-atom distance criteria, elaborates on the lack of hydrogens, and cautions that hydrogen bonds are 'plausible geometry' rather than verified. It also explains the default exclusion of water. This is richly transparent behaviorally.

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 but information-dense, front-loaded with the main action, then distinguishing context, use cases, and technical criteria. Each sentence earns its place, and the structure flows logically from what to when to how. No wasted words.

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

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

Given the tool's complexity and the presence of a rich output schema, the description covers all necessary aspects: purpose, alternatives, parameter semantics, classification details, and limitations. It is completely adequate for an agent to select and invoke the tool correctly without ambiguity.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining how the cutoff relates to the classification thresholds (e.g., '4.0 captures the interactions above') and by explaining why include_water defaults to off. However, most parameter details are already well covered in the schema, so this is a modest enhancement rather than a full compensation.

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: 'Lists the residues in contact across two selections, with distances and types.' It clearly distinguishes itself from sibling tools by calling itself the 'numeric counterpart to ligand_view and interface_view' and provides concrete use cases. This fully satisfies purpose clarity.

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 contrasts with drawing tools: 'instead of drawing the interactions, it reports them' and names the alternatives. It also gives question-based use cases ('what holds this ligand in the pocket') and explains the classification criteria, which helps the agent decide when this tool is appropriate. This is strong 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 of disclosing behavior. It states that it counts and warns about empty counts, but does not explicitly say whether the operation is side-effect-free (e.g., it doesn't modify the scene). The read-only nature is implied but not stated, leaving a mild 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 succinct: three sentences total, with the first stating core functionality and the second/third providing a valuable use case. 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 simplicity, the presence of an output schema, and full parameter schema coverage, the description fully covers the practical usage scenario. The extra note about empty counts as a debugging hint makes it contextually complete for an AI agent deciding when to invoke it.

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 describes the 'selection' parameter as a 'PyMOL selection string to count' with 100% coverage. The description reinforces this by referencing selection expressions but does not add meaningful detail beyond the schema, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Counts') and resource ('atoms matching a selection'), clearly distinguishing it from sibling tools like select or remove. The additional explanation about checking selection expressions makes the purpose even clearer.

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 explicitly recommends using this tool to validate a selection expression before building a scene, providing clear context for when it is useful. It does not explicitly contrast with alternatives or state when not to use it, but the guidance is specific and actionable.

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, but it only states the basic action. It does not mention that the operation copies atoms and leaves the original intact, nor does it disclose potential side effects. The schema's selection parameter description notes 'The original is left in place', but this is not carried into the main description.

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

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

The description is a single concise sentence that is front-loaded with the action. It is not verbose, but given the tool's need for contextual behavior, the brevity borders on under-specification. Still, the sentence is well-structured and clear.

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

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

Despite having a schema with full parameter descriptions and an output schema, the description fails to provide essential context that distinguishes this tool from similar ones like 'extract' (which removes from the original) or 'select'. The presence of numerous sibling tools and no annotations makes this a significant gap.

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

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

The input schema provides complete descriptions for all three parameters (name, selection, source_state), achieving 100% coverage. The description itself adds no additional parameter information, so the baseline score of 3 is appropriate.

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

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

The description uses the verb 'creates' and specifies the resource 'a new object from a selection', clearly indicating the action. This distinguishes it from tools like 'extract' or 'delete' which also manipulate objects but with different semantics.

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 'extract' (which removes atoms from the original) or 'select'. The description only states what the tool does, leaving the agent without decision criteria.

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 transparency. It discloses detailed visual behavior: thin grey cartoon, yellow sticks for cysteines, yellow dashes for disulfides, orange spheres for metals, dashed lines for coordination, and black background. This goes well beyond a basic summary, though it does not mention side effects or scene reset behavior.

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

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

The description is appropriately sized for a visualization tool, with the main purpose stated first and subsequent sentences providing specific visual details. Each sentence contributes useful information, though some minor redundancy exists (e.g., 'drawn as' repeated). Overall, it is well-structured and not verbose.

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

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

For a one-parameter tool with an output schema, the description comprehensively covers the visual output, including colors, styles, and labeling. It does not mention potential side effects (e.g., whether it resets existing styles) or prerequisites, but the simplicity of the tool keeps those gaps minor.

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 a complete description for the single parameter obj_name ('PyMOL object name (e.g. 1abc)'), so schema coverage is 100%. The description does not add extra meaning about the parameter itself; it only elaborates on what will be visualized. Baseline 3 is appropriate.

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

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

The description clearly states the tool highlights structural cross-links (disulfide bonds, metals, and their coordination), which is a specific verb+resource (highlights + cross-links). This distinguishes it from sibling view tools like interface_view or bfactor_view, making its purpose unambiguous.

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

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

The context is clear: use this tool to visualize structural cross-links. While it does not explicitly name alternatives or exclusions, the purpose statement makes the usage obvious. This aligns with 'clear context, no exclusions' rather than merely implied usage.

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

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

Annotations are absent, so the description carries the full burden. It states the destructive action ('Deletes') but does not disclose irreversibility, side effects on dependent objects, or the fact that wildcards and 'all' can mass-delete. The name and schema hint at these behaviors, but the description itself adds little 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, appropriately sized sentence: 'Deletes objects or selections.' It is front-loaded with the verb and object, contains no filler, and is suitably concise for a tool with one parameter.

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 with a rich schema and an output schema, the description provides the basic invocation context. However, as a destructive tool with no annotations, it would benefit from clarifying permanence and differentiating from sibling tools like 'remove', so the description is minimally complete but not fully self-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?

Schema coverage is 100%: the 'name' parameter is fully described with wildcard examples and the special 'all' value. The description adds no extra parameter context, but the schema already provides the necessary details, matching the baseline for high 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 uses a specific verb ('Deletes') and identifies the resource ('objects or selections'), making the core purpose clear. It does not explicitly distinguish itself from similar sibling tools like 'remove' or 'deselect', but the meaning is unambiguous.

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

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

No guidance is given on when to use this tool versus alternatives such as 'remove', 'deselect', or 'hide'. There are no exclusions, prerequisites, or preference hints, leaving the agent without context for tool selection.

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 reveals that PyMOL levels are in sigma, that absolute levels are converted before reaching PyMOL, that EMDB depositions get a pointer with units named, and that the level is always reported in both units. This rich detail goes well beyond a basic 'draws a mesh' statement.

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 three sentences, each earning its place: the main action, the problem it solves, and the operational requirement. It is dense but not bloated, and the most important information is front-loaded.

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

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

Given an output schema exists, the description doesn't need to detail return values. It covers the core behavior, unit conversion, and the load_map prerequisite. Minor gaps include explicit error handling if the map is not loaded correctly, but overall it is sufficiently complete for a moderately complex tool.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaningful semantics for 'level' and 'units' by explaining the sigma/absolute distinction, conversion, and what happens when 'level' is omitted (1.5 sigma generic). This adds value beyond the schema's simple parameter descriptions.

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

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

The description opens with 'Draw an isomesh around a selection, stating the contour level in both units,' which is a specific verb+resource statement. It also uniquely highlights the dual-unit reporting, distinguishing it from sibling tools like isomesh and isosurface.

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

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

The description clearly states the prerequisite: 'Requires the map to have been loaded through load_map' and explains why. It also provides context about the sigma vs absolute discrepancy with EMDB, but it does not explicitly name alternative tools or state when not to use this tool, so it stops short of full exclusion 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 only states the basic action without any details on side effects, prerequisites, or what happens to the selection state beyond clearing.

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

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

The description is a single sentence with zero waste, front-loading the clear purpose. It is appropriately sized for a tool with no parameters and a straightforward action.

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

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

Given the low complexity (0 parameters, simple action) and the presence of an output schema, the description is adequate. It clearly states the tool's purpose, though it could potentially add context about the effect on the selection state.

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

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

The tool has no parameters, and the schema coverage is 100%. Since there is nothing to describe, the baseline is 4, and the description does not add any unnecessary information.

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

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

The description uses the verb 'clears' and specifies the resource 'current selection', clearly indicating the tool's function. It distinguishes itself from the sibling tool 'select' which does the opposite.

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

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

No guidance is provided on when to use this tool versus alternatives like 'select' or other selection-related tools. There is no mention of usage context or exclusions.

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

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

With no annotations provided, the description carries the full burden. It discloses two behaviors: measuring the angle and drawing the measurement as a named object. However, it remains ambiguous whether the angle is returned as a value or only drawn, and it does not mention failure modes or prerequisites. Some behavioral context is provided, but gaps remain.

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 no wasted words. It front-loads the core measurement function, then adds the side effect and use cases. This is appropriately sized and well structured.

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

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

Given the tool has 5 parameters all documented in the schema and an output schema exists, the description covers the essentials: purpose, unit (degrees), side effect (drawing), and example use cases. It does not explain return values (covered by output schema) or state dependence, but for a measurement tool it is substantially complete. A slight gap is the lack of mention about state or structure requirements, so a 4.

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

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

Schema description coverage is 100%, and the schema itself provides detailed parameter descriptions, including examples like 'For a backbone phi angle this is the preceding C.' The description adds no additional semantic meaning beyond what the schema already supplies, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool measures the dihedral (torsion) angle between four selections in degrees, which is a specific verb+resource. It distinguishes itself from sibling tools like angle (three selections) and distance by explicitly mentioning four selections and torsion angle. The added note about drawing a named dihedral object further clarifies its function.

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

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

The description gives clear context on when to use the tool: 'Useful for backbone phi/psi angles and ligand torsions.' It does not explicitly state when not to use it or name alternatives, but the provided use cases effectively guide an agent toward appropriate scenarios. Lacks explicit exclusions, so a 4 rather than 5.

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

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

With no annotations, the description carries the full burden and does well: it discloses the return unit (Angstrom), the side effect of creating a named distance object in the viewport, and the averaging behavior for multi-atom selections. This goes beyond the tool name and schema.

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

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

The description is three sentences, with the purpose upfront, followed by the side effect and an edge case. Each sentence adds distinct value 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 simple measurement tool with three parameters and an output schema, the description covers the core functionality, return unit, side effect, and multi-atom behavior. It lacks only minor details like selection syntax or behavior when no pairs are found, but these are not critical.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds context about the name being used for the drawn object and multi-atom selection behavior, but it does not substantially enrich parameter meaning beyond what the schema already provides.

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

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

The description states the tool measures distance between two selections and returns it in Angstrom, which is a specific verb+resource. It also mentions the side effect of drawing the measurement, distinguishing it from measurement tools like angle or dihedral, but does not explicitly name alternatives.

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 measuring distances but provides no explicit guidance on when to use this tool versus siblings like angle, dihedral, or sasa. There are no exclusions or alternative tool mentions, leaving the agent to infer 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 reveals that the tool uses OpenGL and is faster but lower quality, but it does not disclose what the tool does, what side effects it has, or what output to expect. This is minimal insight into the actual behavior.

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

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

The description consists of a single short sentence with no filler words. It is front-loaded with the key technical detail about the OpenGL renderer and the speed/quality tradeoff. While it is under-specified, that is a completeness issue, not a conciseness issue.

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 very incomplete for a rendering operation. It does not explain what the tool renders, when to use it, or what the result is. Given the complexity of the domain (molecular visualization) and the need to choose between rendering tools, this description is insufficient.

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

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

The input schema provides descriptions for both parameters ('width' and 'height') with 100% coverage, so the schema already documents their meaning. The description adds nothing about the parameters, and per the baseline for high schema coverage a score of 3 is appropriate.

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

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

The description only says 'Uses OpenGL renderer (faster but lower quality)' without stating what the tool actually does. It does not explicitly say 'draw an image' or 'render the current scene', leaving the purpose vague. The technical detail about OpenGL hints at rendering but does not define the action or output.

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

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

No explicit guidance is given about when to use this tool versus alternatives. The phrase 'faster but lower quality' implies a tradeoff with other rendering methods, but no alternative tools are named and no clear usage scenario is stated. This leaves the decision of when to use 'draw' entirely to the agent.

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

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

With no annotations, the description carries the full burden. It discloses visual behaviors (B-factor spectrum, semi-transparent surface, cartoon beneath, sticks with yellow carbons) and the approximate nature of the electrostatics. It doesn't mention whether the coloring permanently alters the session or any prerequisites, but overall it provides substantial 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 compact, with a front-loaded purpose and only three short paragraphs. Each sentence adds value: the main function, the visual rendering details, and an alternative tool. No wasted words.

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

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

The description covers the tool's purpose, visual output, and alternative, which is sufficient for a 2-parameter tool with a schema. It lacks explicit statements about state changes or limitations, but the behavioral details compensate for the absence of annotations.

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

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

Schema description coverage is 100%, with both mode and obj_name described in the input schema. The description does not add parameter-specific details beyond what the schema already provides, so the baseline score of 3 applies.

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

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

The description states a specific action ('Colors the molecular surface') with a defined method ('approximate residue-based electrostatics') and resource ('molecular surface'). It also differentiates from the sibling tool poisson_boltzmann_view by noting it is more accurate and requires additional software.

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 names poisson_boltzmann_view as a more accurate alternative, providing a clear when-not scenario. However, it does not address relationships to other view tools such as bfactor_view or hydrophobic_surface_view, so guidance is partial.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It thoroughly explains the computation (per-residue RMS deviation), the effect (B-factor column overwritten, blue-to-red spectrum coloring, tube thickness), and the interpretive caveat. This goes well beyond minimal 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?

The description is four sentences long, front-loaded with the main action followed by technical detail and a caveat. Every sentence earns its place: the action, the computation, and the crucial interpretation warning. No redundancy or filler.

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

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

The tool has moderate complexity, and the description covers the computation, visual output, and scientific interpretation. It also includes a necessary caution about the metric's meaning. While it does not mention restoring B-factors, it provides enough context for an agent to select and invoke the tool correctly.

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

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

Schema description coverage is 100%, so the schema already explains both parameters. The description adds context about the overall behavior but does not elaborate on parameter syntax or semantics beyond the schema. Baseline 3 is appropriate.

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

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

The description opens with a specific verb and resource: 'Colour and thicken a multi-state object by how much its states disagree.' This clearly identifies the tool's action and target, and distinguishes it from siblings like conservation_view or bfactor_view by focusing on inter-state disagreement.

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

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

The description clearly implies the tool is for multi-state objects and explicitly states what the spread is NOT (calibrated uncertainty/error bar), providing a when-not-to-use caution. However, it does not name alternative tools or explicitly explain when to choose this over a sibling, so it falls short of a 5.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It adds useful context about the PyMOL 'cmd.do' mini-language and explicitly says 'not Python', preventing misuse. It also hints at lower-level behavior via 'raw' and 'better defaults'. However, it does not explicitly mention potential side effects or error behavior, which keeps it from a 5.

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 three sentences, front-loaded with the core purpose, followed by usage guidance and a technical note. Every sentence serves a purpose with no redundant 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 single-parameter raw execution tool, the description is exceptionally complete: it states the operation, gives conditional guidance with examples, and clarifies language syntax. The output schema exists, so return-value details are not needed. It fully covers how an agent should decide to use 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?

Schema description coverage is 100%, and the schema already describes the parameter with an example and the Python exclusion. The tool description adds multi-statement script mention as a usage hint, but it does not materially extend parameter semantics beyond what the schema provides, so the baseline 3 applies.

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

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

The description uses a specific verb+resource construction ('Executes a raw PyMOL command string') and is clear about the tool's role as a fallback, distinguishing it from the dedicated sibling tools (show, color, select, etc.) with explicit examples.

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

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

The description explicitly tells the agent to 'PREFER the dedicated tools' and provides concrete when-to-use and when-not-to-use scenarios, including examples like `set ray_shadow, 0` and multi-statement scripts. It clearly excludes common cases and names 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 burden of behavioral disclosure. The description simply says 'Extracts a selection to a new object' without explicitly stating that the selection is removed from the original object; this critical side effect is only clarified in the parameter description. The word 'extracts' hints at removal but is not explicit enough.

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

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

The description is a single concise sentence that immediately conveys the tool's purpose. It is appropriately sized and front-loaded with no unnecessary words.

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

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

The tool has a simple two-parameter schema with full documentation and an output schema, so the basic usage is clear. However, the description lacks explicit disclosure of the removal side effect and offers no usage guidance, which is a gap given the lack of annotations. The schema compensates partially, but the description itself is thin.

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

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

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

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 'Extracts a selection to a new object' clearly identifies the action (extract) and the resource (selection to a new object). It is specific enough to distinguish from siblings like 'create' because 'extract' implies removal, though it does not explicitly contrast with alternatives.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives such as 'create' or 'select'. The parameter description for 'selection' mentions 'Unlike create' but that is in the structured schema, not the main description, so the description itself lacks usage context.

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

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

With no annotations, the description carries full burden for disclosing behavioral traits. It only states that it creates a peptide chain, but does not mention what the tool actually does in terms of the molecular structure (e.g., backbone, termini, defaults), whether it affects the current session, or what errors might occur. This is a significant transparency gap for a mutation-like operation.

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

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

The description is a single sentence that is direct and front-loaded. Every word adds value, 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?

Given the low complexity (two simple parameters, no nested objects) and the presence of an output schema, a minimal description is adequate. However, the lack of behavioral disclosure (e.g., whether it modifies an existing object or creates a new one) leaves some contextual gaps, so it is not fully complete.

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

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

Schema description coverage is 100%: both 'sequence' and 'options' have descriptive text, with an example for 'options'. The tool description adds no additional parameter semantics, so the baseline score of 3 applies.

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

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

The description clearly states the verb 'creates' and the resource 'peptide chain' with its source ('from a sequence'). It is specific and distinguishes this tool from generic 'create' and other visualization/structure manipulation siblings.

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 prerequisites, side effects, or scenarios where 'fab' is preferred. The description only states what it does, not when to use 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 provided, the description carries the burden of behavioral disclosure. It adds crucial caveats: the model is colored by pLDDT confidence, pLDDT is stored in the B-factor column, and bfactor_view/putty_view will misrepresent the model. This goes beyond the basic schema by explaining interpretational pitfalls, though it does not cover session behavior or error handling.

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 paragraphs, front-loaded with the main purpose, followed by necessary caveats. Every sentence provides value: it explains the prediction nature, the color scheme, and the B-factor column issue, 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?

Given the presence of an output schema and a well-detailed input schema, the description covers the conceptual context needed to interpret results correctly, including the expected coloring and view alternatives. It does not dive into operational details like session replacement, but the schema's 'replace' parameter handles that. The description is sufficiently complete for effective use.

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

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

The schema covers 100% of the parameters with detailed descriptions, so the baseline is 3. The tool description does not add extra parameter semantics beyond mentioning UniProt accession, but the schema already handles this. No additional insight is needed.

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

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

The description clearly states the tool fetches a predicted structure from AlphaFold DB by UniProt accession, which is a specific verb+resource+scope. It implicitly distinguishes itself from the sibling fetch_structure by focusing on AlphaFold predictions, 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 advises using plddt_view instead of bfactor_view or putty_view for viewing, which is useful context. However, it does not explicitly state when to use this tool versus alternatives like fetch_structure or load_structure, nor does it provide exclusions 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, the description carries the full disclosure burden. It reveals important default behaviors: fetching the first biological assembly, removing unrelated chains/states, and applying pLDDT coloring for AlphaFold models. This goes beyond schema and helps the agent anticipate 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 three concise sentences. The first states the core purpose, the second explains the default multimer behavior, and the third covers AlphaFold routing with a pointer. No word is wasted, and the information is front-loaded.

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

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

Given the four parameters and an output schema, the description adequately covers purpose, default behavior, and routing. The main gap is the lack of explicit differentiation from load_structure, which is present in the sibling list and could lead to uncertainty about when to use each.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds context by explaining how pdb_code routing works, but this largely mirrors the schema's field description. It does not add new semantic details for multimer_cutoff or the other parameters beyond what the schema already states.

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

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

The description uses a specific verb ('Fetches') and names clear resources (PDB and AlphaFold DB), with precise routing rules by identifier type. It effectively distinguishes itself from the AlphaFold-specific sibling by pointing to fetch_alphafold, and its scope is unambiguous.

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

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

The description gives clear context: PDB codes fetch from PDB, while UniProt/AF- identifiers route to AlphaFold DB. It references fetch_alphafold as an alternative. However, it does not explicitly contrast with load_structure, which is a close sibling, so exclusion guidance is incomplete.

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

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

With no annotations, the description carries the full burden. It states the action but does not disclose any side effects, prerequisites, or limitations. For a simple tool, this is adequate but not rich.

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

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

The description is extremely concise (two words) and front-loaded with the essential verb and object. 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 no parameters and the presence of an output schema, the minimal description is sufficient for such a simple tool. The context from sibling tools implies it operates in a molecular viewer.

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

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

There are no parameters, so the schema coverage is effectively 100%. The description adds no parameter info but follows the baseline of 4 for zero-parameter tools.

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 'Advances one frame' clearly states the tool's function with a specific verb and resource, distinguishing it from siblings like 'backward' and 'mplay'.

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 'backward' or 'mplay'. It lacks explicit context or exclusions.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It only says 'Loads a molecular fragment' without indicating side effects, object creation, or the outcome of the load. This is insufficient for the agent to understand the tool's behavior.

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

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

The description is a single, concise sentence with no filler or redundant information. It is appropriately sized for a simple tool with one well-documented parameter, earning a perfect score for conciseness.

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

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

Given the tool's simplicity (one parameter) and the presence of a rich output schema, the description is minimally viable. However, it lacks context about what happens after loading (e.g., object creation, display) and how it relates to sibling operations, leaving a clear gap in 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 single parameter 'name' is fully described in the schema with a clear definition and examples ('benzene', 'ala', 'formamide'), giving 100% schema description coverage. The description adds no extra parameter meaning beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description clearly states the action ('loads') and resource ('molecular fragment'), giving a specific verb+resource. However, it does not explicitly differentiate from sibling tools like load_structure or fetch_structure, which also load molecular entities, so it lacks sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. There is no mention of when to choose 'fragment' over load_structure or fetch_structure, leaving the agent without context for tool selection.

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 carry the full burden of behavioral disclosure. The description only states the dual set/query behavior but omits important details such as what happens when querying before any frame is set, whether setting affects the animation state, or any error conditions. This is extremely thin for a tool with no safety annotations.

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

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

The description is a single concise sentence that is front-loaded with the verb and resource. Every word contributes meaning, 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 simplicity (one optional parameter, clear schema, output schema present), the description is minimally viable but still leaves gaps. It does not mention that setting/queries apply to a movie frame, prerequisites, or the format of the query result. The description is adequate for a trivial tool 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?

Schema coverage is 100% and the parameter description explicitly explains that omitting 'frame_number' queries the current frame, while providing it jumps to that frame. The tool description adds no additional parameter semantics beyond the schema, so the baseline of 3 applies.

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

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

The description clearly states the tool's function with a specific verb ('Sets or queries') and resource ('current frame'). It distinguishes itself from sibling navigation tools like 'forward' and 'backward' by indicating that this tool sets/gets an arbitrary frame rather than stepping through frames.

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 prerequisites (e.g., a movie must be loaded) or when choosing this over sibling commands like 'mplay' or 'forward' is appropriate. The schema is the only source of usage context, not the description.

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 burden. It indicates state change ('toggles') but lacks details like whether it returns current state or side effects.

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

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

Extremely concise (two words), front-loaded with action and target.

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

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

Tool is simple with no parameters and output schema exists, so description is adequate for use.

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

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

No parameters, so baseline 4 applies. Schema coverage is 100%.

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

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

Description clearly states action (toggles) and target (fullscreen mode). Distinct from sibling tools which are all other 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?

No explicit guidance on when to use vs alternatives, but for a simple toggle tool, it's adequate.

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 goes beyond the basic return value by explaining that it reports sequence-to-residue-number alignment and chain breaks, with reasoning about PDB numbering and unmodelled loops. This adds meaningful behavioral context. It does not discuss failure modes or side effects, but for a simple read-only retrieval, it is quite transparent.

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

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

The description is concise, consisting of three sentences. The first sentence is direct and operational. The second sentence adds key behavioral details, and the third provides explanatory context. While the third sentence could be shorter, it earns its place by clarifying the significance of the alignment and gaps. No redundancy or fluff.

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 an output schema exists and the parameter schema is rich, the description doesn't need to explain return types. It adequately covers purpose, prerequisites, and key behavioral nuances. However, it does not explicitly address edge cases like invalid chain names or multiple chains, though these may be handled by the output schema. Overall, it is complete for a straightforward retrieval tool.

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

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

Schema description coverage is 100%, so both parameters (obj_name and chain) already have descriptions in the schema. The tool description does not add parameter-level detail beyond the schema; it only mentions 'loaded structure' and 'residue numbers' in general terms. Since the schema does the heavy lifting, a baseline score of 3 is appropriate.

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

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

The description clearly states the tool returns the amino-acid sequence in FASTA format with a specific verb and resource ('Returns the amino-acid sequence of a loaded structure'). It also mentions additional reporting of sequence alignment and chain breaks, making the purpose specific. However, it does not explicitly distinguish itself from sibling tools, though its function is unique among them.

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

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

The description implies when to use the tool (when you need the sequence of a loaded structure) and mentions a prerequisite ('loaded structure'), but it does not explicitly state alternatives or contrast with other tools. The 'Both matter' paragraph explains why the alignment and gaps are important, which helps contextualize usage, but there is no direct guidance on when to choose this over a sibling.

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

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

No annotations are provided, and the description only states the action itself. It does not disclose side effects, whether existing hydrogens are replaced, or any state changes, leaving behavioral characteristics largely hidden.

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

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

The description is a single, focused sentence with no redundancy. It is highly concise and front-loaded, putting the action and target first.

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 simple one-parameter interface and presence of an output schema, the description is minimally sufficient. However, it lacks usage context, alternative tool differentiation, and behavioral disclosures, creating a slight 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 schema fully documents the selection parameter with its default 'all' and description 'Where to add hydrogens.' The tool description adds nothing beyond the schema, so the baseline score of 3 applies.

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

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

The description uses a specific verb ('Adds') and resource ('hydrogens') plus target ('to a selection'), clearly conveying the operation. It doesn't distinguish from the sibling h_fill, but the core purpose is unambiguous.

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

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

No guidance is given about when to use h_add versus alternatives like h_fill, or any context about preparation steps or prerequisites. The description simply states the action without usage scenarios.

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

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

No annotations are provided, so the description must carry the behavioral transparency burden. It only states 'Shows help for a command' without disclosing details such as output format, side effects (if any), or state dependence. For a help tool, it is likely read-only, but the description gives no explicit behavioral context.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to the meaning: 'Shows help for a command.' It is appropriately sized for such a simple tool.

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

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

Given the tool's simplicity (one optional parameter, no annotations, but an output schema exists), the description is mostly complete. It clearly states the tool's purpose, and the parameter description covers the optional command. It could perhaps mention what kind of help is shown (e.g., usage, options), but the minimal context is sufficient for a help command. The output schema likely defines the return format, so the description need not explain it.

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

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

Schema description coverage is 100%: the parameter 'command' is described as 'PyMOL command to describe. Omit for general help.' This fully clarifies the parameter's meaning and default. The tool description itself adds no additional parameter semantics, but the schema already covers it, so a baseline score of 3 is appropriate.

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

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

The description 'Shows help for a command' uses a specific verb ('shows') and a clear resource ('help for a command'). It clearly distinguishes this tool from sibling tools like 'execute_pymol_command' or specific display commands, as it is the designated help facility.

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

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

Usage is implied: use this when you need help on a PyMOL command. However, the description itself does not explicitly state when to use it or mention alternatives, though the parameter description adds 'Omit for general help.' This provides context but not explicit guidance on alternatives or exclusions.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It clearly states the tool operates on the editor pick rather than a selection and explains a common failure mode. However, it does not explicitly describe side effects (e.g., structure modification) or reversibility, though the operation is implied.

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 three concise sentences with no filler. The first sentence provides the core purpose, the second details usage constraints and a pitfall, and the third names the alternative tool. Every sentence 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?

The description fully explains the tool's unique requirement (editor pick), prerequisite (atom picked in GUI), a common error, and the alternative tool for selection-based additions. Since an output schema exists, return values need not be explained. This is complete for a simple utility.

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 (100% coverage baseline is 4). The description adds valuable context by stating that it takes no selection and explaining that passing a selection would incorrectly land in the quiet argument and fail. This goes beyond the empty schema, earning a 5.

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 fills open valences on the currently picked atom with hydrogens, a specific verb+resource. It also explicitly distinguishes itself from the sibling h_add tool, which adds hydrogens to a selection.

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 states when to use this tool (requires an atom picked in the GUI, takes no selection) and directs users to h_add for selection-based additions. It also warns about passing a selection causing a specific error, preventing misuse.

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 is the sole source of behavioral info. It discloses only the basic action and lacks details about reversibility, side effects, or selection defaulting to 'all'. The agent cannot tell if hidden representations are merely toggled off or if there are any lasting consequences.

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

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

The description is a single, front-loaded sentence with no filler. It is appropriately concise for a simple tool, though it sacrifices informative detail that would improve other dimensions.

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 and fully described parameters, so the description need not cover return values. It adequately states the core function, but the absence of usage context, exclusions, and behavioral detail—compounded by missing annotations—leaves the description minimally viable rather than 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?

Both parameters have schema descriptions, giving 100% schema coverage. The description adds no meaningful parameter semantics beyond the schema; 'given selection' is already captured by the schema's 'PyMOL selection string.' Baseline 3 applies.

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

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

The description clearly states the action: 'Hides a graphical representation for a given selection.' It identifies the resource (graphical representation) and the scoping (selection). It does not explicitly differentiate from sibling tools like delete or remove, but the verb 'hide' conveys a visibility toggle rather than destruction.

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 show, delete, or remove. The description merely states the action without context, exclusions, or alternative tool recommendations.

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

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

With no annotations, the description carries the full burden of disclosure. It thoroughly describes the visual outcome: exact colors for amino acid categories, a white cartoon beneath a semi-transparent surface, and ligand rendering with yellow carbons. It does not mention reversibility or interaction with existing display styles, but the main behavioral effect is well specified.

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, front-loading the core purpose and then listing color mappings in a clear, scannable format. Every sentence adds specific visual information without unnecessary padding.

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 visualization tool, the description covers the key visual outcomes and distinguishes the tool from numerous sibling views. It does not mention prerequisites like a loaded structure, but that is implied by the obj_name parameter. An output schema exists, so return values need not be described.

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

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

The only parameter, obj_name, is already fully described in the schema with an example, providing 100% schema coverage. The description adds no extra parameter information, so the baseline of 3 is appropriate.

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

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

The description starts with a specific verb and resource: 'Colors the molecular surface by amino acid hydrophobicity.' It clearly defines the tool's function and the detailed color mapping distinguishes it from other view tools such as electrostatic_view or bfactor_view.

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 a hydrophobicity-colored surface is desired) but provides no explicit guidance on alternatives or exclusions. It does not mention other view tools or state when not to use this visualization.

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

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

With no annotations provided, the description fully carries the transparency burden. It explains the computation technique (comparing solvent-accessible area free and bound), the ranking by buried surface, and the chemistry breakdown. It also communicates interpretive caveats ('These are guides... not a verdict'), which is useful behavioral context beyond basic read-only 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 structured with a clear lead sentence, a method paragraph, interpretation guidance, and a pointer to a sibling tool. It is somewhat longer than minimal but every sentence contributes value: measurement definition, output details, thresholds, caveat, and alternative. Front-loaded with the main purpose, so it is effective without being wasteful.

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

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

Given the tool's moderate complexity and the presence of an output schema, the description is complete. It explains what is measured, how (SASA comparison), what is reported (buried surface area, residue ranking, chemistry), and how to interpret the numbers. It also directs users to contact_report for specific interaction details, covering the necessary context for correct invocation and result interpretation.

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

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

Schema description coverage is 100%, so the parameters are already well-documented. The description adds context about the overall method (SASA comparison) but does not add meaning beyond the schema for individual parameters like chain_a, chain_b, or max_residues. It does not repeat or enrich parameter details, so the baseline of 3 is appropriate.

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

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

The description opens with a specific verb+resource: 'Measures how large a protein-protein interface is, and which residues form it.' It clearly distinguishes itself from the sibling tool contact_report by explicitly directing users there for hydrogen bonds and salt bridges. The method (buried surface area comparison) and outputs (residue ranking, chemistry breakdown) are specific.

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 usage guidance: it gives numerical interpretation thresholds (under ~400 A^2 suggests crystal packing, over ~1000 A^2 suggests a specific association) and states that for interaction pairs (hydrogen bonds, salt bridges) one should 'use contact_report on the same two chains.' This offers an alternative and helps decide when to use this tool versus a sibling.

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 provides rich visual details (colors, surface patch, sticks, H-bonds within 4Å) that let the agent predict the output. It does not mention potential side effects like modifying existing representations or creating objects, but for a visualization tool this is a minor gap, and the description is otherwise transparent about what the user will see.

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 three sentences: a clear main purpose followed by two compact sentences of visual specifics. It is front-loaded and every sentence adds useful information without redundancy or fluff.

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