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

With no annotations provided, the description carries full burden for behavioral disclosure. While it mentions the tool creates a document and returns success/failure messages, it lacks critical details like permission requirements, whether the document becomes active/selected, what happens if a document with the same name exists, or any rate limits. The description provides minimal behavioral context beyond the basic 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 reasonably structured with clear sections (Args, Returns, Examples), but includes some redundancy. The example JSON could be more concise, and the 'Returns' section could be integrated more efficiently. While not excessively verbose, it doesn't achieve the efficiency of the highest-scoring examples.

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

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

Given the tool has an output schema (which should document return values) and only 1 parameter, the description covers the basics adequately. However, for a creation tool with no annotations, it should provide more behavioral context about what 'creating a document' entails in FreeCAD's environment and how it relates to sibling tools.

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 only 1 parameter and 0% schema description coverage, the description effectively compensates by explaining that 'name' refers to 'The name of the document to create'. It provides a concrete example showing how to use the parameter, adding meaningful context 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 the action ('Create a new document') and resource ('in FreeCAD'), making the purpose immediately understandable. However, it doesn't differentiate this tool from sibling tools like 'create_object', which might create confusion about when to use each.

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

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

No guidance is provided about when to use this tool versus alternatives like 'create_object'. The description mentions the tool's basic function but offers no context about prerequisites, when it's appropriate, or what distinguishes it from similar tools in the server.

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

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

With no annotations provided, the description carries full burden. It clearly indicates this is a creation/mutation operation ('Create a new object'), describes the return format ('message indicating success or failure and a screenshot'), and provides extensive examples showing different object types and their properties. However, it doesn't mention potential side effects, permissions needed, or error handling 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 excessively long with 7 detailed examples that could be condensed. While the initial purpose statement is clear, the examples section dominates the description and includes redundant formatting. The structure could be improved by summarizing example patterns rather than listing numerous full JSON examples.

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 (5 parameters, nested objects, no annotations) and the presence of an output schema, the description provides substantial context. It explains parameter usage thoroughly, shows return format, and covers multiple object categories. However, the excessive examples make it less efficient, and it could benefit from more behavioral context about mutations and dependencies.

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 explaining all 5 parameters through the 'Args' section and extensive examples. It clarifies 'doc_name' as document name, 'obj_type' with specific prefixes and examples, 'obj_name' as object name, 'analysis_name' context for FEM objects, and 'obj_properties' with detailed property structures across multiple object types.

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

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

The description clearly states the verb 'Create' and the resource 'new object in FreeCAD', with specific examples of object types starting with 'Part::', 'Draft::', 'PartDesign::', or 'Fem::'. It distinguishes from siblings like 'create_document' (which creates documents rather than objects) and 'edit_object' (which modifies existing objects).

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

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

The description implies usage for creating various FreeCAD objects with examples, but doesn't explicitly state when to use this versus alternatives like 'create_document' for documents or 'edit_object' for modifications. It provides context through examples but lacks explicit guidance on tool 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool deletes an object, implying a destructive mutation, and mentions a return message and screenshot, which adds some context beyond the basic action. However, it doesn't cover critical aspects like permissions needed, whether deletion is reversible, error handling, or side effects on related objects, leaving gaps in transparency.

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

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

The description is well-structured and concise, with no wasted words. It starts with the core purpose, followed by clear sections for arguments and returns, making it easy to parse. Every sentence serves a functional role, and the information is front-loaded for quick understanding.

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 (a destructive operation with 2 parameters) and the presence of an output schema (implied by 'Returns' section), the description is moderately complete. It covers the basic action and parameters but lacks details on behavioral traits like safety, prerequisites, or error cases. The output schema helps, but without annotations, the description should do more to address mutation risks and usage context.

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

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

The schema description coverage is 0%, so the description must compensate. It lists and briefly explains the two parameters ('doc_name' and 'obj_name'), adding meaning beyond the schema's minimal titles. However, it doesn't provide details like format examples, constraints, or how to find valid names, which limits the added value. Given the low coverage, this is adequate but not comprehensive.

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

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

The description clearly states the tool's purpose: 'Delete an object in FreeCAD.' It specifies the verb ('Delete') and resource ('an object in FreeCAD'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from sibling tools like 'edit_object' or 'get_object', which would require more specific context about when deletion is appropriate versus modification or retrieval.

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 doesn't mention prerequisites (e.g., whether the object must exist), exclusions (e.g., not for read-only operations), or comparisons to siblings like 'edit_object' for modifications. This lack of context leaves the agent to infer usage based on the tool name alone.

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

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

