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

No annotations are provided, so the description must fully disclose behavior. It describes the operation (calculate bounding box) and return type (dict with center and dimensions), but does not mention side effects, performance, or that the tool only reads the file without modifying it. It is adequate but not detailed.

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 exceptionally concise and well-structured: a one-line purpose followed by clear Args and Returns sections. Every sentence provides 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 tool's complexity (CAD file input, multiple siblings), the description covers input format restrictions and output structure comprehensively. It could mention potential error causes or file size considerations, but overall it provides sufficient context for an AI agent to use the tool correctly.

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

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

With 0% schema description coverage, the description adds significant meaning by specifying the input_file parameter as a path to a CAD file and listing supported formats (.fbx, .gltf, .obj, etc.). This far exceeds the bare schema, providing essential context for correct 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 'Calculate the bounding box of a CAD file' with a specific verb and resource. It distinguishes from the sibling 'calculate_bounding_box_kcl' by specifying CAD file formats, making the tool's 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 tells when to use the tool (when needing bounding box of a CAD file) and lists supported file formats. However, it does not explicitly mention when not to use it or direct users to the sibling 'calculate_bounding_box_kcl' for KCL files, missing a clear differentiation.

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

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

No annotations are provided, so the description carries full burden. It discloses the return format (dict with center and dimensions, or error message) and the unit_length parameter behavior. However, it doesn't disclose failure conditions, edge cases (e.g., what happens if both or neither inputs are valid), or any side effects. For a calculation tool with no annotations, 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 well-structured with clear Args and Returns sections, efficiently packed into a compact block. Every sentence adds value. Could be slightly tighter but is appropriately organized and readable.

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

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

An output schema exists, so return values need not be fully re-explained, but the description still provides a useful summary. The tool has only 3 parameters with a required field and an output schema, and the description covers the key semantics (input alternatives, unit choices, return shape). For a moderately simple operation, this 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%, so the description must compensate. It does explain unit_length (with the allowed values listed), kcl_code, and kcl_path with reasonable detail. However, it doesn't explain the mutually exclusive nature strongly (e.g., what if both are provided?) or give format hints for kcl_code. It compensates for the 0% coverage fairly well but could add precedence rules between the two inputs.

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 calculates the bounding box of a KCL model using a specific verb and resource. It distinguishes from siblings like calculate_mass, calculate_volume, and the CAD variant (calculate_bounding_box_cad) by specifying KCL models and mentioning the either/or input of kcl_code or kcl_path.

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 that either kcl_code or kcl_path must be provided, and clarifies what kcl_path should point to (a .kcl file or a directory containing main.kcl). This gives clear guidance on how to invoke the tool, though it doesn't explicitly state when to prefer this over calculate_bounding_box_cad.

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 that the tool returns either a dict with five keys or an error message on failure, which is helpful. However, it does not disclose whether file reads are read-only, whether there are any side effects, auth/permission requirements, or performance considerations for large files. The return-structure disclosure is decent but not deep.

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

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

The description is well-structured with an Args section listing each parameter, allowed values, and a Returns section. Each sentence earns its place. It's somewhat verbose (listing every allowed unit value for each parameter) but this is genuinely useful given the schema has no enum constraints. Could be slightly tighter but is appropriately organized 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?

The tool is moderately complex with 7 required parameters and an output schema. The description thoroughly documents every parameter with allowed values and the aggregate return structure. There is an output schema present, so return values don't need over-explanation. The main gaps are the lack of behavioral caveats (large file handling, read-only assumptions) and interaction effects between unit parameters, but for a calculation utility, coverage is solid.

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 provides 0% description coverage, so the description carries full parameter documentation. The docstring explains each of the seven parameters with allowed values/enumerations for the unit parameters and file formats. This adds significant value beyond the bare schema (which only has titles like 'Unit Area'). However, it doesn't clarify semantic relationships between parameters (e.g., that unit_length affects both center_of_mass and volume, or how density and unit_density interact).

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+resource purpose: 'Calculate physical properties (volume, mass, surface area, center of mass, bounding box) of a CAD file.' It clearly lists the computed outputs and distinguishes it from sibling tools like calculate_center_of_mass, calculate_mass, calculate_surface_area, etc., which compute single properties individually. The scope (all five physical properties in one call) is explicit.

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 lists the supported file formats (.fbx, .gltf, .obj, .ply, .sldprt, .step, .stp, .stl) with case-insensitivity noted, which gives clear guidance on when this tool applies. It does not explicitly state when NOT to use it or name alternatives (e.g., when a user only needs mass, the sibling calculate_mass tool might be more appropriate), but the format constraints and comprehensive nature of the tool are reasonably 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 provided, the description carries the full transparency burden. It states the return type (string) and mentions it can return an error message on failure, which is useful. However, it doesn't disclose whether this is a read-only operation, whether it uploads/processes files, or any side effects, rate limits, or performance considerations. The bottom-line 'or an error message if the operation fails' does offer some failure 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 and well-structured with Args/Returns sections, front-loading the primary purpose in the first sentence. The format/unit enumerations are value-dense and earn their place. Slightly verbose with the file format list, but this is functional information every caller needs.

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 that an output schema exists (mitigating the need to document return structure), the description adequately covers both parameters, supported formats, units, and failure behavior. For a two-parameter calculation tool, this is quite complete. The only notable gap is that it doesn't explain how mass/density is determined from geometry files (a prerequisite for center-of-mass calculation), which an agent might need to understand.

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 documenting parameters. The description provides detailed semantics for both input_file (path plus enumerated supported formats, case-insensitive) and unit_length (enumerated allowed values: cm, ft, in, m, mm, yd). This adds substantial meaning beyond the bare schema property names, though it doesn't specify default behavior like density assumptions used to compute mass from geometry.

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 (calculate) and resource (center of mass of a 3D object from an input file). It also enumerates supported file formats, which adds useful specificity. While it doesn't explicitly distinguish from siblings like calculate_volume or calculate_mass beyond the specific quantity, the 'center of mass' resource is distinctive enough among the similar physics-calculation 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?

The description implies usage context by listing supported formats and units, telling the agent what inputs are valid. However, it doesn't explicitly state when to choose this tool over calculate_cad_physical_properties or calculate_kcl_physical_properties (which may also compute mass properties), nor does it provide exclusions or alternative 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. It discloses that the function returns either a dict with the listed keys or an error message if the operation fails, which is useful. However, it doesn't mention whether the operation is read-only, requires authentication, or what model/tooling prerequisites exist (e.g., whether the KCL must be a solid vs sketch). The return behavior disclosure partially compensates but leaves 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 reasonably structured with an Args section and Returns section, making it scannable. The parameter list format is efficient, though somewhat verbose given 8 parameters each with their enum values enumerated inline. The front section clearly states purpose before diving into params. Slightly verbose but well-organized.

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

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

