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

With no annotations, the description carries full burden. It discloses that it works on two file types, the default ligand_index, and returns a structured report. Does not disclose potential side effects, permissions, or limitations beyond the basic usage pattern.

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

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

Two sentences, front-loaded with main purpose and interaction types, followed by parameter usage. No redundant information. Efficient 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?

With three parameters, no annotations, and no output schema, the description covers the two main use cases and parameter meanings. It lacks explicit mention of return format details, but 'structured interaction report' provides reasonable clarity. Could be more thorough but adequate.

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

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

Schema coverage is 0%, but the description adds meaning to all three parameters: input_path files type (complex or pose-viewer), ligand_asl for single complex, ligand_index for pose-viewer. It gives context beyond the schema, though the format of input_path is implied rather than explicit.

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?

Clearly states the tool analyzes protein-ligand interactions and lists specific interaction types (hydrogen bonds, salt bridges, pi-pi stacking, pi-cation). It separates use cases (pose-viewer vs complex) and distinguishes from sibling tools like ligand_interaction_diagram by mentioning it returns a structured report.

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

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

Provides explicit guidance on when to use ligand_index vs ligand_asl based on file type (pose-viewer vs complex). Clearly explains the default for ligand_index. However, it does not discuss when not to use this tool or mention alternative tools.

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

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

With no annotations, the description carries full burden. It discloses that the job directory and partial outputs remain, which is important behavioral context beyond the basic action. Does not mention permissions or reversibility, but is generally 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 with two sentences. The second sentence adds necessary detail without redundancy. Could be slightly improved by front-loading parameter info, but it is efficient.

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

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

For a simple single-parameter tool with no annotations or output schema, the description covers the action and outcome but lacks parameter guidance. It is adequate but has 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?

Schema description coverage is 0%, so the description must compensate for the parameter. However, the description does not mention 'job_id' or any parameter, leaving the agent to infer from the schema alone, which only provides a title.

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 'Stop a running job', using a specific verb and resource. It distinguishes itself from sibling tools like list_jobs, get_job_status, etc., which do not perform cancellation.

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 vs alternatives (e.g., checking status first), nor are there any exclusions or prerequisites mentioned. The description implies usage but does not give explicit context.

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

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

No annotations are provided, so the description carries the full burden. It discloses synchronous execution and the return format (path to CSV). However, it omits details like error handling, file size limits, or required permissions.

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 at two sentences without wasted words. However, it could incorporate parameter detail without sacrificing brevity.

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

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

With two parameters (one required), no output schema, and many siblings, the description lacks essential details such as input format, handling of output_path, and expected data volume. It is incomplete for reliable agent usage.

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

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

Schema description coverage is 0%, but the description does not explain the parameters. It fails to specify what input_path should point to (e.g., file path, SMILES, SDF) or how output_path behaves when null. This leaves critical gaps for an agent.

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 computes 2D physicochemical descriptors (e.g., MW, logP, TPSA) using Canvas, which distinguishes it from sibling tools like glide_dock or jaguar_qm. The verb 'compute' and resource 'descriptors' are specific and 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 mentions 'Synchronous' to imply blocking behavior, but does not provide explicit guidance on when to use this tool versus alternatives (e.g., qikprop). No when-not-to-use or caveats are given.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It explains that the tool is long-running, asynchronous (returns a job_id), and writes output to a specific file (<jobname>-out.maegz in the job directory). This provides sufficient transparency about the execution model and output, though it omits details like success/failure indicators.

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 two efficient sentences. It front-loads the purpose, then gives critical preconditions and behavioral notes. Every sentence adds value without redundancy.

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

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

Given the absence of annotations and output schema, the description covers the essential aspects: purpose, input requirements, supported formats, execution model, and output location. It lacks details on retrieving results via job_id or troubleshooting, but overall it is sufficiently complete for a straightforward long-running job.

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

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

