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

With no annotations provided, the description carries full disclosure burden. It states that the tool 'will update the JCAD document' and explains the return value, which is useful. However, it does not disclose failure behavior, error conditions, or what happens to existing annotations, leaving significant gaps.

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

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

The description is efficient: a clear one-line purpose, a param list, and a warning. While the whitespace around the warning is slightly awkward, every sentence adds information and nothing is redundant.

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 mutation tool with no output schema and no annotations, yet it lacks critical context. It does not explain what the annotation is used for, how it relates to sibling tools, failure modes, or provide the missing jcad_path semantics. The warning is a good start but insufficient for a state-modifying tool.

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

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

Schema description coverage is 0%, so the description must compensate. It documents parent, message, position, and user, but omits the required jcad_path param entirely. Moreover, several explanations are vague (e.g., 'position of the annotation', 'first messages in the annotation'), adding limited clarity.

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 'Add an annotation to the document', a specific verb+resource statement that clearly distinguishes it from siblings like remove_annotation. It also clarifies the return value (annotation id) and the mutation side effect, reinforcing purpose.

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 an explicit usage prerequisite: 'To understand the current state of the document, you MUST first use the get_current_cad_design tool.' This is strong guidance, though it does not explicitly mention alternatives or exclusions beyond the implicit contrast with remove_annotation.

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 explicitly warns that the tool updates the JCAD document at the given jcad_path and states the return value (the document itself). However, it doesn't disclose other behavioral aspects like whether the operation is destructive, requires permissions, or what happens 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: a clear one-line purpose, individual parameter docs, and a warning section. All sentences contribute value, though the param list is a bit verbose but necessary given the schema lacks descriptions.

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

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

With 9 parameters, no output schema, and no annotations, the description covers all parameters, states the return type, and provides a critical prerequisite warning. This is fairly complete, but it could be enhanced by noting edge cases or the nature of the document update (e.g., persistent vs in-memory).

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 with :param lines for every parameter, adding meaningful details such as color format ('#FF5733' or RGB float list) and units for rotation_angle (degrees). Some descriptions like 'position: The shape 3D position' could be more specific, but overall it provides 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?

Description clearly states the verb ('Add') and resource ('a box to the document'), and specifically distinguishes it from sibling tools like add_cone, add_sphere, etc. The scope is unambiguous.

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

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

Description gives explicit prerequisite guidance: 'you MUST first use the get_current_cad_design tool' to understand the document state before adding. This tells the agent when to use the tool, though it doesn't mention 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?

With no annotations, the description carries the burden of disclosing side effects. It explicitly warns 'This tool will update the JCAD document at the given jcad_path' and also states the return value ('The document itself'). This goes beyond a bare 'Add a cone' and is transparent about mutation.

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 compact docstring with one line per parameter, a clear opening sentence, and a brief warning. No superfluous text; every sentence contributes necessary information. The structure is scannable and front-loaded with the 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 10 parameters, no annotations, and no output schema, the description covers purpose, all parameter semantics, a mutation warning, and a return value. It lacks only minor details like coordinate system conventions, but the mandatory call to get_current_cad_design provides essential context 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?

Schema description coverage is 0%, but the description explains every parameter in detail, including meaning and examples (e.g., angle: '0: no cone, 180: half cone, 360: full cone'). It also clarifies color formats and position/rotation semantics, fully compensating for the schema's lack of descriptions.

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

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

The description opens with 'Add a cone to the document,' which is a specific verb+resource that clearly distinguishes this tool from siblings like add_box, add_cylinder, and add_sphere. It unambiguously states the tool's function without ambiguity.

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

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

The description includes a mandatory prerequisite: 'you MUST first use the get_current_cad_design tool' to understand the document state. This provides clear timing/context for safe usage. It does not explicitly mention alternatives, but the tool name and sibling list make the choice obvious.

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 disclosing behavior. It warns that the tool will 'update the JCAD document at the given jcad_path,' clearly indicating a write operation, and instructs the agent to first read the current state. It also mentions the return value as the document itself. This is transparent about the mutating nature, though it omits details on error handling or overwrite semantics.

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 into a one-line purpose, a parameter docstring, and a warning. It is not overly long, and every section adds necessary value given the lack of schema descriptions. The front-loading of purpose is effective, though the warning is slightly verbose with formatting whitespace.

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 9 parameters, no output schema, and no annotations, the description covers all parameters, the return value, and the prerequisite for usage. It explains the mutation behavior and points to get_current_cad_design for context. It could be more complete by specifying whether the cylinder is centered at position or how rotation axes relate to the shape, but overall it is sufficiently complete for a typical CAD manipulation tool.

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

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