Given 8 parameters, 0% schema coverage, and an output schema, the description does a fair job of documenting all inputs and the return structure. However, it doesn't explain edge cases like what happens when both kcl_code and kcl_path are provided simultaneously, whether the model must be a properly closed solid, or dependencies on material properties. For a complex multi-input tool, more guidance would help, but the required parameters are all 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%, so the description must fully document parameters. It does list all 8 parameters with their types and allowed enum values, which is helpful. However, for key non-enum parameters like kcl_code and density, it provides minimal semantic context beyond what the schema shows. It doesn't explain the relationship between density and unit_density, or what realistic density ranges are. It lists the parameter meanings but doesn't enrich beyond the schema's basic type definitions.

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 the verb (calculate) and resource (physical properties of a KCL model), enumerating the specific outputs: volume, mass, surface area, center of mass, bounding box. It distinguishes from sibling tools like calculate_mass, calculate_volume, and calculate_surface_area, which each handle only a single property, whereas this tool computes all of them at once. This is specific and differentiated.

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

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

Description explains the mutual exclusivity requirement of kcl_code vs kcl_path, noting that either one must be provided, and clarifies what kcl_path should point to (.kcl file or directory with main.kcl). It doesn't explicitly say when to use this tool vs the individual calculation siblings (calculate_mass, calculate_volume, etc.), though the distinction is implied by computing all properties at once. No explicit exclusions 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?

No annotations are provided, so the description carries full burden. It indicates it returns mass or error but does not disclose whether it modifies files, requires authentication, or is read-only. Basic behavioral info is present but could be more 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 structured with clear Args/Returns sections, but the 'Args' block is somewhat verbose for a tool with only 4 parameters. Could be slightly more concise without losing 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?

The description covers all parameters and return type, which is sufficient given the tool's simplicity. However, it could include usage context (e.g., recommended when needing object weight) or mention that it is non-destructive.

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 compensates fully by explaining each parameter in detail: input_file formats, unit_mass options, unit_density options, and density as float. This adds significant meaning beyond the plain 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 it calculates mass from a 3D file, lists supported formats and units, and distinguishes it from siblings like calculate_volume and calculate_surface_area.

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 use when needing mass but does not explicitly specify when to use this vs alternatives among the many sibling tools (e.g., calculate_volume, calculate_center_of_mass).

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 that the tool reads a file, returns the area or an error message, and specifies supported file formats and unit options. It does not discuss file accessibility or side effects, but these are minor omissions.

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 (a few sentences) and well-structured with clear 'Args' and 'Returns' sections. Every sentence adds value, and there is no redundancy.

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

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

Given the lack of annotations and 0% schema coverage, the description is quite complete. It covers both parameters, return type, and error behavior. It could hint at file existence requirements, but overall it provides sufficient context for an agent.

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 fully compensates by explaining both parameters: input_file (path and supported formats) and unit_area (list of valid units). This adds crucial meaning beyond the raw schema, which only states type 'string'.

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 defines the tool's function: 'Calculate the surface area of a 3d object represented by the input file.' This is a specific verb-object combination that distinguishes it from sibling tools like calculate_volume or calculate_mass.

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 states the tool is for calculating surface area from 3D files, implying its usage. It does not explicitly mention when not to use it or compare to alternatives, but the purpose is clear and sibling tool names provide 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 discloses that the tool returns a volume value or error message, but does not mention side effects, permissions, file size limits, or whether files are read-only. Minimal behavioral context is provided.

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 organized with clear Args and Returns sections, and each sentence is informative. Slightly verbose by listing all file formats and units, but this is necessary 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 the presence of an output schema and the tool's simplicity, the description adequately covers purpose, inputs, and return value. It is complete enough for an agent to understand the tool's function.

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 compensates for the input schema's 0% coverage by fully explaining both parameters: input_file includes supported formats, unit_volume lists all allowed values. This adds significant meaning 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 verb 'Calculate' and the resource 'volume of a 3d object', and the input file parameter distinguishes it from sibling tools like calculate_mass or calculate_surface_area.

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 versus alternative calculation tools (e.g., calculate_mass, calculate_surface_area). The description lacks any contextual hints about selection 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It transparently explains that centring moves the camera without re-framing, potentially dropping parts of the model outside the image, and that session_id is required because camera position is scene state. It also details the behavior of move_vantage, including the default and its effect.

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 main line, usage context, and an Args section. Every sentence contributes: it explains the rationale, prerequisites, side effects, and parameters without filler. The length is justified by the behavioral nuances it conveys.

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

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

Given no annotations and a simple output schema, the description fully covers what an agent needs: purpose, preconditions, side effects, parameter details, and a note about the return confirmation. It addresses all context needed for correct tool invocation.

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

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

Despite 0% schema description coverage, the description's Args section adds substantial meaning beyond the schema. It explains why session_id is required (scene state would be discarded) and clarifies the semantics of move_vantage (True centres most precisely, False re-aims from current position). This goes far beyond the bare schema definitions.

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 object: 'Point the camera at the current selection set.' This clearly identifies the tool's purpose and its unique role among siblings. It further clarifies by explaining why centring helps small selections, especially edges, distinguishing it from other camera or selection 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 explicitly states prerequisites ('Set the selection first with select_entities'), provides a follow-up action ('Follow with snapshot passing zoom=False'), and explains why zoom=True would undo the centring. This gives clear when-to-use and when-not-to-use guidance, fully differentiating it from alternatives.

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

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

With no annotations provided, the description carries the full burden. It discloses key behaviors such as export_path directory vs file handling, default export_format of 'step', and that it returns a path or error message. This is transparent and practical, though it could mention error handling or permission implications if any.

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 'Args' and 'Returns' sections, making it easy to scan. Every sentence adds value—no fluff. The formatting is clear and directly addresses the user 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 conversion tool with 3 params, the description covers all necessary aspects: input, output, defaults, and return value. It accounts for edge cases (directory vs file path) and is complete enough for an agent to invoke correctly. The output schema (string) is also indicated by the return type.

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, and it does excellently. It explains each parameter in detail: input_file lists all supported formats (case-insensitive), export_path explains directory vs file behavior, and export_format documents allowed values and the default of 'step'. This goes far beyond the raw schema.

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

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

The description clearly states the tool's purpose: 'Convert a CAD file from one format to another CAD file format.' It lists specific input/output formats and distinguishes itself from sibling tools like import_cad_file by focusing on conversion between formats. This is a specific verb+resource with clear scope.

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 the tool (conversion) and provides format constraints, but it does not explicitly compare with alternatives or state when not to use it. While usage is implied through format lists, there is no direct guidance on choosing between convert_cad_file and similar sibling tools like import_cad_file or export_kcl.

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 convey behavior. The verb 'get' implies a read-only operation, but there is no explicit statement about side effects, permissions, or failure conditions. It adequately indicates the operation is non-destructive but lacks explicit 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 concise and well-structured. It includes the function, parameters, and return value in a clear format without unnecessary verbosity. Each 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?

For a simple get operation, the description covers the necessary context: what it does (get start/end points), the inputs (curve_id and session_id), and the output (CurveGetEndPoints). It is complete for its scope; no further details are 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?