The input schema has 0% description coverage, meaning the schema itself provides no parameter explanations. The description mentions the input path implicitly ('Input must contain explicit hydrogens') and the jobname in the output filename, but does not explain parameters like max_conformers or optimize. Thus, the description adds only minimal parameter context.

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

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

The description clearly states the tool's purpose: 'Generate a conformer ensemble for ligands with ConfGen.' It uses a specific verb (generate) and resource (conformer ensemble), and references the specific program ConfGen. Among siblings, no other tool explicitly generates conformer ensembles, so it is well-distinguished.

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

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

The description provides a clear precondition: 'Input must contain explicit hydrogens (run ligprep first).' It also notes that the tool is long-running and returns a job_id. However, it does not explicitly state when not to use it or mention alternative tools for related tasks, though no direct alternative is present among siblings.

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 that input format is inferred from extension and that the output path is returned, but lacks details on error handling, default behavior for optional output_path, or whether the tool is destructive.

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

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

The description is two sentences long, directly relevant, and contains no unnecessary words. It front-loads the main action and then adds key details.

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

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

Given the absence of output schema and 0% parameter coverage, the description minimally covers the conversion action and return value but omits important behavior like handling of unsupported formats or the effect of a null output_path.

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

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

Schema coverage is 0%, so the description must compensate. It lists supported formats but does not explain each parameter individually, such as that output_format must be one of the listed formats or that output_path is optional and defaults to a generated path.

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 'convert' and the resource 'structure file', lists supported formats explicitly, and distinguishes from sibling tools like merge_structures or split_structures by focusing on format conversion.

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 converting structure file formats but does not explicitly state when to use this tool versus alternatives, nor does it mention when not 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?

Without annotations, the description carries the full burden. It transparently lists the reported information and notes GPU limitations (NVIDIA required, Apple Silicon unsupported), though it does not explicitly state if the tool is read-only or has side effects.

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

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

Three sentences, each earning its place: first states purpose, second gives usage advice, third adds important context. Front-loaded and efficient.

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

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

Given no parameters, no output schema, and no annotations, the description fully explains the tool's function, when to use it, and key constraints, making it complete for an introspective 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?

No parameters exist, so the description adds no parameter info. Per rules, zero parameters score baseline 4.

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

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

The description clearly states the tool reports Schrödinger installation details such as root path, release/build, licensed products, job hosts, and GPU availability, distinguishing it from sibling task-oriented tools.

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

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

Explicitly advises calling this tool first to confirm the suite is found and to see licensed workflows. Also mentions GPU requirements for specific workflows, providing clear when-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?

No annotations provided, so description must carry the burden. It discloses long-running async behavior (returns job_id) and output file with properties. However, it does not mention side effects, authentication needs, or what exactly happens during processing.

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

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

Three sentences, front-loaded with purpose, then input format, then async/output. No fluff, but could be more concise by merging sentences or adding parameter hints.

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

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

With 5 parameters, no output schema, and no annotations, the description only covers input format and async behavior. Missing explanations for ph, ph_tolerance, max_states, and exact return value structure. Incomplete for a complex computational tool.

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

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

Schema description coverage is 0%, so description should compensate. It only adds meaning to input_path ('non-Maestro inputs auto-converted') and output_name ('states with pKa/penalty properties'), but ignores ph, ph_tolerance, and max_states entirely.

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 enumerates protonation/tautomeric states and estimates pKa for ligands using Epik. This specific verb-resource combination distinguishes it from sibling tools like ligprep or glide_dock.

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 on when to use this tool vs alternatives. The description mentions input format and auto-conversion but does not specify prerequisites, when not to use, or compare to similar tools like ligprep or jaguar_qm.

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

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

No annotations are provided, so the description carries the full burden. It states the download source and return value but does not disclose potential side effects like file overwriting or internet dependency. It is adequate but not comprehensive.

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

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