The input schema has zero parameter descriptions, so the description fully compensates by explaining each parameter in detail (name, radius, height, angle, color, position, rotation_axis, rotation_angle). It even clarifies angle semantics (0: no cylinder, 180: half, 360: full) and color format (hex or RGB float list). This goes well beyond the schema's bare properties and defaults.

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 'Add a cylinder to the document.' This is a specific verb and resource, and it distinguishes the tool from siblings like add_box, add_cone, add_sphere, and add_torus. 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 does not explicitly mention alternatives, but it provides a key usage prerequisite: 'To understand the current state of the document, you MUST first use the get_current_cad_design tool.' This gives clear context on when to use the tool and emphasizes inspecting the document before mutation. However, it lacks explicit when-not-to-use or alternative recommendations.

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

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

With no annotations, the description must carry the transparency burden. It discloses that the tool updates the JCAD document at jcad_path and that pythonocc-core is required. However, it does not explain exactly what 'update' entails (e.g., overwrites, appends, in-place), how the shape string should be interpreted, or potential failure modes. This is partial disclosure but leaves key behaviors ambiguous.

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 and front-loaded: the purpose is stated first, followed by prerequisites, parameter details, return type, and a critical warning. Every sentence earns its place, and the param list adds value given the schema's lack of descriptions. The only slight issue is the omission of jcad_path in the param list, but the warning covers it implicitly.

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 complex, has no annotations, and no output schema. The description covers purpose, prerequisites, side effects, and param meanings, but leaves significant gaps: how to specify the shape string, what transformations are applied relative to the current coordinate system, and what happens on error or missing dependencies. Given the complexity, these omissions make the description incomplete though not misleading.

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

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

Schema description coverage is 0%, so the description must compensate. The :param block explains five of six parameters (shape, name, position, rotation_axis, rotation_angle) with brief meanings, including units for rotation_angle. Notably, jcad_path is omitted from the param block, only mentioned in the warning. The descriptions are terse and do not explain the shape format or defaults, providing only partial compensation.

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

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

The description clearly states the tool's purpose: 'Add an OpenCascade TopoDS shape to the document.' This specifies the verb (add), resource (document), and the type of shape (OpenCascade TopoDS). It distinguishes itself from primitive shape tools (add_box, add_cone) and file-based tools (add_step_file) by explicitly naming TopoDS.

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 useful context: it requires pythonocc-core, updates the document, and instructs the agent to first call 'get_current_cad_design' to understand the document state. However, it does not explicitly compare against sibling tools or state exclusion criteria, so it falls short of a 5.

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

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

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It explicitly warns that the tool updates the JCAD document and instructs the user to read the current state first. It also mentions the return value, which is the document itself. This is stronger than typical but lacks details on error behavior or permanence.

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 opening, parameter list, and warning section. The angle explanations repeat across three parameters but add necessary detail. Overall, it is appropriately sized with no filler, though slightly repetitive.

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 10-parameter tool with no output schema and no annotations, the description covers the essential aspects: purpose, parameter semantics, return value, and side-effect warning. It lacks details on units, coordinate system, and a few parameter nuances, but these are minor gaps given the overall coverage.

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 steps in with explanations for 9 of 10 parameters. It provides meaningful semantics for angles (degrees and effect on sphere shape) and color (hex or RGB list). However, position and rotation_axis remain vague ('The shape 3D position' and 'The 3D axis used for the rotation'), and jcad_path is missing from the param list even though it is referenced in the warning.

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

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

The description states a specific action and resource: 'Add a sphere to the document.' This clearly conveys the tool's purpose. However, it does not differentiate this tool from sibling tools such as add_box or add_cylinder, so it misses the top score.

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

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

The description provides a clear prerequisite: 'To understand the current state of the document, you MUST first use the get_current_cad_design tool.' This gives useful context for when to use the tool. It does not mention explicit alternatives or when-not-to-use scenarios, 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?