Both parameters are described in the description: 'curve_id' is a UUID from an artifact graph, and 'session_id' is a modeling session from execute_kcl or exec_kcl_project. This adds meaningful context beyond the schema's basic types, though it could be more detailed about constraints or formats.

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

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

The description clearly states the tool's purpose: 'Get the start and end points of a curve entity.' This is a specific action on a specific resource, distinguishing it from sibling tools like curve_get_type or edge_get_length.

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. It does not mention scenarios, prerequisites, or contrast with other curve-related operations. 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 full burden of behavioral disclosure. It mentions the return type (CurveGetType) but does not explicitly state that the tool is read-only, has no side effects, or requires authentication. This is a significant gap for a safety-conscious agent.

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 and well-structured: a one-sentence purpose, then Args and Returns sections. No irrelevant detail, front-loaded with the core functionality.

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 getter with an output schema, the description covers the necessary context: what the curve_id and session_id are and what is returned. It lacks mention of side effects or errors, but these are not essential for a read-only query. Overall, adequate without being overly verbose.

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

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

Although schema coverage is 0%, the description adds meaningful context for both parameters: curve_id is described as a Curve UUID from an artifact graph, and session_id is tied to a modeling session from specific commands. This goes beyond raw string types and clarifies expected provenance.

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

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

The description clearly states the tool's action ("Get whether a curve is a line, arc, or NURBS curve") with a specific resource (curve type). It is distinct from siblings like curve_get_end_points or curve_get_end_points, and leaves no 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 context for parameters (curve_id from an artifact graph, session_id from execute_kcl/exec_kcl_project) which implies usage context but does not explicitly contrast with alternative tools or provide exclusions. No guidance on 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?

With no annotations provided, the description carries the full burden. It discloses the operation (get length), the units (current scene units), and how parameters are sourced, which adds behavioral context. However, it does not explicitly state that the operation is read-only or free of side effects, though the verb 'get' implicitly suggests this. This is a gap given the absence of annotations.

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

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

The description is a well-organized docstring with a clear one-line purpose, followed by Args and Returns sections. It is brief, front-loaded, and every sentence 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 tool is a simple getter, and the description includes purpose, units, parameter origins, and return type. An output schema exists to detail the return object, so the description needn't over-specify. It lacks error-handling or edge-case notes, but for a basic getter, this is largely complete.

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

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

The input schema has zero description coverage, so the description must compensate. Both parameters are explained: edge_id is described as an Edge UUID from an artifact graph, and session_id as a modeling session from execute_kcl or exec_kcl_project. This adds meaningful semantics beyond the bare schema property names and types, though examples or constraints are not provided.

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 'Get the length of an edge entity in the current scene units' clearly states the specific verb (get) and resource (edge length), and the 'current scene units' adds useful scope. It distinguishes from sibling tools like entity_distance or curve_get_end_points, which serve 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 provides context on how to obtain the parameters (edge_id from artifact graph, session_id from execute_kcl or exec_kcl_project), which implies when the tool is usable. However, it does not explicitly state when to choose this tool over alternatives or mention any exclusions, so usage guidance is mostly 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 explains the return value and the relationship between session_id and prior KCL execution, and examples clarify the accepted JSON structure. However, it does not disclose error behavior, invalid t values, or any side effects, leaving notable gaps for an unannotated 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 well-structured with a one-line summary, relevant examples, and an Args list. The two path_json examples are useful but somewhat lengthy; they earn their place because this parameter is otherwise ambiguous. Overall it is efficient and readable.

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

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

Given the complexity of path_json, the examples substantially improve completeness. The output schema is present, so return values need less space. The description omits edge cases and validation behavior, but for the core usage it provides enough context.

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

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

Schema coverage is 0%, but the description compensates by explicitly defining all three parameters: path_json as serialized KCL path, t as a normalized path parameter, and session_id as a modeling session from execute_kcl or exec_kcl_project. The JSON examples additionally clarify the expected path_json structure beyond what the bare schema 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 a specific action—evaluate a serialized KCL path at parameter t—and identifies the exact resource (path_json) and input (t). It stands apart from sibling tools like curve_get_end_points or entity_distance because it focuses on evaluating a path parameterization, not measuring geometry endpoints.

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 usage context by explaining that session_id must come from execute_kcl or exec_kcl_project and that t is normalized between 0 and 1. It does not explicitly list alternatives or when-not-to-use cases, but the context is sufficiently clear for a modeling utility.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It explicitly states that it 'Get[s]' distances, implying a read-only operation, and details the return type (EntityGetDistance with min/max). However, it does not mention potential side effects, permission requirements, or error conditions. This is adequate for a simple getter but leaves some 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 well-structured with an Args section and Returns section. Every sentence contributes meaningful information: the purpose, parameter explanations, and return type. It is concise without redundant text, and the format is front-loaded with the core 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?

The tool has 4 parameters and an output schema. The description explains the purpose and parameters, and mentions the return type (EntityGetDistance with min/max). While it does not elaborate on the structure of the return value, the output schema likely covers that. It could mention the need for an active session or that entities must exist, but these are implied by the session context.

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

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

Schema description coverage is 0%, yet the tool description compensates by explaining each parameter. It specifies that entity_id1 is typically from an artifact graph, entity_id2 is the second UUID, session_id must be populated by execution tools, and on_axis is optional for projected distance. This adds substantial 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 states the tool 'Get the minimum and maximum distance between two model entities.' The verb-resource pair is specific and distinguishes it from sibling tools like edge_get_length or curve_get_end_points, which target specific entity measurements. It precisely identifies what is retrieved (distance between two entities).

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 prerequisites, noting that session_id should be 'a modeling session populated by execute_kcl or exec_kcl_project.' It implies when to use this tool (after a session exists and entities are known) but does not explicitly contrast it with alternative distance-related tools or state when not to use it. This is clear but lacks explicit 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?

No annotations are provided, so the description bears the full burden of disclosing behavioral aspects. It does not mention side effects, permissions, error handling, or assumptions (e.g., read-only nature). As a 'get' operation it is likely safe, but that is not stated, leaving transparency low.

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, using three short sentences. It includes the purpose, parameter explanations, and return type without any unnecessary fluff or repetition. 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?

Given the simplicity of the operation (fetch all child UUIDs), the description provides sufficient detail: it states the action, describes both parameters, and indicates the return value. However, it lacks explicit usage guidance and behavioral notes, which prevents a perfect score, but it is largely complete for a basic getter.

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 provides only titles and types with zero descriptions. The description partially compensates by explaining that entity_id is 'typically obtained from an artifact graph' and session_id is 'a modeling session populated by execute_kcl or exec_kcl_project.' This adds useful context but does not fully define valid values, formats, or 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 specific action: 'Get all child UUIDs belonging to an entity.' This is a precise verb+resource combination that distinguishes it from sibling tools that retrieve other types of data. The 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?

The description explains what the tool does but does not explicitly state when to use it versus other similar getter tools. It implies usage when child UUIDs are needed, but lacks direct guidance on alternatives or context for selection among the many sibling getters.

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?