The description is two sentences with no fluff. Every sentence provides essential information: what the tool does, an example, the return type, and a recommended next step.

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 download tool, the description covers the core functionality and next steps. It lacks details on error handling or output behavior, but given the low complexity, it is reasonably 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 0%, and the tool description does not explicitly explain the parameters. The pdb_id parameter is clear from the example, but output_dir is only hinted at by its name and default value. The description adds minimal value beyond the parameter names.

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

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

The description clearly specifies the action: download an experimental structure from RCSB PDB by its 4-character ID. It provides an example ('1HSG') and distinguishes the tool from siblings by mentioning the next step (use protein_prepwizard).

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 by suggesting to use protein_prepwizard afterward, implying a workflow. However, it does not explicitly exclude alternatives or state when not to use the tool.

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

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

No annotations provided, so the description must disclose behavior. It explains the properties parameter format, output format options, and that it returns a file path. However, it omits side effects (e.g., whether it modifies input), permissions, or error conditions, leaving gaps.

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

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

The description is three sentences, front-loaded with the core purpose, and contains no fluff. Every sentence adds essential 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 complexity (4 parameters, no enums, no output schema), the description covers input, parameters, and return value. It distinguishes from siblings by noting 'every structure in a file.' It lacks details on supported file types or error handling but is mostly complete for typical 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?

Schema description coverage is 0%, so the description compensates well by explaining the 'properties' format ('all' or comma-separated), implying output_format options (PDF/HTML from context), and that output_path is the report location. It adds meaning beyond the bare 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 specifies the tool builds a 2D structure report for all structures in a file, with labeled properties (e.g., docking scores). It mentions PDF or HTML output, distinguishing it from sibling tools like render_2d_structure that likely handle single structures.

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 states the tool is 'Great for sharing docking/screening results,' implying suitable use cases but does not explicitly exclude alternatives or provide when-not-to-use guidance, despite siblings like summarize_docking and render_2d_structure existing.

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

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

No annotations are provided, so the description carries full burden. It discloses the tool is long-running, returns a job_id, and the grid lands in the job directory. It explains the two binding-site specification methods. However, it does not mention return value format, potential errors (e.g., if both center and ligand_ref are given), or any permissions needed.

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

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

The description is three well-structured sentences: purpose, site specification options, and behavior note. No wasted words, front-loaded with the main 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?

With 6 parameters, no output schema, and no annotations, the description should be more complete. It lacks explanation for required 'receptor_path' and the numeric parameters 'inner_box' and 'outer_box' (units, defaults). It also does not specify what happens if both center and ligand_ref are provided (likely an error or one takes precedence). The return value is mentioned as job_id but not structured.

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

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

Schema coverage is 0%, so the description should compensate. It explains 'center' and 'ligand_ref' (with syntax hints) and mentions 'grid_name'. But it does not explain 'receptor_path', 'inner_box', or 'outer_box'—leaving these to the schema titles. The description adds value for two parameters but not the rest.

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

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

The description clearly states it builds a Glide docking grid from a prepared receptor, specifying the binding-site center via 'center' or 'ligand_ref'. It distinguishes itself from sibling tools like glide_dock, which uses the grid, and other unrelated tools.

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

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

The description provides clear context: use this tool to build a grid from a prepared receptor, with two ways to specify the binding site. It mentions it's long-running and returns a job_id, and that the grid is for glide_dock. However, it does not explicitly state when not to use it or compare to 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. It describes fetching outputs and final state, which implies a read operation, but does not disclose authentication needs, rate limits, or what happens if the job is not finished. Adequate for a retrieval task but lacks depth.

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

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

Two sentences, no wasted words. The main purpose is front-loaded, and the follow-up guidance is placed efficiently.

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

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

The description covers what the tool returns (list of files, final state) and provides a follow-up for docking jobs. It lacks output schema and details on error handling or output format, but for a simple retrieval tool, it is reasonably 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?