The disclosure that the tool 'will update the JCAD document' indicates a mutating operation, and the instruction to first fetch the current design is useful context. However, it does not reveal whether the update is additive, destructive, or how failures are handled, which is important 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 short but begins with 'None,' which is noise. The warning about updating the document is useful, but the overall structure is poor and not well-formatted for an AI agent.

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 six parameters and no output schema or annotations, the description is severely lacking. It only provides a warning and prerequisite, leaving out the tool's core functionality and parameter semantics.

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 makes no mention of any of the six parameters (jcad_path, path, name, position, rotation_axis, rotation_angle). With schema description coverage at 0%, the agent has no guidance on what these parameters mean or how to use them.

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 says 'Warning: This tool will update the JCAD document at the given jcad_path.' This does not state that the tool adds a STEP file; 'update' is generic and the resource is vague. The tool name suggests the purpose, but the description lacks 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 description provides a clear prerequisite: 'To understand the current state of the document, you MUST first use the get_current_cad_design tool.' However, it does not explain when to use this tool versus alternatives like add_box or add_cone, nor does it explicitly state that this is for importing STEP files.

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 does disclose that the tool updates the document and returns the document itself, and it warns about the required pre-step. However, it does not mention potential side effects (e.g., whether an existing object is overwritten) or error behaviors, and the return description is minimal. This is adequate but not deeply transparent.

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

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

The description is well-structured: a one-sentence purpose, a clear list of parameter explanations, a return note, and a warning. The param list is somewhat lengthy but necessary given the lack of schema descriptions. The warning is front-loaded enough to emphasize the prerequisite. No filler or redundancy, so it earns a 4 rather than a 3.

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 11 parameters, no output schema, and no annotations, the description covers most essentials: what the tool does, the key parameter semantics, the return value, and the necessary precondition. Missing details include a thorough definition of jcad_path and coordinate system specifics, but overall the description is complete enough for an agent to use the tool correctly.

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

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

Although schema description coverage is 0%, the description compensates well by explaining 10 of 11 parameters, including radius meanings, angle ranges with examples, and color format. The only required parameter, jcad_path, is not explicitly described in the parameter list, and 'position' and 'rotation_axis' are somewhat vague. Still, the description adds substantial meaning beyond the schema's bare 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?

The description clearly states 'Add a torus to the document' with a specific verb and resource. It distinguishes this tool from sibling tools like add_box, add_sphere, and add_cone by naming the exact shape. The purpose is unambiguous and immediately understandable.

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

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

The description provides clear usage context by warning that the tool updates the JCAD document and instructs that one must first use 'get_current_cad_design' to understand the current state. This is a concrete prerequisite. However, it does not explicitly mention alternatives or when not to use this tool, 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?

With no annotations, the description carries the full burden. It discloses that the tool updates the JCAD document, defaults to the last created object, and returns the document, adding behavioral context beyond the schema. It does not cover all edge cases but gives key operational 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 structured with a brief intro, parameter list, and warning. While longer than ideal, each section adds necessary information for a 9-parameter mutation tool, so no redundant content is apparent.

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

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

The description covers the operation, default behavior, all parameters, return value, and prerequisite call, which is substantial for a complex tool with no annotations or output schema. Minor gaps remain, such as how edge indices are determined or potential side effects.

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 documents 8 of 9 parameters with meaningful explanations (e.g., shape accepts name or index, color format). jcad_path is only mentioned in the warning, and some parameter details are generic, but overall it adds substantial value.

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 applies a chamfer operation on an object, making the purpose specific. It does not explicitly differentiate from the sibling 'fillet' tool, so sibling distinction is implied by the term 'chamfer' rather than stated.

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

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

It provides usage guidance by explaining the default operand (last created object) and warns that users must first call get_current_cad_design to understand document state. It does not mention alternatives or when not to use it, so it stops short of full when/when-not guidance.

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

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

With no annotations, the description carries full disclosure burden. It warns that the tool updates the JCAD document at the given path, explains the fallback operand selection, and specifies the return value (the document itself). It does not detail error cases or intended vs. destructive behavior fully, but the mutation and prerequisite are transparently 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 structured with an opening statement, a colon-prefixed parameter list, return line, and a warning block. It is somewhat lengthy but every section adds value. The front-loaded purpose and clear separation of param docs make it easy to scan, though the warning could be more compact.

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 9 parameters, no output schema, and no annotations, the description is remarkably complete. It covers purpose, all parameter semantics, default behaviors, return value, side effects (document update), and a prerequisite action. This is sufficient for an agent to invoke the tool correctly.

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

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