No annotations are provided, so the description carries full burden. It mentions the tool edits an object and returns a success/failure message with a screenshot, but doesn't disclose behavioral traits like required permissions, whether edits are destructive or reversible, error handling, or rate limits. This is inadequate for a mutation tool with zero annotation coverage.

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

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

The description is appropriately sized and front-loaded, starting with the core purpose. The Args and Returns sections are structured clearly, though the second sentence could be more concise. Overall, it avoids unnecessary verbosity and organizes information effectively.

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 (3 parameters, nested objects, no annotations) and the presence of an output schema (which covers return values), the description is moderately complete. It explains the purpose, parameters, and returns, but lacks behavioral context and detailed parameter semantics, making it adequate but with clear gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It lists the three parameters (doc_name, obj_name, obj_properties) with brief explanations, adding meaning beyond the bare schema. However, it doesn't detail the format or constraints of obj_properties (e.g., what properties are editable), leaving some ambiguity. This partial compensation justifies a baseline score.

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

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

The description clearly states the tool's purpose: 'Edit an object in FreeCAD.' It specifies the verb ('edit') and resource ('object in FreeCAD'), making the action clear. However, it doesn't explicitly differentiate from siblings like 'get_object' or 'delete_object' beyond mentioning 'create_object' as an alternative, which slightly limits distinction.

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

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

The description provides some usage guidance by stating 'This tool is used when the `create_object` tool cannot handle the object creation,' which implies an alternative context. However, it lacks explicit when-not-to-use scenarios or comparisons to other siblings like 'delete_object' or 'get_object,' leaving gaps in comprehensive guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the return includes a success/failure message, output, and screenshot, but lacks critical details like security implications, execution environment constraints, error handling, or performance impacts for arbitrary code execution in FreeCAD.

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

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

The description is appropriately sized and front-loaded with the core purpose, followed by structured Arg and Return sections. Every sentence adds value, though the return details could be slightly 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 tool's complexity (executing arbitrary code) and lack of annotations, the description is moderately complete but has gaps. It covers purpose and return values (aided by the output schema), but misses critical behavioral context like safety warnings or usage constraints, making it inadequate for full understanding.

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 meaningful context for the single parameter ('code: The Python code to execute'), which is essential since schema description coverage is 0%. It clarifies the parameter's purpose beyond the schema's basic type and title, though it could provide more on code format or restrictions.

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 ('Execute arbitrary Python code') and the target resource/environment ('in FreeCAD'), distinguishing it from sibling tools that handle documents, objects, parts, and views rather than code execution. It uses precise verb+resource phrasing.

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. The description does not mention prerequisites, limitations, or scenarios where other tools might be more appropriate, such as using sibling tools for specific object manipulations instead of raw code execution.

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 retrieves an object and its properties, and returns a screenshot, which adds useful context about output behavior. However, it lacks details on permissions, error handling, rate limits, or whether this is a read-only operation (though 'get' implies non-destructive). The description doesn't contradict any 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 well-structured with a purpose statement, usage hint, and sections for Args and Returns. It's front-loaded with the main purpose and avoids unnecessary fluff. However, the usage hint could be more concise, and the structure is slightly verbose for a simple tool.

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

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

Given the tool's moderate complexity (2 parameters, no annotations, but has an output schema), the description is reasonably complete. It covers purpose, parameters, and return values (object and screenshot), and the output schema likely details the return structure. However, it could benefit from more behavioral context like error cases or dependencies.

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 compensates by explaining the parameters: 'doc_name: The name of the document to get the object from' and 'obj_name: The name of the object to get'. This adds clear meaning beyond the schema's basic titles. However, it doesn't specify format constraints or examples for the names.

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

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

The description clearly states the tool's purpose: 'Get an object from a document' and 'get the properties of an object'. It specifies the verb ('get') and resource ('object from a document'), making the intent understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_objects' (plural) or 'get_view', which might retrieve multiple objects or document views instead.

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 stating 'to get the properties of an object to see what you can check or edit', suggesting it's for inspection before potential edits. However, it doesn't provide explicit guidance on when to use this tool versus alternatives like 'get_objects' (for multiple objects) or 'edit_object' (for modifications), nor does it mention prerequisites or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions that the tool returns a list of objects and a screenshot, which adds some context beyond basic functionality. However, it doesn't cover important aspects like whether this is a read-only operation, potential performance impacts, error conditions, or how the screenshot is formatted, leaving significant gaps for a tool that retrieves document data.

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 concise with three sentences, but the second sentence ('You can use this tool...') is somewhat redundant with the first. The structured 'Args' and 'Returns' sections are helpful, but overall it could be more front-loaded and streamlined without losing essential information.

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

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