There are no annotations, and the description only states the action without disclosing side effects or error behavior. While 'get' implies a read-only operation, it does not explicitly confirm that the tool modifies no state or what happens if the entity does not exist. The description does not mention any potential side effects, but the lack of explicit assurance makes transparency incomplete.

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

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

The description is concise and well-structured, with clear separation of purpose, arguments, and return value. It avoids unnecessary fluff and presents all essential information in a compact format. The use of numbered argument descriptions is clean and easy to follow.

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 getter operation, the description covers the primary purpose, inputs, and output. It does not elaborate on potential errors or precise semantics of 'index', but these are likely straightforward in the context of CAD modeling. The inclusion of the return type 'EntityGetIndex' and its description makes the tool's behavior understandable without additional documentation.

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

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

The description expands on the schema by explaining that entity_id is a UUID typically from an artifact graph and that session_id is a modeling session from execute_kcl or exec_kcl_project. This adds meaningful context beyond the bare schema, though it does not provide details about the expected format or constraints. The explanation is adequate for basic usage but leaves some ambiguity about edge cases.

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 retrieves an entity's index within its parent, which is a specific and unambiguous operation. It could be more detailed about what constitutes an entity, but in the context of the related CAD tools, it is sufficiently clear. The verb 'get' accurately reflects the read-only nature of the 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 provides no guidance on when to use this tool versus alternatives. It does not mention any prerequisites, conditions, or distinguish itself from sibling tools like entity_get_parent_id or entity_get_all_child_uuids. Users are left to infer when this tool is appropriate without explicit direction.

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 return value (parent UUID) and parameter provenance, but it does not disclose behavior for edge cases such as an entity with no parent, invalid entity_id, or session errors. The read-only nature is implied by 'Get' but not explicitly stated.

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

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

The description is concise and well-structured with a one-line summary followed by Args and Returns sections. Every sentence adds useful information, with 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?

For a simple getter with two parameters and an output schema, the description covers the essential context: what the tool does, where parameters come from, and what it returns. It does not explain error cases, but the low complexity and presence of an output schema make this acceptable.

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 compensates by explaining that entity_id is an Entity UUID typically obtained from an artifact graph and that session_id must be a modeling session populated by execute_kcl or exec_kcl_project. This adds meaningful provenance beyond the raw string type in 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 opens with 'Get the UUID of an entity's parent,' which is a specific verb+resource statement. It clearly distinguishes this from sibling tools like entity_get_all_child_uuids by focusing on the parent relationship.

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: entity_id typically comes from an artifact graph, and session_id must be a modeling session populated by execute_kcl or exec_kcl_project. It does not explicitly mention alternatives, but the prerequisites are clear enough for correct use.

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

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

No annotations are available, so the description carries the full burden. It clarifies that the operation is a read ('Get') and specifies prerequisites (session_id populated by KCL execution). However, it doesn't disclose any side effects, error conditions, or whether the result is empty for entities without sketches. It adds some context but lacks richer behavioral details.

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

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

The description is highly concise: a one-sentence purpose, followed by concise Args and Returns sections. Every sentence adds value, and there is 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?

The tool is simple with two well-documented parameters and an output schema. The description covers purpose, parameters, and return type. It doesn't address edge cases (e.g., entities with no sketch paths), but given the low complexity and presence of an output schema, it is adequately 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%, but the description compensates by explaining both parameters: entity_id is the entity UUID typically from an artifact graph, and session_id is a modeling session from execute_kcl or exec_kcl_project. This adds meaningful context beyond the raw schema, though it could further specify accepted formats or 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 tool's function: 'Get the sketch path UUIDs belonging to an entity.' It uses a specific verb ('Get') and resource ('sketch path UUIDs') and is distinguishable from sibling entity getters like entity_get_all_child_uuids, which returns all child UUIDs, not just sketch paths.

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 parameter acquisition: entity_id is 'typically obtained from an artifact graph,' and session_id must be 'a modeling session populated by execute_kcl or exec_kcl_project.' This implies the tool requires an active modeling session. However, it doesn't explicitly mention when not to use this tool or suggest alternatives, so it misses the 'exclusions/alternatives' aspect 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. It discloses server-side execution and that an artifact graph JSON is saved. However, it does not mention potential side effects, prerequisites (e.g., existing session), or behavior when both kcl_code and kcl_path are provided.

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

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

The description is concise and well-structured with a clear one-sentence summary, an Args list, and a Returns line. Every sentence adds value with no repetition of schema 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 3-parameter tool with no annotations, the description covers the basics but misses key context: it does not state that exactly one of kcl_code or kcl_path must be provided, nor does it mention whether session_id must refer to an active session. The return value is explained, and an output schema exists.

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 no property descriptions, so the tool's Args section provides essential meaning for each parameter. It explains kcl_code and kcl_path as alternatives and session_id as the execution context, but it stops short of explicitly stating the mutual-exclusion constraint.

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 runs a KCL project server-side and saves its artifact graph. This distinguishes it from sibling tools like execute_kcl and uses a specific verb and resource.

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

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

The Args section explains the two input modes (kcl_code for single-file, kcl_path for a .kcl file or directory) and session_id, giving clear context on how to use the tool. However, it does not explicitly mention when to use this tool versus alternatives such as execute_kcl.

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 session executions save an artifact graph to a temp JSON and return its path, while local executions have network overhead and no artifact graph. This goes beyond a minimal description, though it does not cover every potential side effect (e.g., file system writes beyond temp files).

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 first sentence, a short paragraph contrasting execution modes, and an Args/Returns section. Every sentence contributes meaningful information, and the format is easily scannable without being 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's complexity and lack of annotations, the description covers all necessary aspects: purpose, input modes, execution differences, and return value content. It addresses the key concerns an agent would have about running arbitrary KCL code, including the artifact graph location and network overhead, making it sufficiently 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?

Despite the input schema providing no default descriptions, the description clearly explains each parameter: kcl_code, kcl_path, and session_id, and emphasizes the critical constraint that either kcl_code or kcl_path must be provided. It also clarifies the nature of kcl_path (file or directory with main.kcl). This adds substantial value 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 opens with 'Execute KCL code given a string of KCL code or a path to a KCL project,' using a specific verb and resource, and clearly distinguishes two input modes. This clearly defines what the tool does and differentiates it from any ambiguous reading, even though sibling tool distinctions aren't explicitly discussed.

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 session vs. local executions, outlining trade-offs like artifact graph generation and network overhead. However, it does not explicitly name alternative tools (e.g., exec_kcl_project) or state when to prefer this tool over siblings, so it stops 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?

No annotations provided, so the description carries full burden. It discloses that the tool returns a file path or error, uses a temporary file if no export_path, and defaults to 'step' format. It does not mention side effects or authentication needs, which are unlikely for an export 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 concise and well-structured with clearly labeled sections for Args and Returns. Every sentence adds value, with no redundancy or unnecessary phrasing.

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 4 parameters, 0 required, and the constraint of providing exactly one of kcl_code or kcl_path, the description covers all necessary usage details. It also describes the return value and error handling.

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 compensates fully by explaining each parameter in detail, including the mutual exclusivity of kcl_code and kcl_path, the expected file extensions, and the default format and path behavior.

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 exports KCL code to a CAD file. It specifies the verb 'export' and the resource 'KCL code to a CAD file', and distinguishes from sibling tools like 'convert_cad_file' which handles CAD 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 explicitly requires either kcl_code or kcl_path, and provides guidance on how to specify these parameters. It lists valid export formats and the default format. Although it does not mention when to avoid using the tool, the constraints are 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?