Schema coverage is 0%, so the description must explain parameters. It provides detailed descriptions for all 9 parameters, including type alternatives (string/index), defaults (color, position, rotation_axis, rotation_angle), and the meaning of 'refine'. This goes well 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 opens with 'Apply a cut boolean operation between two objects,' which clearly states the verb (apply), resource (boolean operation), and scope (between two objects). It distinguishes from sibling boolean tools like 'fuse' (union) and 'intersect' by its specific operation name and description of operands.

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

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

Provides clear usage context: if no objects are provided, the last two created objects are used as operands, and a warning mandates using 'get_current_cad_design' first to understand the document state. However, it does not explicitly contrast with alternatives like 'fuse' or 'intersect', so it falls short of a 5.

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

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

With no annotations provided, the description carries the full burden. It warns that the tool updates the JCAD document and requires prior state inspection. It also describes the fallback behavior and return value. These disclosures are significant, though it does not mention side effects like reversibility or permission requirements, preventing a 5.

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

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

The description is front-loaded with a clear purpose statement and then systematically presents parameters and a warning. It is somewhat lengthy but every sentence serves a purpose. The structure is logical, though the param list could be tightened by grouping related transformations, making it not perfectly 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?

The description provides a comprehensive overview: purpose, parameters, return value, mutation warning, and prerequisite. However, it does not explain how to determine the edge index for the fillet, which is critical for using the tool correctly. This gap in operational guidance prevents a 5, but overall the description is well-rounded.

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's param list adds substantial meaning beyond the schema's basic types and defaults. It explains that 'shape' can be a name or index, defines default color behavior, and clarifies edge, radius, and rotation semantics. This compensates well for the schema's lack of descriptions, even if jcad_path is only referenced in the warning rather than the param list.

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

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

The description clearly states the tool's function with a specific verb and resource: 'Apply a fillet operation on an object.' It also distinguishes this tool from siblings like chamfer and other edge operations, and clarifies behavior with the fallback to the last created object when no input is provided.

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: it explains the default operand behavior ('If no objects are provided as input, the last created object will be used as operand') and explicitly instructs the agent to use 'get_current_cad_design' before invoking the tool. However, it does not explicitly mention alternatives or when not to use the tool, so it falls short of a perfect score.

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

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

Since no annotations are provided, the description carries the full burden. It discloses that the tool updates the JCAD document, defaults to the last two created objects, and returns the document. It also warns about the mutation. This goes beyond the minimal requirement and gives useful operational context.

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

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

The description is front-loaded with the core purpose, followed by a structured list of parameters and a clear warning. It is appropriately sized given the number of parameters, though the shape2 typo is a minor structural blemish. Each sentence contributes 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?

For a mutation tool with 9 parameters and no output schema, the description covers the return value, side effects, and operand defaults. It could be enhanced by noting that the shapes must already exist in the document and by clarifying the refine option's effect, but the description is complete enough for an agent to invoke the tool correctly.

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

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

The schema provides no descriptions (0% coverage), so the description must explain the parameters. It describes each parameter in natural language, including types, defaults, and meaning. A minor flaw is that shape2 is incorrectly described as 'the first object' (should be 'second'), but all other parameters are clearly explained, and jcad_path is addressed in the warning.

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 'Apply a union boolean operation between two objects' with a specific verb and resource, distinguishing it from sibling operations like cut and intersect. The additional note about default operands further clarifies the tool's 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 provides important usage context: if no objects are passed, the last two created objects are used, and it warns that the JCAD document will be updated and that the agent must call 'get_current_cad_design' first. However, it does not explicitly compare with alternative boolean tools like cut or intersect, nor state exclusions for 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 the burden. It discloses the tool is read-only via 'Read' and 'before modifying it', implying no side effects. However, it doesn't mention error behavior (e.g., missing file) or permissions, but for a simple read 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?

Description is appropriately short and front-loaded. It has a clear purpose sentence, a usage hint, and param/return docs. The ':param' and ':return' lines are somewhat formulaic but not bloated.

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 one parameter and an output schema. The description covers purpose, usage, and param meaning. It doesn't need to detail return format since an output schema exists. Adequate 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?