With 0% schema description coverage, the description must compensate but does not elaborate on job_id. The parameter is self-explanatory, but the description adds no additional meaning or format details beyond the schema field name.

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 outputs of a finished job, listing produced files and final state. It distinguishes from siblings like get_job_status (status only) and summarize_docking (follow-up for docking jobs).

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 when to follow up with summarize_docking for docking jobs, providing context and an alternative. It implies the tool is for finished jobs but does not explicitly state when not to use it, such as for running jobs.

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

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

No annotations provided, so description carries full burden. It discloses what is returned but does not mention prerequisites, side effects, or rate limits. Adequate but not comprehensive.

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

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

Two sentences, no wasted words. Front-loaded with the core action and returned data.

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

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

For a simple tool with one parameter and no output schema, the description covers the key return fields. Could be more detailed about the log tail or response format, but 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?

Input schema has 0% description coverage for the single parameter job_id. Description adds no extra meaning about the parameter's format or constraints; only implies it's the job identifier.

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?

Clearly states the tool checks a submitted job and lists the returned fields (state, elapsed time, exit code, log tail). Distinguishes from siblings like list_jobs and get_job_results.

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

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

Explicitly says 'Poll this after submitting any long-running workflow,' guiding when to use it. Does not mention when not to use or alternatives, but the context is clear.

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

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

No annotations provided, so description carries full burden. It discloses long-running nature, returns a job_id, and mentions the output file pattern. It does not discuss permissions or side effects, but the async behavior is well-covered.

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

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

Three sentences with no redundancy. Front-loaded with main action, then parameter guidance, then async flow. Every sentence adds value.

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

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

Given complexity (5 params, async, output is job_id, need another tool for results), description covers essential workflow. However, misses details on poses_per_ligand and njobs, and lacks output schema to explain return values. Could be more 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 0%, so description must add value. It explains precision (SP vs XP) and that ligands_path should be LigPrep-prepared. It does not explain grid_path, poses_per_ligand, or njobs. Adds meaning for 2 of 5 parameters, partially compensating.

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: 'Dock prepared ligands into a Glide grid and score them.' It specifies key inputs and the async nature, distinguishing it from sibling tools like generate_glide_grid and summarize_docking.

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 context on when to use: after grid generation and ligand preparation. It mentions that ligands_path should be LigPrep-prepared and that after docking, summarize_docking should be used on the output. Does not explicitly state when not to use, but implicit guidance is strong.

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 alone must disclose behavioral traits. It mentions that the tool is 'long-running' and 'returns a job_id,' indicating asynchronous execution, but it does not describe side effects, data modification, error behavior, or required permissions. This is insufficient for a complex computational 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 three sentences: first defines purpose, second details parameters, third gives behavioral note. Every sentence adds value with no redundancy. It is appropriately front-loaded with the tool's main function.

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 6 parameters, no output schema, and no annotations, the description covers the tool's core purpose and key inputs but lacks details on return values beyond job_id, error handling, and output format. It does not fully compensate for the missing structured information.

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

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

Schema coverage is 0%, so the description must compensate. It explains that 'calculation' is one of three options and that 'input_path' accepts structure files or .in files. Other parameters (basis, functional, charge, multiplicity) are listed with defaults but not elaborated. This provides partial but incomplete guidance.

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

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

The description clearly states it runs a Jaguar quantum-mechanics calculation on a small molecule. It specifies the calculation types ('optimization', 'energy', 'frequency') and accepted input formats (structure file or .in file). This distinguishes it from sibling tools like 'compute_descriptors' or 'epik' which have different purposes.

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 to 'keep systems small (a few dozen atoms) on CPU-only hardware,' providing explicit context for appropriate use. However, it does not explicitly state when not to use this tool or mention alternative tools for larger systems or different hardware, which would improve the score.

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

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