Without annotations, the description clearly explains the two modes: returns formatted string for kcl_code, and formats in-place (returns None) for kcl_path. No hidden destructive behavior beyond expected file modification is disclosed.

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?

Well-structured with Args and Returns sections. The first sentence captures the essence. Could be slightly more concise, but 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 annotations and an output schema (implied), the description covers return behavior and parameter semantics adequately. For a simple formatting tool, it provides sufficient context.

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

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

Schema has 0% description coverage (only titles). The description fully compensates by explaining each parameter's purpose, type, and usage constraints (e.g., .kcl file or directory with main.kcl).

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 'Format' and the resource 'KCL code' (string or path). It distinguishes itself from siblings like execute_kcl and lint_and_fix_kcl by focusing solely on formatting.

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

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

Explicitly states that either kcl_code or kcl_path must be provided, with constraints on kcl_path pointing to .kcl files or directories. Lacks explicit comparison with siblings like lint_and_fix_kcl, but provides sufficient guidance for correct 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, and the description does not mention side effects, read-only nature, permissions, or error conditions. It only describes the return information, leaving behavioral transparency minimal.

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 Args and Returns sections, but it contains some redundancy (e.g., repeating position and center details). It is clear but could be more concise.

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

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

Given the lack of an output schema, the description adequately explains the return type FaceInfo with its fields. It covers parameters and returns, but omits potential errors or edge cases, which might be expected for a simple getter.

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

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

The description adds context to both parameters: face_id as a user/LLM-selected identifier and session_id as populated by execute_kcl or exec_kcl_project. This goes beyond the schema's simple type declarations, though it could be more detailed about formats or 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 tool's function: retrieving position, gradient, normal, and center of a face in a modeling session. It distinguishes from sibling tools by focusing on face-specific geometric data.

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 in a modeling session context but does not explicitly state when to prefer this over other geometry-related tools. It lacks explicit comparisons or conditions for use.

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

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

Discloses that it returns full Markdown content or an error message. No annotations, so description carries full burden and covers key behaviors well, though could mention prerequisites.

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?

Efficient, well-structured with sections for purpose, usage, and parameters. No redundant sentences.

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 output schema (implied), description fully explains return values and error handling, leaving no 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 has 0% coverage, so description adds value with concrete examples (e.g., 'docs/kcl-lang/functions'), partially compensating for lack of schema descriptions.

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

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

Clear verb 'Get' and resource 'full content of a specific KCL documentation file'. Distinguishes from siblings like list_kcl_docs and search_kcl_docs.

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 using list_kcl_docs to find paths and search_kcl_docs for keyword search, providing clear when-to-use guidance and 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 must carry the full burden. It does disclose the return-type polymorphism (SampleData OR error string), the error condition ('if the sample is not found'), and the reliability note about multipleFiles being more accurate here than in sibling tools. It doesn't detail auth requirements or rate limits, but given no annotations, this is solid 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 well-structured with clear Args/Returns spacing and front-loaded purpose statement. The Returns section is somewhat lengthy but informative, and there's a minor redundancy near the end ('Returns an error message string if the sample is not found. If there was an error, returns an error message string.') which repeats the same point twice.

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 single-parameter retrieval tool with a rich output schema present. The description thoroughly documents the return structure including each key in the SampleData dict, the error behavior, and the distinction in multipleFiles reliability. Given the tool's simplicity and good schema coverage, this is 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 sole param (sample_name) has no title/description value beyond its name. The description compensates by providing concrete examples ('ball-bearing', 'axial-fan', 'gear') and clarifying it's the 'sample directory name'. This adds meaningful context 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 states the verb ('Get the full content') and resource ('a specific KCL sample including all files'). It explicitly distinguishes from siblings by noting reliability of multipleFiles is higher than in list_kcl_samples/search_kcl_samples, and names those sibling tools 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?

Explicitly instructs when to use this tool vs alternatives: 'Use list_kcl_samples() to see available sample names, or search_kcl_samples() to find samples by keyword.' This provides clear context on discovery vs retrieval flow.

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 it delivers. It reveals the process scoping, the restart-recovery gotcha ('A restarted server has no sessions'), the at-most-one-session limitation, and why the return type is a list (future multi-session support). This is rich, honest behavioral disclosure that would be invisible to an agent otherwise.

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 short, information-dense sections: a one-line purpose, a usage rationale with edge-case handling, and a return-type spec. There is zero fluff — every sentence earns its place and the most important sentence leads.

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

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

For a zero-parameter, list-returning tool with no annotations, the description covers all bases: purpose, ecosystem context (reconnect scenario), state-reset behavior, current implementation limits, and future extensibility. Nothing meaningful is left unstated.

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 parameter schema is empty (0 params), which earns a baseline of 4. The description goes further by documenting the return value shape (list[str], 'currently empty or one item'), adding semantic value beyond the structured schema 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 opens with a precise, specific phrase — 'List modeling sessions owned by the current MCP server process' — combining a specific verb (list) with a scoped resource (modeling sessions owned by the current MCP server process). This clearly distinguishes it from sibling lifecycle tools like start_modeling_session and stop_modeling_session.

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

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

The description explicitly states when to use it: 'Use this to recover the active session ID after reconnecting to a server process.' This is clear context, but it never explicitly names alternatives or exclusions (e.g., 'for creating sessions use start_modeling_session'), leaving the exclusion partly implied by sibling names.

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 fully discloses behavior: it executes KCL, groups sketches by constraint status, details the structure of each entry, and explains the kcl_executes_successfully and kcl_error fields. It also mentions partial reports on failure.

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

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

The description is well-structured: it starts with the purpose, then details parameters, then explains the return structure. 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 tool's complexity (2 optional parameters, no annotations), the description is complete. It covers purpose, usage constraints, parameter semantics, and detailed output structure, even though an output schema exists.

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 compensates by explaining that kcl_code and kcl_path are optional with at least one required, and defines kcl_path as pointing to a .kcl file or directory containing main.kcl.

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

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

The description clearly states 'Execute KCL and return a report of sketch constraint status,' with specific verb ('execute' and 'return') and resource ('sketch constraint status'). It distinguishes itself from sibling tools like execute_kcl by focusing on constraint 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 provides explicit guidance that either kcl_code or kcl_path must be provided, and explains the expected format for kcl_path. It implies when to use this tool (for constraint status) but does not explicitly exclude alternatives or compare to 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 fully carries the behavioral disclosure burden. It discloses that highlighting only brightens entities slightly, that selection overrides highlight, that highlights draw through solids, and that a highlighted entity in a snapshot does not prove camera facing — valuable operational caveats that go far beyond a simple 'highlight' 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 longer than average, but every sentence conveys meaningful operational guidance, and it is well-structured with a concise summary, numbered behavioral notes, and clear Args/Returns sections. The early sentence 'Does NOT modify the selection set' is high-value 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?