Schema has 0% description coverage, but the description adds a param doc: ':param jcad_path: The path to the JCAD file.' This gives meaning beyond the schema's bare title 'Jcad Path'. It's minimal but sufficient for a single string parameter.

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

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

Description clearly states the tool 'Read the current content of a JCAD (JupyterCAD) document', using a specific verb and resource. It distinguishes from sibling tools which are all mutating or transformation operations (add, remove, cut, fuse, etc.).

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

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

Explicitly advises 'Use this tool to understand the current state of a JCAD file before modifying it', giving clear when-to-use context. It doesn't mention when not to use it or name alternatives, but the sibling list makes alternatives obvious (mutating 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?

The description discloses key behavioral traits: it updates the JCAD document at jcad_path, requires prior state knowledge via get_current_cad_design, and falls back to the last two created objects. While it does not mention potential side effects on operand objects, it provides meaningful operational warnings beyond the bare 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 moderately long but well-structured, starting with the core purpose, then param details, and ending with a critical usage warning. Every element contributes useful information, though the param block is somewhat 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?

The description covers purpose, parameters, side effects, precondition (get_current_cad_design), and return value (the document itself). It is complete enough given the lack of output schema and annotations, though it could mention operand preservation or more explicit examples.

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

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

With 0% schema description coverage, the description fully compensates by documenting all 9 parameters. It explains shape1/shape2 accept names or indices, color accepts hex or RGB list with a default, and clarifies rotation axis and angle units. This adds substantial 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?

The description clearly states the tool applies an intersection boolean operation between two objects, using a specific verb and resource. It also notes the default behavior of using the last two created objects, which distinguishes it from sibling tools like cut and fuse.

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

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

The description provides clear context for when to use the tool, including the fallback to the last two created objects if none are provided. It also instructs the agent to use get_current_cad_design first to understand the document state. However, it does not explicitly discuss alternatives or 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 carries the full burden of disclosing behavior. It explicitly warns that the tool 'will update the JCAD document at the given jcad_path,' revealing its mutating nature. It also documents the return value as 'the document itself.' While it does not detail all side effects, it provides substantial behavioral insight.

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 one-line purpose, a brief param/return section, and a prominent warning. The warning is placed effectively at the end, adding useful context without bloating the text. The formatting is clean and easy to parse.

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 simple mutation tool is well described for its context: it explains the mutation, the prerequisite state check, and the return value. It does not cover error cases or dependency impacts, but given the tool's simplicity and lacking annotations, the description is 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?

The schema has no parameter descriptions, so the description must compensate. It defines 'name' as 'The name of the object to remove,' and the warning mentions 'jcad_path' as the document path. Both parameters are thus clarified, but the description does not provide full syntax or format details, and 'jcad_path' is only implicitly defined.

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 as 'Remove an object from the document.' The verb 'Remove' and resource 'object' are specific, and the phrase 'from the document' clarifies scope. While it does not explicitly contrast with sibling tools like 'remove_annotation,' the term 'object' provides implicit differentiation.

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

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

The description gives a clear usage prerequisite: 'To understand the current state of the document, you MUST first use the get_current_cad_design tool.' This provides context for when it is safe to call the tool. However, it does not mention alternatives or explicit when-not-to-use scenarios, stopping short of a full 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 are provided, so the description carries the burden. It discloses that the tool mutates the document ('will update the JCAD document') and warns about needing current state. This is meaningful beyond the implied remove operation, though it doesn't detail reversibility or return 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 concise and includes only necessary elements: purpose, parameter hint, and critical warning. Formatting is slightly awkward with indentation, but each sentence contributes to safe usage.

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

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

Given the simple two-parameter remove operation, the description covers the core purpose, a mutation warning, and a usage prerequisite. It lacks explicit return value info, but the operation is straightforward and the warning suffices for basic completeness.

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

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

Schema description coverage is 0%. The description documents annotation_id ('The id of the annotation') but jcad_path is only vaguely referenced in the warning. It fails to fully explain both parameters, leaving a gap for the user.

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 'Remove an annotation from the document'—a specific verb and resource. This distinguishes it from siblings like add_annotation and generic remove.

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

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