No annotations are provided, so the description bears full responsibility. It discloses the inline display of PNG and file writing, but does not explicitly state that the operation is non-destructive or mention error conditions. However, as a rendering tool, non-destructiveness 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 a single sentence that efficiently conveys the core functionality and output details, though it could be slightly reorganized for readability. No wasted words.

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

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

Given the lack of output schema and the complexity of four parameters (one required), the description is incomplete. It does not clarify the return format (whether it returns image data or just writes to file) or handle error cases, though the essential function is covered.

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

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

Schema description coverage is 0%, and the description adds no explanation for the four parameters (input_path, ligand_asl, ligand_index, output_path). It only mentions input and output in general terms, failing to help an agent understand parameter usage.

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

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

The description clearly states it renders a 2D ligand-interaction diagram as a PNG, specifies the input type (protein-ligand complex or Glide pose-viewer file), and distinguishes from siblings like render_2d_structure and analyze_interactions by focusing on interaction visualization.

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

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

The description implicitly tells when to use this tool (to obtain a visual diagram of interactions with color-coded highlights and legend), but does not explicitly state when not to use it or list alternatives. Sibling tools provide context for differentiation.

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

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

No annotations are provided, so the description carries the full burden. It discloses the asynchronous nature (long-running, returns job_id) and that output is written to a file in the job directory. This is sufficient for an agent to understand the tool's behavior, though it could mention if any destructive actions occur.

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, well-organized with critical information front-loaded. Every sentence adds value: first sentence explains the process, second sentence clarifies the asynchronous behavior and output retrieval.

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

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

The tool has no output schema, but the description explains the return value (job_id) and how to locate results (via get_job_results). It covers the main aspects, though more detail on the output file format or structure would enhance 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?

Schema coverage is 0%, so the description must compensate. It mentions input_path by format, use_epik, ph, ph_tolerance, max_stereoisomers, and output_name implicitly through the description of preparation steps and output handling. However, it does not explicitly explain each parameter's role or default behavior, leaving room for ambiguity.

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

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

The description clearly states the tool's purpose: prepare ligands for docking by adding hydrogens, generating ionization/tautomeric states, enumerating stereoisomers, and producing optimized 3D structures. It also lists accepted input formats (.smi/.csv/.sdf/.mae), distinguishing it from siblings like epik or confgen that focus on specific sub-steps.

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 notes the tool is long-running and returns a job_id, with output retrievable via get_job_results. While it doesn't explicitly state when to use or not use alternatives, the context implies usage before docking, and the reference to get_job_results guides the agent on next steps.

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

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

No annotations are provided, so the description carries full burden. It only states basic behavior (list, order, filter) but does not disclose whether the operation is read-only, if there is pagination, rate limits, or what fields are returned. The transparency is insufficient given the lack of annotations.

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

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

The description is a single, front-loaded sentence that efficiently conveys the core purpose and optional filter. Every word earns its place; 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?

For a simple listing tool with no output schema, the description covers the basic operation and filter option. However, it omits important context like whether pagination exists, what the return format is (list of job IDs or full objects), and if there are any limits. This is adequate but not 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 coverage is 0% for the 'state' parameter, but the description adds significant meaning by listing valid enum values ('submitted/running/completed/failed/canceled'), which the schema lacks. This enables proper usage beyond the schema's bare types.

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 'List known async jobs, most recent first' with a specific verb (list) and resource (async jobs), and mentions an optional filter. This differentiates from sibling tools like get_job_status (single job) and cancel_job (cancel operation).

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

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

The description implies usage for listing jobs but does not explicitly state when to use this tool versus alternatives like get_job_status for specific jobs. No when-not or alternative guidance is provided.

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

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

With no annotations, the description carries full burden for behavioral disclosure. It only says 'concatenate', omitting details like whether the output file is overwritten, error handling, supported file formats, or if order is preserved. This leaves significant ambiguity.

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

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

The description is a single, clear sentence with no unnecessary words. It could be slightly expanded for completeness, but it is 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?