Given the tool's moderate complexity (retrieving objects and a screenshot from a document), no annotations, and an output schema present, the description is minimally adequate. It covers the basic purpose and return values, but lacks details on behavioral traits, error handling, or integration with sibling tools, which would enhance completeness for effective agent use.

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

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

The description adds meaningful context for the single parameter 'doc_name' by explaining it's 'The name of the document to get the objects from', which clarifies its purpose beyond the schema's basic title. Since schema description coverage is 0% and there's only one parameter, this adequately compensates, though it doesn't specify format or constraints for the document name.

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

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

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('all objects in a document'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from sibling tools like 'get_object' (singular) or 'get_parts_list', which would require a more precise distinction.

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 implied usage guidance by stating 'to see what you can check or edit', suggesting this tool is for inspection before editing. However, it lacks explicit guidance on when to use this versus alternatives like 'get_object' (for a single object) or 'get_parts_list', and doesn't mention prerequisites or exclusions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves a list but doesn't mention any behavioral traits such as read-only nature, potential rate limits, authentication needs, or what happens if no parts exist. This leaves significant gaps for a tool that likely interacts with a library system.

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

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

The description is a single, clear sentence that directly states the tool's purpose without any wasted words. It's front-loaded and efficiently communicates the essential information, 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?

Given the tool has 0 parameters, an output schema exists (which handles return values), and no annotations, the description is minimally adequate. However, it lacks context about the 'parts library addon' or how this tool fits with siblings, leaving room for improvement in guiding the agent's understanding of the broader system.

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, and the input schema has 100% description coverage (though empty). The description doesn't need to add parameter details, so it appropriately avoids redundancy. A baseline of 4 is assigned since no parameters exist, and the description doesn't introduce unnecessary complexity.

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 ('Get') and resource ('list of parts in the parts library addon'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_objects' or 'get_object', which might retrieve different types of data, so it misses the highest score for sibling distinction.

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. With siblings like 'get_objects' and 'insert_part_from_library' available, there's no indication of context, prerequisites, or exclusions, leaving the agent to infer usage based on tool names alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action ('Get a screenshot') and return value, but lacks details on permissions, rate limits, file formats, or error handling. For a tool that likely involves visual output and system interaction, this is a significant gap in transparency.

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

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

The description is well-structured with clear sections for Args and Returns, making it easy to parse. It's front-loaded with the core purpose. However, the list of views is somewhat lengthy and could be more concise, though it's necessary for completeness. Overall, it's efficient with minimal waste.

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 (single parameter with enum), no annotations, and an output schema (implied by 'Returns'), the description is adequate but incomplete. It covers the parameter well and states the return, but lacks behavioral context like how the screenshot is delivered (e.g., as an image file or data URL). This leaves gaps for an AI agent to use it effectively.

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

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

The description adds substantial meaning beyond the input schema. The schema has 0% description coverage, only providing an enum list. The description explains that 'view_name' is 'The name of the view to get the screenshot of' and lists all available views with examples, compensating fully for the schema's lack of context. This is excellent parameter clarification.

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 a screenshot of the active view.' It specifies the verb ('Get') and resource ('screenshot of the active view'), making the function unambiguous. However, it doesn't differentiate from sibling tools like 'get_object' or 'get_objects', which might also retrieve visual data, so it doesn't reach the highest 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 no guidance on when to use this tool versus alternatives. It lists available views but doesn't explain scenarios for choosing one view over another or when to use this tool compared to siblings like 'get_object' for object-specific screenshots. This lack of contextual advice limits its utility for an AI agent.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool inserts a part and returns a success/failure message with a screenshot, but lacks details on permissions, side effects, error handling, or rate limits. This is insufficient for a mutation tool with zero annotation coverage.

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 for Args and Returns, and it uses minimal sentences to convey key information. However, the first sentence could be more front-loaded with additional context, slightly reducing efficiency.

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

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

Given the tool has an output schema (which covers return values), the description doesn't need to detail returns extensively. However, as a mutation tool with no annotations and incomplete parameter guidance, it leaves gaps in behavioral and usage context, making it only minimally adequate.

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

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

The schema description coverage is 0%, but the description includes an 'Args' section that explains 'relative_path' as 'The relative path of the part to insert', adding meaningful context beyond the bare schema. However, it doesn't elaborate on format or examples, so it only partially compensates for the low 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 clearly states the action ('Insert a part') and the source ('from the parts library addon'), which is specific and distinguishes it from siblings like 'create_object' or 'get_parts_list'. However, it doesn't explicitly differentiate from similar tools like 'create_object' in terms of when to use one over the other, keeping it from a perfect 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 no guidance on when to use this tool versus alternatives such as 'create_object' or 'get_parts_list'. It mentions the parts library addon but doesn't specify prerequisites or contexts, leaving the agent without clear usage instructions.

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