Provides explicit prerequisite guidance: 'you MUST first use the get_current_cad_design tool' to understand document state before removal. This is clear context, though it does not discuss alternatives or exclusions.

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

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

The description explicitly warns that 'This tool will update the JCAD document at the given jcad_path', disclosing the mutation side effect. It also notes the return value (the document itself). With no annotations present, this warning carries the transparency burden, but it does not cover failure modes or conflict handling.

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

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

The description is compact and includes only necessary elements: purpose, parameters, return value, and a safety warning. It is not overly verbose, though the formatting with extra whitespace and indentation could be tighter.

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 rename operation, the description covers the action, all three parameters, the return value, and a critical warning about document mutation. It does not discuss edge cases like nonexistent old names or naming constraints, but such details are secondary given the tool's straightforward nature.

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 provides per-parameter explanations for old_name and new_name in the :param lines, and the warning clarifies jcad_path as the target document location. Since the schema has no descriptions (0% coverage), this addition is valuable and compensates for the lack of structured documentation.

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

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

The description clearly states the action ('Rename') and the target ('an object in the document'), providing a specific verb and resource. It distinguishes this tool from siblings such as remove or add_box by focusing on renaming, and the JCAD document context is reinforced by the warning.

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 instructs the agent to first use 'get_current_cad_design' to understand the current document state, which is a clear and important prerequisite. It does not explicitly compare with alternatives, but no sibling tool handles renaming, so the implicit usage context is sufficient.

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

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

With no annotations, the description carries the burden of disclosing side effects. It explicitly states 'This tool will update the JCAD document at the given jcad_path,' which signals mutation. However, it does not disclose permissions, failure behavior, or whether changes are reversible. The 'MUST first use' warning adds context, but the disclosure is not exhaustive.

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

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

The description is concise, with a clear first sentence, parameter docs, and a warning. It is front-loaded with the core purpose. The warning is somewhat verbose but necessary. No redundant or extraneous content.

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

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

This is a simple mutation tool with no output schema, so return values need not be explained. The description covers purpose, a prerequisite, and mutation side effect. However, the lack of jcad_path documentation, combined with no mention of error handling or object-not-found behavior, leaves moderate gaps. The tool is usable but not fully self-sufficient.

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

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

The schema has 3 parameters with no descriptions (coverage 0%). The description documents 'name' and 'value' (including hex format for value), which adds meaning. However, 'jcad_path' is only implicitly referenced in the warning ('at the given jcad_path') and lacks explicit definition or format. Given the low schema coverage, the description only partially compensates, leaving a critical parameter underspecified.

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 'Set the color of an object,' which identifies the specific action and resource. While it doesn't explicitly differentiate from sibling tools like 'set_visible' or 'rename', the action is unambiguous and the tool name reinforces it. The scope ('an object') is slightly vague but acceptable for a generic setter.

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

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

The description provides a clear prerequisite: 'To understand the current state of the document, you MUST first use the get_current_cad_design tool.' This tells the agent when to use the tool relative to reading state. It does not mention alternatives or exclusions, but the warning establishes a necessary condition for safe usage.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It explicitly warns that the tool updates the JCAD document and mandates reading the current design first, which is valuable context for a mutating operation. It doesn't cover reversibility or errors, but it provides the key side 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 short and front-loaded with the core purpose, followed by clear parameter notes and a necessary warning. Each sentence contributes value; only minor formatting inconsistency (param lines vs. prose) prevents a 5.

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 no output schema, the description provides the critical update side effect and prerequisite, but it leaves jcad_path undefined and value type ambiguous. It's adequate for a simple mutation tool but has clear gaps.

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

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

The description explains 'name' and 'value' (True/False), adding meaning beyond the bare schema types. However, 'jcad_path' is left unexplained, and 'value' is declared as string in the schema while the description implies boolean, creating ambiguity. With 0% schema coverage, the description only partially compensates.

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 'Set the visibility of an object' uses a specific verb and resource, and the sibling tools list confirms no overlap (e.g., set_color for color, remove for deletion). It clearly states the tool's function.

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

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

The description gives explicit context: 'To understand the current state of the document, you MUST first use the get_current_cad_design tool.' This tells the agent when to use this tool relative to a required prerequisite, though it doesn't mention alternatives or exclusions.

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