Given the tool has two parameters and no output schema, the description is too sparse. It does not specify file format expectations, handling of multiple inputs, or output structure. The agent lacks critical context to use it correctly.

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

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

Schema description coverage is 0% for both parameters. The description does not mention input_paths or output_path at all, so it adds no meaning beyond the raw schema. The agent must infer parameter roles from names alone.

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 'concatenate' and the resource 'several structure files into one multi-structure file'. It is specific but does not differentiate from sibling tools like 'split_structures' or 'convert_structure', which have opposite or similar purposes.

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 'split_structures' or 'convert_structure'. No exclusions, prerequisites, or contextual hints are given.

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

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

Without annotations, the description discloses key behavioral traits: it is long-running, returns a job_id, and output structures contain the binding free energy. This covers async behavior and output format, though it does not mention cancellation 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?

The description is two sentences with no redundancy, front-loading the purpose and then adding key details. Every sentence adds value.

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

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

Given no output schema, no annotations, and three parameters, the description leaves gaps: it explains only one parameter, does not cover error handling, prerequisites, or how to retrieve results beyond mentioning job_id. More detail is needed for 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?

Schema description coverage is 0%, so the description must explain parameters. It only describes input_path (file format), but does not explain ligand_asl or minimize (e.g., when to set them, what they control). This is insufficient for an agent to use the tool correctly.

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

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

The description clearly states the tool rescored a receptor-ligand complex or Glide pose-viewer file with Prime MM-GBSA to estimate binding free energy. It specifies input formats and output, distinguishing it from siblings like compute_descriptors or glide_dock.

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 it is for rescoring docking poses via the mention of Glide pose-viewer files, but does not explicitly state when to use this tool versus alternatives like compute_descriptors or analyze_interactions, nor does it provide 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 burden. It discloses that the tool is long-running, returns a job_id, and the prepared structure is named <output_name>. It also lists the computational steps (Epik, Prime, minimization), but does not detail failure modes, authentication needs, or rate limits.

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 no redundant information. The first sentence packs the core purpose and steps, the second lists input formats, and the third notes key behavioral traits (long-running, job_id). Information is front-loaded and efficiently presented.

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 lack of output schema or parameter descriptions, the description provides reasonable context: input formats, key operations, and return behavior. However, it omits prerequisites (e.g., valid structure, licensing) and expected execution time, which would be helpful.

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

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

The schema has 0% description coverage, so the description must compensate. It maps to some parameters (fill_sidechains, fill_loops, epik_ph, minimize) but does not explain input_path or output_name. The description adds meaning but lacks detail on default values and parameter ranges.

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 prepares a protein structure for docking, listing specific steps (assign bond orders, add/optimize hydrogens, set protonation states, fill missing side chains/loops, minimize). It also specifies accepted input formats (.pdb/.mae/.cif), distinguishing it from sibling tools like fetch_pdb or convert_structure.

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 docking preparation but does not explicitly state when to use this tool versus alternatives like ligprep or analyze_interactions. No exclusions or when-not-to-use guidance is provided, making the usage contextual but not prescriptive.

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 discloses that the tool is long-running and returns a job_id, which is critical behavioral info given no annotations. It also describes the output format (CSV and annotated .mae). No contradictions with annotations since none exist.

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 paragraph of four sentences, flowing logically from purpose to usage. It is concise and front-loads the main action, though it could be further structured with bullet points for clarity.

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

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

For a tool with 3 parameters and no output schema, the description covers purpose, async behavior, and output handling. However, it omits explanation of the 'fast' parameter and could provide more details on supported input formats beyond 'most structure formats'.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning for input_path (accepts most structure formats) and outname (results land as <outname>.CSV), but does not explain the 'fast' boolean parameter.

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

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