Given the tool's visual complexity and the absence of annotations, the description covers all key aspects: effect, side effects, parameter semantics, relation to sibling tools, camera pitfalls, and return type. The presence of an output schema plus the description's Returns note makes the tool fully comprehensible.

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

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

Although the input schema provides only types and titles, the description's Args section adds crucial semantics: 'entity_ids' are UUIDs and an empty list clears highlights, while 'session_id' must come from start_modeling_session and is required because highlights are scene state. This fully compensates for the schema's 0% description 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 'Replace the currently highlighted entities' — a specific verb and resource that clearly defines the operation. It immediately distinguishes itself from the sibling tool 'select_entities' by stating 'Does NOT modify the selection set' and later contrasts the visual emphasis of highlight vs. 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 gives detailed when-to-use guidance, including following with the 'snapshot' tool using the same session_id and zoom=False. It explicitly compares against 'select_entities', recommends calling both for faces, and suggests alternatives like 'center_camera_on_selection' when edges are too thin, making the usage context highly 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?

No annotations are provided, so the description carries the burden. It discloses the return type (modeling engine ID) and accepted file formats, but doesn't mention potential side effects, error conditions, or whether the import is reversible. For a non-destructive import operation, 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 compact and well-structured with clear Args and Returns sections. Every sentence adds value: the purpose, parameter explanations, and return type. 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 moderate complexity (2 params, no enums, output schema present), the description covers the essential aspects: what it does, required inputs, and return value. It doesn't explain the output schema details, but the output schema itself provides that. The file format list is thorough. Slightly more context on error handling would push it to 5.

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 explains session_id as 'The ID returned by start_modeling_session' and input_file as a path with supported extensions, adding meaning beyond the bare schema. However, it doesn't specify path format (absolute/relative) or file size limits, so it's baseline adequate.

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 imports a CAD file into an existing modeling session, with a specific verb ('Import') and resource ('CAD file into an existing modeling session'). It distinguishes from siblings like convert_cad_file and start_modeling_session by emphasizing the existing session context.

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 by requiring a session_id from start_modeling_session, which provides clear context. It doesn't explicitly state when not to use it or name alternatives, but the session requirement and file format list give adequate guidance for selection 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?

No annotations provided, so description carries full burden. It discloses inputs, outputs, and that unfixed lints remain. No mention of side effects or permissions, but seems non-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?

Description is well-structured with Args and Returns sections, front-loaded with purpose. Could be slightly more concise, but all sentences add value.

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

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

Given the tool's complexity (two modes, tuple return), the description explains return formats for both cases. Output schema exists but not shown, yet description covers output well.

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

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

Schema has 0% description coverage, but the description adds meaning by explaining what each parameter does, that one must be provided, and how return values differ based on parameter used.

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 lints and fixes KCL code, with two modes: string or path. It distinguishes from siblings like format_kcl by specifying 'lint and fix' rather than just formatting.

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

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

Explicitly states that either kcl_code or kcl_path must be provided, and details valid path formats. Does not mention when not to use or compare to alternatives, but provides clear 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, but the description discloses return type (dict or error string) and structure. It covers the behavior of returning categories with file paths. No side effects or permissions are mentioned, but for a read-only list operation, the transparency is adequate.

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

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

The description is concise and well-structured, with a brief summary followed by category details and return info. It is front-loaded with the main purpose. Minor redundancy could be trimmed, but overall it's effective.

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 annotations, and a low-complexity operation, the description is complete. It explains what the tool does, the output structure, and error handling. No additional information is necessary for correct invocation.

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

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

There are no parameters, so the schema coverage is 100% by default. The description adds no parameter info, but none is needed. Baseline score of 4 is appropriate for zero parameters.

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

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

The description clearly states the tool lists available KCL documentation topics organized by category. It uses specific verb 'list' and resource 'KCL documentation topics', and distinguishes from siblings like get_kcl_doc and search_kcl_docs by focusing on listing all topics.

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 context: listing available docs before retrieving specific ones via get_kcl_doc. It does not explicitly state when not to use it, but the context of sibling tools provides guidance. A slightly more explicit exclusion would improve it.

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

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

With no annotations, the description fully bears the burden of behavioral disclosure. It explains the data source (Zoo samples repository), describes the return format with field-level details, and transparently notes the 'multipleFiles' field's best-effort nature and the fallback on error (returns error string). No contradictions.

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

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

The description is well-structured: a one-sentence purpose, followed by contextual details, then a bulleted return format. Every sentence serves a purpose, and the critical caveat is highlighted. 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?

Despite having no parameters, the output schema is fully described with field semantics and edge cases (multipleFiles caveat, error handling). For a simple listing tool, this provides complete context for an agent to interpret results correctly.

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

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

The tool has zero parameters, so the input schema provides no information. The description compensates by thoroughly detailing the output, including field meanings and a caveat. Baseline 4 is justified as it adds value 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 opens with 'List all available KCL sample projects,' using a clear verb+resource structure. It explicitly states the scope ('all available') which distinguishes it from sibling tools like search_kcl_samples that perform filtered search.

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 the tool is for listing all samples, but does not explicitly contrast with alternatives (e.g., search_kcl_samples) or provide when-not-to-use guidance. The context is clear but lacks explicit usage direction.

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 clearly states the operation (read-only listing), what is included/excluded (only enabled datasets), and the return format (list of objects or error message). It does not mention potential side effects, auth requirements, or rate limits, but for a simple list operation, the described behavior is transparent and sufficient. A 4 is appropriate given the lack of annotations and the solid but not exhaustive detail.

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, starting with a one-sentence purpose, followed by a paragraph explaining inclusion/exclusion criteria, then a Returns section. It is concise yet complete, with no redundant or filler content. 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 tool is simple (no params, output schema exists) and the description fully covers the purpose, edge cases (excluded datasets), return format, and how to use the results with the sibling tool. There is no missing information that would leave an agent uncertain about when to use it or what to expect. Given the presence of an output schema, the description does not need to elaborate on return values beyond what is mentioned.

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

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

The tool has 0 parameters, so the baseline is 4 per the rubric. The description does not need to explain parameters, and the schema covers everything (trivially). The description adds context about the return structure (id, name, description) and how to use the id, which is useful 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 starts with a clear verb-resource statement: 'List the datasets available to the user's organization.' It explicitly states the tool's scope (organization-level) and distinguishes itself from the sibling search tool by explaining that it returns enabled datasets and that the `id` should be used with `search_org_dataset_semantic`. This clearly differentiates it from any potential sibling list/search tools.

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

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