The description clearly states that the tool predicts ~50 ADMET properties for ligands using QikProp, with a specific verb and resource. It also notes that it accepts most structure formats, distinguishing it from sibling tools like compute_descriptors which compute general descriptors.

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 explains that the tool is long-running and returns a job_id, and advises using structure_info on the output .mae to read the results. This provides clear guidance on how to handle the asynchronous workflow, though it does not explicitly compare to 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?

The description discloses that the tool writes PNG to disk and shows output inline, but does not explain the return format, behavior with conflicting inputs, or the effect of max_structures. No annotations are present to supplement.

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 (two sentences) and front-loaded with the main purpose. However, it could be structured with bullet points for clarity.

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 five parameters and no output schema, the description covers core functionality but omits details on max_structures, default output path, and inline display semantics. The sibling tool list is large but no differentiation is provided.

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

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

With 0% schema description coverage, the description adds meaning for smiles, input_path, and legend_property, but does not explain max_structures or output_path. The description provides partial clarity 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 renders molecules as 2D PNG images inline, specifying the two input options (smiles or input_path). It differentiates from siblings by focusing on 2D structure rendering, but does not explicitly contrast with similar tools like generate_2d_report.

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 explains when to use smiles vs input_path and gives an example for legend_property, but lacks guidance on when to use this tool over alternatives (e.g., generate_2d_report) or contexts to avoid.

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 discloses key behaviors: it ranks structures, writes results to a .maegz file with Shape_Sim scores, is asynchronous (returns job_id), and requires prepped 3D inputs. With no annotations, it covers the major behavioral traits but omits details like whether input files are modified or any permission requirements.

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

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

The description is two sentences with no extraneous information. The first sentence clearly states the action and result, and the second adds critical context (file requirements, asynchrony, output format). Every sentence serves a purpose.

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

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

Given no output schema and 4 parameters, the description provides sufficient context for an agent to use the tool. It covers input format, process, output location, and side effects (long-running). The only gap is the undocumented njobs parameter, but overall the description is complete enough 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 description explains query_path and screen_path as 3D structure files and links jobname to output naming, adding meaning beyond the schema. However, njobs (a parameter) is not described, and schema coverage is 0%, so the description does not fully compensate for the missing schema documentation.

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

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

The description clearly states the tool performs shape-based similarity screening, ranking structures by shape similarity to a query. This specific verb+resource combination distinguishes it from siblings like glide_dock (docking) or compute_descriptors (descriptors), leaving no ambiguity about 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 provides some usage context, noting that both inputs must be 3D structure files and that ligands should be prepared first. It also mentions the tool is long-running and returns a job_id. However, it does not explicitly contrast with alternatives (e.g., when to use shape_screen vs. sitemap or confgen), leaving the agent to infer use cases.

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

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

With no annotations, the description carries full burden for behavioral disclosure. It clearly states the tool is long-running, returns a job_id, and writes output files (site maps, SiteScore/Dscore). This adds significant value beyond the basic 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?

Two sentences, no filler. The first sentence states purpose, the second provides key usage context. 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?

The tool has 3 parameters, no output schema, and no annotations. The description covers input format, async nature, and output files, but neglects parameter details. Given the complexity, it is minimally complete but has clear gaps.

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

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

Schema coverage is 0%, so the description must elaborate on parameters. It only indirectly mentions that 'input_path' is a prepared structure, but fails to explain 'num_sites' or 'jobname'. This leaves gaps for effective tool invocation.

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 detects and scores potential ligand-binding sites using SiteMap, a specific verb+resource. It distinguishes from siblings by specifying a unique function, but does not explicitly contrast with similar tools like 'analyze_interactions' or 'glide_dock'.

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 context on input requirements (prepared .mae structure) and behavior (long-running, returns job_id). However, it lacks explicit guidance on when not to use this tool or mention of alternative tools for similar tasks.

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

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

With no annotations, the description carries the full burden. It states it generates single-conformer structures and writes to a file, which implies a write operation. However, it doesn't explicitly disclose whether the operation is safe (non-destructive) or other behavioral traits, but it is reasonably transparent for a file-creation 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?

Three sentences, front-loaded with the action, no wasted words. The structure is clear and efficient.

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

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

Given 5 parameters, no output schema, and no annotations, the description provides the essential idea but lacks details on parameter constraints (e.g., valid output formats, default behavior). It is sufficient for basic understanding but not fully complete for complex usage.

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

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

The schema has 0% description coverage, so the description must compensate. It explains that 'smiles' is a list of SMILES strings, mentions output format by referring to 'write them to one file', but does not detail 'output_format', 'titles', or 'require_stereo'. Adds some meaning but is not comprehensive.

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 'generate' and the resource '3D structures from SMILES', and distinguishes this tool from ligprep by mentioning it is for quick 3D embedding vs. full ligand preparation.

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

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

Explicitly says when to use this tool ('Good for quick 3D embedding') and when to use an alternative ('for full ligand preparation... use the ligprep tool instead'), providing clear 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 bears full burden for behavioral disclosure. It mentions returning a list of files with titles, but omits details on original file handling, default output directory, overwrite behavior, supported input formats, and error conditions.

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

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

Two sentences, minimal and to the point; every word contributes to the tool's purpose and output. No wasted text.

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

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

Despite describing the return list, the description is incomplete for a file-splitting tool. Missing input file requirements, output directory behavior (default to input path?), and output format meaning. With no output schema, more detail is needed.

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

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

Schema coverage is 0% and the description adds no parameter details. Input_path, output_dir, and output_format are all undocumented, leaving the agent without guidance on required vs optional or format constraints.

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 ('Split'), the resource ('multi-structure file'), and the output ('one file per structure, returns list of written files with titles'), distinguishing it from siblings like merge_structures or convert_structure.

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

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

No explicit when-to-use or when-not-to-use guidance is provided. The description implies usage for multi-structure files needing splitting, but lacks alternatives or context vs. siblings.

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

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

Without annotations, the description should disclose behavioral traits. It mentions the tool returns specific properties, but does not clarify if it is read-only, destructive, or requires authentication. The non-destructive nature is implied but not explicit.

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 very concise with two sentences, front-loaded with key actions and outputs. Every part provides useful information without redundancy.

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

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

The description lists several specific return values (atom counts, charge, etc.) but refers vaguely to 'a sample of named properties' without enumerating them. Given no output schema, a bit more detail on properties would improve completeness.

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

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

The input schema has no parameter descriptions (0% coverage), and the tool description does not mention or explain the parameters at all. It fails to add meaning beyond the schema's basic types and default values.

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

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

The description clearly states the tool inspects a structure file, listing specific output items like atom/bond counts, charge, molecular weight, etc. It differentiates from sibling tools by focusing on inspection rather than conversion, docking, or analysis.

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 inspecting structure files but does not explicitly state when to use this tool over alternatives like analyze_interactions or convert_structure. No when-not or alternative guidance is provided.

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

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

Discloses core behavior: parsing, ranking, sorting by score (lower better). No annotations exist, so description carries full burden. Could mention error handling for missing files, but overall clear.

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

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

Two concise sentences with no redundant information. Front-loaded with core function.

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

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

Adequate but lacks parameter descriptions and explanation of 'key terms'. Return value mentioned (ranked table), but no details on structure. For a simple tool, somewhat incomplete.

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

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

Schema coverage is 0% and description does not explain pose_file or top_n parameters beyond what schema provides (title, default). Needs to specify expected file format or meaning of top_n.

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 verb 'Parse' and resource 'Glide pose-viewer file' and mentions output format. However, it does not explicitly differentiate from sibling tools like analyze_interactions, which may also analyze docking results.

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

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

No explicit when-to-use or when-not-to-use guidance. Usage is implied by the tool's function (need a pose-viewer file), but no alternatives or exclusions are mentioned.

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