The description provides explicit guidance on when to use the tool (to list datasets enabled for lookup) and when not to (datasets excluded from lookup, e.g., while conversions are worked on, should not be searched). It also instructs the agent to use the returned `id` as the `dataset_id` for the semantic search tool, directly linking usage to a sibling 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 are present, so the description carries the burden. It discloses the operation is a read/list (non-destructive, 'List the skills'), the return shape, and that an error message may be returned. It doesn't discuss permissions, pagination limits, or whether the list is ordered/filtered, but the read-only nature and return contract are reasonably 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?

The description is compact, front-loaded with the purpose in the first line, and then details the return structure. The Returns section is a bit formalized but earns its place given there is no output schema reference to fall back on. No wasted sentences.

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?

A zero-parameter list tool has low complexity, and the description fully specifies the operation and return shape. An output schema exists but the description still documents the fields, which is redundant but not harmful. It's arguably complete for the tool's simplicity.

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 0 parameters, so there is nothing to describe. The baseline for 0 parameters is 4. The description appropriately focuses on the return contract instead, which is what matters for a parameterless tool.

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

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

The description clearly states the verb ('List') and resource ('skills available to the user's organization'). It also specifies the data shape of each skill. It doesn't explicitly distinguish from sibling tools like list_org_datasets, but the resource is clearly named and distinct.

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 versus alternatives. It doesn't mention why you'd list skills (e.g., to get IDs for later reference), when this would be useful, or any exclusions. Sibling tools like list_kcl_samples serve a seemingly similar listing purpose but no differentiation is 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?

Since no annotations are provided, the description must cover behavioral aspects. It explains it returns a tuple (bool, str) with success/failure message, and that it mock executes. It does not disclose side effects, but for a mock tool, this is adequate.

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

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

The description is concise and well-structured, with a clear introductory sentence followed by parameter documentation and return value. No unnecessary 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 tool's simplicity (2 parameters, no annotations, and an output schema), the description covers all necessary aspects: function, parameters, return value, and usage constraints, making it complete for an agent.

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, but the description provides detailed documentation for each parameter, including types and the mutual exclusivity constraint, adding significant value 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 'mock execute KCL code' with a specific verb and resource. It also distinguishes from the sibling tool 'execute_kcl' by mentioning 'mock', implying simulated execution.

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

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

The description specifies that either kcl_code or kcl_path must be provided, but does not give explicit guidance on when to use this mock tool versus the real execute_kcl, 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?

With no annotations, the description carries full burden. It discloses behavior thoroughly: output_path can be a file or directory (directory implies default filename 'image.jpg'), and if omitted, a temporary file is created. It also states the return value (absolute path or error).

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 Args and Returns sections, front-loaded with a clear purpose sentence. No wasted words; every sentence adds useful 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?

The description is complete for this simple tool: it covers purpose, differentiation, parameter behavior, return value, and edge cases (directory path, temporary file). The presence of an output schema reduces need for return elaboration, but it is still 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?

Schema coverage is 0%, yet the description compensates fully. It explains the image parameter's origin (typically from snapshot) and details output_path semantics with examples, directory handling, and fallback behavior.

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: 'Save an ImageContent object to disk.' It clearly states the tool's function and distinguishes it from the sibling snapshot tool by noting that snapshot can write directly to disk, while this tool is for images already held.

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 snapshot: 'snapshot can write straight to disk via its own output_path argument; this tool is for images you already hold.' This tells the agent exactly when to use this tool versus the alternative.

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 explicitly discloses the error behavior ('If there was an error, returns an error message string'), the search is case-insensitive, and it describes the request/response structure. This is strong behavioral transparency for a read/search tool with no 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?

Description is well-organized with a clear one-line summary followed by detailed Args and Returns sections using docstring format. It's appropriately detailed for a tool with an output schema — arguably slightly verbose for a simple search function, but the returns field detail adds genuine value given 0% schema coverage.

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 thoroughly explains the return value structure including error handling, which is valuable. The tool is a simple search function (2 params, no nested objects), and the description fully covers purpose, parameters, return format, and error behavior. Complete enough for an agent to use correctly.

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

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

Schema description coverage is 0%, so the description must fully compensate. It does: explains query as a search query (case-insensitive), max_results as max number of results with default (5), and details each field of the returned list (path, title, excerpt with highlighted context, match_count). This adds significant meaning beyond the raw schema.

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

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

Description clearly states the verb ('Search'), the resource ('KCL documentation by keyword'), and the scope ('across all KCL language and standard library documentation'). It distinguishes from siblings like list_kcl_docs and get_kcl_doc, which are clearly listing/retrieval operations rather than keyword search.

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 context is clear: 'Search KCL documentation by keyword' with search across all docs. It's logically differentiated from siblings (list_kcl_docs, get_kcl_doc, search_kcl_samples) through naming, but doesn't explicitly state when to prefer this over alternatives or 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?

No annotations are provided, so the description carries the full burden. It discloses that multipleFiles is a 'best-effort hint only' and advises calling get_kcl_sample for a reliable answer, which is useful. However, it doesn't disclose pagination, rate limits, or error cases beyond returning an error string, leaving some transparency gaps for a search operation.

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

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

The description is well-structured with a one-line summary followed by args, returns, and caveats clearly labeled. It's thorough without being bloated; the docstring format is readable and front-loads the core purpose.

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

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

Given there's an output schema, the description needn't fully explain return values, but it does anyway, which is helpful. It documents the return list fields and the error fallback, and provides the multipleFiles caveat with a pointer to a reliable alternative. For a search tool with 2 params and no annotations, this 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%, so the description must compensate, and it does. It explains query is 'case-insensitive' and max_results is 'Maximum number of results to return (default: 5)', adding semantics beyond the bare schema. It also documents the return structure in detail.

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 it searches KCL samples by keyword across titles and descriptions, and returns results ranked by relevance. The purpose is specific and clear, though sibling tools like search_kcl_docs and search_org_dataset_semantic share similar search patterns, so explicit differentiation is limited.

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 the tool searches all KCL sample titles and descriptions, giving implied usage context. However, it doesn't explicitly contrast with search_kcl_docs, search_org_dataset_semantic, or list_kcl_samples, and there's no statement of when NOT to use this tool.

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

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

With no annotations, the description discloses key behaviors: embedding and cosine similarity ranking. It does not discuss side effects or auth, but for a read-only search this is adequate.

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

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

The description is concise, with a clear summary, process explanation, parameter list, and return format. 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 tool's simplicity (3 params, no nested objects), the description covers purpose, mechanism, parameters, and return format completely. The existence of an output schema further supports 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 has 0% description coverage, but the description adds meaningful context for all three parameters: dataset_id (source list_org_datasets), query (natural-language), limit (optional max results). This significantly augments 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 performs semantic search on a dataset, specifying the verb 'Semantic-search' and the resource 'dataset'. It distinguishes from siblings like search_kcl_docs by focusing on org datasets.

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 it embeds the query with an org-dataset model and returns top chunk matches, implying use for natural-language queries. However, it does not explicitly contrast with alternative search tools or provide when-not 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 full responsibility for behavioral disclosure. It thoroughly describes rendering behavior (tint, outline, draw-through, occlusion effects), how selection overrides highlight, clearing behavior with empty list, and the requirement for an active session. This goes far beyond typical tool descriptions.

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

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

The description is well-structured with clear sections (overview, behavioral details, args, returns). While lengthy, every sentence adds critical information about rendering quirks and usage nuances. 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 tool's complexity, no annotations, and multiple sibling tools, the description is exceptionally complete. It covers all relevant aspects: usage, parameters, rendering behavior, interaction with highlight and snapshot, and return type. The output schema exists and the description confirms the return is a SelectReplace confirmation.

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 provides rich parameter explanations in the Args section: entity_ids are UUIDs used exactly as in artifact graph, empty list clears selection; session_id must come from start_modeling_session and is required because selection is scene state. This adds meaning the schema lacks.

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

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

The description opens with a specific verb and resource: 'Replace the selection set with the given entities.' It clearly distinguishes from highlight_set_entities by explaining differences in visual emphasis and when to use each, making the tool's 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 gives explicit usage guidance, including when to combine with highlight_set_entities, when to use only one, and how to follow up with snapshot (including zoom=False). It also explains the need for a session_id, which is a prerequisite for correct 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, but the description discloses a key behavioral trait: the filter is scene state and would be discarded without a session_id. It also confirms a return value. It doesn't cover all edge cases, but it adequately addresses persistence 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 compact, front-loaded with the purpose, and uses a structured Args/Returns format. Every sentence adds value without unnecessary 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 setter with two required parameters and an output schema, the description is complete: it explains what, why, and the return type, plus the session dependency. No critical information is missing.

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

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

Schema has no parameter descriptions (0% coverage), so the description compensates. It explains entity_types as 'permitted' and session_id with the important caveat about scene state and where to obtain it. This goes beyond what the schema 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's function: 'Set which model entity types can be added to the "selection set".' This distinguishes it from sibling selection tools like select_entities or highlight_set_entities, and specifies the resource (selection filter) and action (set).

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 by requiring an open modeling session from start_modeling_session, implying the filter is session-scoped. It doesn't explicitly name alternatives, but the session prerequisite and clear purpose make the usage context clear. No exclusions are mentioned.

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 behavioral burden and succeeds. It discloses orthographic projection, exact view axes, zoom-to-fit behavior, the warning that a freshly executed scene renders only a few pixels wide with zoom=False, multi-view collage layouts, and that output is always JPEG regardless of file extension.

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?

Although long, the description is front-loaded with the core purpose and prerequisite, then organized into clear parameter explanations with examples. The length is justified by the complexity of camera_view and the numerous behavioral details; no sentence is wasted.

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 high complexity of the tool, the description is complete: it covers prerequisites, projection behavior, camera-view variants, zoom, output format, file extension behavior, and return types. The return value is explained even though an output schema exists, making the tool fully actionable.

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 fully compensate, and it does. Every one of the seven parameters is explained, including the complex camera_view union with named views, dictionary examples, list forms, zoom behavior, padding, and output_path directory/file semantics.

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: 'Render an open modeling session as an image.' It immediately distinguishes itself from scene-population tools by instructing the caller to populate the session with execute_kcl or exec_kcl_project first, and the detailed camera-view discussion clarifies its unique rendering role.

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

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

The description gives clear context for use: the session must be populated first, zoom=False is only appropriate when the camera is already positioned, and output_path switches between inline and file output. It does not explicitly name alternative tools for image saving or rendering, so it lacks an explicit when-not-to-use statement.

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 goes beyond the absence of annotations by disclosing the error behavior (fails if already open/connecting, returns session ID), the lack of server-side expirations, and caller responsibility for timeouts. This is valuable context not derivable from the tool signature.

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 substantive yet concise, covering purpose, constraints, error handling, usage workflow, and return value in a well-organized manner. Every sentence contributes essential 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?

Despite having no parameters and a simple return value, the description fully contextualizes the tool within the broader workflow: it explains how to use the returned session_id, stops the session, and notes the timeout responsibility. This is comprehensive for a session-start 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?

There are no parameters, so the description correctly omits any parameter details. Per the rule for zero parameters, this is a baseline of 4, and no additional explanation 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 action ('Open an empty modeling websocket') and its purpose as a session initializer. It distinguishes from sibling tools by positioning itself as the entry point that returns a session_id for subsequent execute/query 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?

It explains the cardinality constraint (only one session open) and instructs to stop before starting a new one, and to pass the returned session_id to specific tools. However, it does not explicitly compare with alternatives like get_modeling_sessions or mention when to choose this over other session-related tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It transparently describes closing and canceling sessions, mentions freeing slots for new calls, and references error messages for ID sourcing. This is adequate for a simple 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 compact and well-structured, using a clear Args/Returns format. Every sentence adds value, with no redundancy or fluff, making it easy for an agent to parse quickly.

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

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

For a tool with a single parameter and a declared Returns None, the description fully covers the main action, the cancellation edge case, and the parameter source. Since an output schema exists, the return value is not needed in the description, and the description is complete for its complexity.

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

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

The description adds crucial meaning to the session_id parameter by specifying it comes from start_modeling_session or an 'already open or starting' error. This goes well beyond the schema, which only provides the type and required flag, effectively documenting the parameter's provenance.

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 closes a persistent modeling websocket session, with a specific verb and resource. It also distinguishes from its sibling start_modeling_session by noting the cancellation of connecting sessions, which is unique behavior.

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 explains when to use the tool, including the special case of canceling a starting session and freeing a slot for a new start_modeling_session call. This provides clear context for usage, though it doesn't explicitly list alternatives, the guidance is sufficiently specific.

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 transparently explains that the image is solver-debug output, that no modeling session is opened, and what happens when output_path is provided versus omitted. It also discloses the return shape: inline ImageContent, absolute path, or error message. This is solid but not exhaustive—it does not discuss potential side effects or failure modes.

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 organized with a purpose statement, parameter details, and return behavior. Every sentence adds useful information, and the structure makes it easy to scan. The example for sketch_name is particularly valuable and does not feel 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?

The description is largely complete for a tool with four parameters and no annotations: it covers purpose, parameters, return behavior, and how to discover sketch names. The main gap is that it does not clarify whether kcl_code and kcl_path are mutually exclusive, optional alternatives, or what happens if both are provided. Given that only sketch_name is required, this is a meaningful omission.

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, and it does. Every parameter is explained with meaningful semantics: sketch_name includes a KCL code example, kcl_code and kcl_path are clearly described, and output_path gets detailed behavior including directory handling. This goes well beyond the bare input schema and gives an agent enough to invoke 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 opens with a specific verb and resource: 'Render a named 2D KCL sketch as a solver-debug PNG.' It clearly distinguishes the tool by emphasizing it works 'without opening a modeling session' and provides a concrete sketch_name example. This makes it easy for an agent to understand what the tool does and to differentiate it from modeling-session 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 gives clear context on when to use this tool: for quick solver-debug visualization without a modeling session. It also explicitly directs the agent to get_sketch_constraint_status when sketch names are unknown. It stops short of naming alternative tools or stating explicit exclusion conditions, so it earns a 4 rather than a 5.

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