KeyShot MCP

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

Annotations already flag destructiveHint=true, and the description adds the dual action of applying and saving, plus 'create or update' implying potential overwrite of existing camera names. However, it doesn't disclose file overwrite specifics or required permissions, so it adds only modest context beyond annotations.

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

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

The description is a single, well-structured sentence with no filler. It front-loads the action and outcome, making it efficient 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?

Given the schema's 100% parameter coverage and presence of an output schema, the description sufficiently covers the main workflow. Minor ambiguity in 'configured standard-view or absolute camera preset' is clarified by the schema's presetName description, making it adequately complete for a tool with strong annotations.

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

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

Schema coverage is 100%, with each parameter described. The tool description's high-level summary maps to parameters but doesn't add details beyond the schema, justifying the baseline score of 3.

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: create/update a saved camera from a preset and save the scene. It uses specific verbs and resources ('create or update', 'camera preset', 'save the edited scene') and distinguishes from siblings like keyshot_set_camera or keyshot_save_scene by combining both actions.

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 a combined workflow (apply preset and save) and hints at using keyshot_list_camera_presets via the presetName schema description. However, it does not explicitly name alternatives or when-not-to-use conditions, 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?

Annotations already indicate destructive behavior (destructiveHint=true), and the description adds that the tool saves the edited scene. This is useful context beyond the raw annotation. However, it does not elaborate on other behavioral aspects such as file overwriting specifics, potential errors, or prerequisites. Given the annotation coverage, a score of 3 is appropriate.

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

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

The description is a single, front-loaded sentence that conveys the essential action without redundancy. Every word contributes to understanding the tool's purpose and workflow. It is concise and well-structured.

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

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

The description, combined with the fully detailed schema and output schema, provides sufficient context for understanding the tool's function. It covers the core workflow (apply material, save scene) without needing to explain return values. Minor gaps such as explicit failure modes or prerequisites are not critical given the schema richness, but a bit more behavioral context would make it fully complete.

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

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

The input schema provides 100% coverage with detailed descriptions for all six parameters, including the distinction between objectName and objectPath and materialName and materialPath. The tool description itself adds no additional parameter semantics beyond what the schema already provides, so the baseline of 3 holds.

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: applying a KeyShot library material or local material file to a specific object, followed by saving the scene. This distinguishes it from sibling tools like keyshot_apply_material_preset (which applies a preset) and keyshot_save_scene (which only saves). The verb 'apply' and resource 'material' are precise and unambiguous.

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

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

The description implies usage context by mentioning 'library material or local material file,' which hints at when to use this tool versus the preset-based alternative. However, it does not explicitly name alternatives or provide exclusionary guidance. The context is not fully developed, so it falls short of a 4.

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 clearly states that a new scene is saved, implying the original input scene is not overwritten. This adds useful behavioral context beyond the annotations' destructiveHint=true, which might otherwise suggest the tool modifies the original. It does not disclose error handling for missing presets or object resolution, but the core side-effect is 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 a single concise sentence that front-loads the verb 'Resolve' and clearly outlines the three-step action. No filler or redundant information, every word earns its place.

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

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

Given the output schema exists, return values need not be explained. The description covers the full workflow from preset resolution to final save, and combined with rich parameter descriptions, it is sufficiently complete for an agent to invoke correctly. Minor gaps include object disambiguation (objectName vs objectPath) but this is covered in the schema.

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

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

Schema description coverage is 100%, with each parameter (scenePath, objectName, objectPath, presetName, outputScenePath) having detailed descriptions. The tool description adds no additional parameter semantics, and the baseline for high schema coverage is 3.

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 specifies a clear multi-step action: resolve a preset, apply it to one object, and save a new scene. This distinguishes it from sibling tools like keyshot_apply_material and keyshot_list_material_presets by emphasizing the preset resolution and new scene output.

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

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

The description implies usage for applying a material preset and saving a new scene, but does not explicitly state when to choose this over alternatives like keyshot_apply_material. The parameter description for presetName references keyshot_list_material_presets, giving some context, but no explicit when-not or alternative guidance is provided.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, which the description does not contradict. The description adds that output goes to a directory but does not disclose additional behavioral details like overwrite rules, rendering time, or process requirements, though the schema covers overwrite.

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

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

The description is a single sentence that immediately states the action and scope. It contains no filler or redundant 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?

Despite being brief, the tool is well-specified through its rich schema (100% parameter coverage), annotations, and output schema. The description provides a clear overview; however, it omits explicit guidance on when to use this vs. sibling render tools, which is a minor gap.

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

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

All 10 parameters have schema descriptions, and the schema provides detailed semantics (e.g., overlapping samples/maxTimeSeconds, outputDir path restrictions, qualityPreset values). The tool description itself adds no parameter-specific meaning beyond saying 'explicit list of saved cameras'.

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

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

The description uses a specific verb 'Render' and identifies the resource: 'explicit list of saved cameras from one scene' into an output directory. This clearly distinguishes it from siblings like keyshot_render_all_cameras (all cameras) and keyshot_preview_render.

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 batch-rendering specific cameras but does not explicitly state when to choose this over alternatives such as keyshot_render_all_cameras or keyshot_preview_render. The 'cameras' parameter schema adds a prerequisite ('Use keyshot_list_cameras first') but this is not in the tool description.

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

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

The annotations already declare destructiveHint=true and readOnlyHint=false, so the safety profile is known. The description adds that it applies 'requested composition options' and 'saves a new scene', but does not disclose overwrite behavior or other potential side effects beyond what the schema implies. This is acceptable but not rich.

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

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

The description is a single sentence that front-loads the primary action ('Import a supported local model'), specifies the optional base scene, and states the output. It contains no redundant or vague words.

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

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

Given the tool's moderate complexity, complete schema descriptions, and the presence of an output schema, the description adequately summarizes the workflow. It does not discuss limitations like unsupported formats or error handling, but those are covered by the schema and output schema, and the description is sufficiently complete for an import 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 full descriptions for all 7 parameters (100% coverage), including paths and boolean options. The description's phrase 'apply requested composition options' is a high-level aggregation and adds no detail beyond the schema, so the baseline 3 is appropriate.

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

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

The description uses a specific verb ('Import') and resource ('a supported local model') and states the outcome ('save a new scene'). It clearly distinguishes this tool from siblings like keyshot_render or keyshot_inspect_scene by focusing solely on the import workflow.

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

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

The description clearly indicates when to use the tool: to import a model into either an empty or an existing base scene and then save a new scene. While it does not name explicit alternatives, the scenario is specific enough to guide selection among siblings.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds the 'read-only' behavior and specifies the exact data returned (metadata, objects, cameras, etc.), which provides additional context beyond the annotations without contradiction.

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

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

The description is a single concise sentence that front-loads the core action ('Open a scene read-only') and efficiently lists the return items. No redundant words or details.

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

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

For a simple read-only inspection tool with a single parameter, an existing output schema, and strong annotations, the description covers the necessary aspects: what it does, what it returns, and its safety profile. It does not address edge cases like missing files, but these are not essential given the output schema and read-only 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 input schema already provides full documentation for the single parameter 'scenePath', including its type and purpose. The description does not add further parameter-level details, so it does not improve on the schema's coverage.

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

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

The description uses specific verbs ('Open', 'return') and clearly identifies the resource ('scene') and the scope of what is returned (metadata, objects, cameras, material assignments, model sets, external references). It effectively distinguishes this inspection tool from rendering or camera-specific siblings.

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

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

The description implies usage when a read-only inspection of the scene is needed, but it does not explicitly state when to use this tool over alternatives like keyshot_list_cameras or keyshot_status. There is no mention of exclusions or preferred scenarios, leaving usage inferred from the verb 'inspect' and 'read-only'.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds behavioral context by specifying that it reads a JSON configuration and does not open KeyShot. This goes beyond the structured hints, but could further explain failure modes (e.g., missing/invalid JSON) or the difference between 'standard' and 'absolute' presets.

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 well-structured sentence that front-loads the action ('Read... return...') and includes all essential information without filler. Every word contributes to understanding the tool's purpose and behavior.

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

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

For a zero-parameter read-only tool with an output schema and strong annotations, the description is complete. It states the input source (configured JSON), the operation (return presets), and the key constraint (without opening KeyShot). No additional return-value documentation is needed since an output schema exists.

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

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

The tool has zero parameters, and the schema is trivially fully described. With no parameters to document, the description doesn't need to provide parameter-level details. Given the 0-param baseline of 4, this is appropriate.

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

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

Description clearly states it reads the configured camera preset JSON and returns valid standard or absolute camera presets, with the key qualifier 'without opening KeyShot'. This distinguishes it from other camera-related tools like keyshot_list_cameras (which likely lists scene cameras) and keyshot_apply_camera_preset (which applies presets).

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 phrase 'without opening KeyShot' provides clear context for when this tool is appropriate: when you need to inspect available presets without launching the application. However, it doesn't explicitly name alternatives or state when not to use it, such as clarifying that keyshot_list_cameras is for current scene cameras.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the contextual note 'without saving changes', which reinforces that opening the scene will not persist modifications. This is useful but not extensive, and it aligns with annotations, so a mid-range score is appropriate.

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 composed of two concise sentences: the first states the core function and the second provides contextual usage. Every word earns its place, and the main action is front-loaded, making it clear and efficient.

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

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

For a simple list tool with one parameter, the description covers purpose and usage, while the output schema and annotations handle return values and safety. The description also clarifies the non-mutating behavior, making it complete for the tool's 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 description coverage is 100%, with the scenePath parameter fully described as an absolute path to an existing KeyShot scene file, including a note about paths outside the output directory. The description does not add any parameter-specific details, so it relies on the schema, which already carries the semantic weight.

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 'Return' and the resource 'saved camera names', and adds the qualifier 'without saving changes' to clarify the non-destructive nature. This distinguishes it from sibling tools like keyshot_set_camera or keyshot_render_all_cameras, which perform different actions.

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

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

The description explicitly advises using this tool 'before selected-camera rendering when names are unknown', providing a clear usage context. It does not explicitly name alternative tools, but the guidance implies where this fits in a workflow, which is sufficient for a straightforward list operation.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, but the description adds valuable context by specifying that it reads a local JSON configuration and does not open KeyShot. This goes beyond the safety profile of the annotations, though it doesn't detail response structure (covered by output schema).

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

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

The description is a single, well-structured sentence that quickly communicates the action, source, and output. Every word adds meaning, with no redundancy or filler.

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

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

This is a simple, parameterless tool with an output schema present. The description completely covers what the tool does and where it gets its data, leaving no significant gaps for an AI agent to invoke it correctly.

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

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

The tool has zero parameters, so the baseline is 4. The description adds the source of the data (configured local material preset JSON), which is useful semantic context beyond the empty input 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 reads a configured local material preset JSON and returns valid preset names and material sources, without opening KeyShot. This uses a specific verb and resource, and distinguishes it from sibling tools like keyshot_list_camera_presets or keyshot_apply_material_preset.

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: to obtain a list of material presets without needing to launch KeyShot. However, it does not explicitly mention alternatives or when not to use it, so it stops short of the highest 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?

The description discloses that temporary previews are deleted after embedding, which is a non-obvious behavioral detail beyond the readOnly/idempotent/non-destructive annotations. It also explains that an optional output path preserves a copy, aligning with the schema's 'never overwrites' guarantee.

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

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

The description is two sentences, front-loaded with the primary action, and the second sentence efficiently conveys the temporary-file lifecycle. No superfluous 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?

The tool has 7 parameters and an output schema, so the description need not detail returns or every parameter. It covers the two most important behavioral caveats—temporary deletion and optional persistence—while annotations and schema cover the rest, making it sufficiently complete.

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

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

Schema coverage is 100% and the description adds no parameter-specific syntax beyond what is already in the input schema. The phrase 'safe output path preserves a copy' mirrors the schema's outputPath description, providing no additional semantic 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 renders a bounded PNG preview from an existing scene and returns it directly as MCP image content. This specific verb-resource-output combination distinguishes it from sibling render tools like keyshot_render or keyshot_batch_render, which likely produce full-resolution files.

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

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

The description implies the tool is for bounded previews delivered as image content, which fits quick visual checks, but it does not explicitly compare to sibling tools or state exclusions. The context is clear but lacks direct guidance such as 'use this instead of keyshot_render for fast previews.'

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 annotations already declare destructiveHint=true. The description adds useful context such as 'headless process' and 'save a scene copy,' but it does not disclose details about overwrite behavior, error handling in allCameras mode, or what happens to the original scene. This is moderate additional value beyond 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?

One sentence with a colon-separated list, front-loaded with the action, and every phrase earns its place. No redundant filler or restatement of the title.

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 32 parameters, a single overview sentence is relatively thin. It omits important modes (single vs allCameras), mutual-exclusion constraints (modelPath vs scenePath), and overwrite behavior—though these are all covered in the schema. The description gives a helpful overview but isn't sufficient for an agent to fully understand the workflow without deep schema inspection.

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

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

Schema coverage is 100% with every parameter described. The description groups steps (assign materials, configure camera/environment, save scene copy, render) that map to parameter families, but it does not introduce any semantics beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Run') and resource ('complete product workflow'), with a concrete list of steps that clearly distinguishes this from single-purpose sibling tools like keyshot_import_model, keyshot_apply_material, or keyshot_render. It immediately signals the tool's all-in-one scope.

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

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

The phrase 'complete product workflow' implies end-to-end use, but the description never explicitly says when to prefer this over individual sibling tools, nor does it mention exclusions or alternatives. Usage context is implied rather than stated, so it earns a 3.

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

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

Annotations already flag destructiveHint=true, and the description adds that it outputs to an image file. However, it does not disclose potential overwriting of outputPath, render time expectations, or license/prerequisite requirements. The description adds minimal behavioral context beyond the annotations, so it meets but does not exceed the baseline.

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, well-structured sentence that front-loads the action and outcome. Every word adds value, with no redundant or filler 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?

Given the tool has 9 parameters and multiple render-related siblings, the description is somewhat minimal. It explains the basic purpose but does not guide the agent on when to choose this tool over alternatives or warn about side effects. The presence of a complete output schema and parameter descriptions keeps it at a minimally viable level.

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

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

Schema description coverage is 100% with detailed per-parameter descriptions (e.g., qualityPreset dimensions and samples, samples vs. maxTimeSeconds conflict). The tool description adds no additional parameter-level meaning, so it does not go beyond what the schema already provides.

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

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

The description clearly states the core action: 'Render the active or a named camera from an existing scene to an image file.' This uses a specific verb ('Render') and resource ('camera from an existing scene'), and the title 'Render one KeyShot view' further distinguishes it from batch or product render siblings.

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

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

The phrase 'from an existing scene' and 'active or a named camera' implies a single-view render use case, but the description does not explicitly contrast with siblings like keyshot_batch_render, keyshot_preview_render, or keyshot_render_all_cameras. It offers some contextual guidance without naming 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?

Annotations already disclose destructive intent (destructiveHint=true) and non-read-only nature. The description adds valuable context: headless process, collision-safe file names, and per-camera results. This goes beyond the structured annotations, though it omits details like error handling or overwrite behavior (which are in the schema).

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

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

The description is a single, well-structured sentence that front-loads the primary action ('Discover every saved camera') followed by key attributes. Every phrase earns its place—headless process, collision-safe filenames, per-camera results—without redundancy.

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

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

Given the tool's complexity (10 parameters) and the presence of a full output schema, the description provides a solid overview: it states the operation, scope (all cameras), and notable behavior (headless, collision-safe, per-camera). It doesn't need to explain return values due to the output schema, and annotations cover the destructive nature. Minor gaps remain around error handling or overwrite semantics, but these are covered by the schema.

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

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

The description does not delve into parameter specifics, but the input schema provides 100% coverage with detailed descriptions for all 10 parameters. Thus, the description adds no additional semantic value beyond what the schema already offers, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool's function: discover every saved camera and render each view in one headless process. This distinguishes it from siblings like keyshot_render (single render) or keyshot_list_cameras (listing only) by emphasizing 'every saved camera' and 'per-camera results'.

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

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

The description implies the tool is for batch rendering all cameras, providing clear context for when to use it. However, it doesn't explicitly mention alternatives or when not to use it, such as when only a specific camera is needed or when interactive rendering is required.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false. The description adds the key behavioral detail that processing is sequential to avoid KeyShot license and output file competition, going beyond what annotations provide. The potential to overwrite output files is implied by the warning about output files, though not explicitly stated.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to explaining the tool's purpose and rationale.

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 core behavior (sequential rendering of independent jobs) and the rationale (avoiding conflicts). With an output schema present and rich input schemas for each job, the description does not need to explain return values or all parameters. It is complete for the tool's primary function, though it could briefly mention the continueOnError option, which is already described in the schema.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not elaborate on any individual parameters; it only states that jobs are independent scene and camera jobs, which is already captured in the schema. No additional semantic meaning beyond the schema is provided.

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

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

The description uses the specific verb 'Render' with the resource 'independent scene and camera jobs' and the mode 'sequentially', clearly distinguishing it from parallel rendering tools like keyshot_batch_render. 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 states that jobs are rendered sequentially to avoid license and output file conflicts, implying this tool is for use when multiple independent render jobs could interfere. It does not explicitly name alternative tools, but the context is clear enough for an agent to infer appropriate use.

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

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

Annotations already declare destructiveHint=true, so the tool is known to be potentially destructive. The description adds the safe output directory constraint but does not disclose whether the original scene is modified, whether files may be overwritten, or what side effects opening the scene has on the current session.

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

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

The description is a single, focused sentence that immediately states the tool's purpose and key constraint. There is no unnecessary wording or repetition of the title.

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 only two parameters, a detailed schema, and a truthful annotation set. The description covers the essential behavior (open, save copy to allowed path). It lacks explicit mention of side effects (e.g., overwriting, effect on current scene), but these are partially covered by the destructiveHint annotation and the output schema would explain results.

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

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

Schema description coverage is 100%, with both parameters already documented in the schema. The description adds the safe directory requirement for outputScenePath, but this is also present in the schema. It does not add further semantic value beyond the structured fields.

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 ('save a copy') and the resource (a KeyShot scene), and specifies the destination constraint (inside the configured safe output directory). This distinguishes it from sibling tools like keyshot_render or keyshot_import_model.

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 usage is implied by the description and name, but there is no explicit guidance on when to use this tool versus alternatives, nor any exclusions. It does not mention for example 'use keyshot_inspect_scene to view without saving'.

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

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

Annotations already indicate destructiveHint=true and readOnly=false, and the description aligns by stating 'create or update' and 'save the edited scene.' However, it does not disclose additional behavioral details like whether an existing scene is overwritten or if any permissions/validations apply, so it only minimally adds transparency beyond the annotations.

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

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

The description is a single, well-structured sentence with the action verb front-loaded. It avoids filler and directly states the purpose, making it highly concise and readable.

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

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

Given the detailed schema with 100% parameter coverage and the presence of an output schema, the description sufficiently covers the primary action. Minor gaps exist around usage versus camera-preset tools, but the high-quality schema information compensates, making the description adequately complete.

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

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

The schema description coverage is 100% with per-property explanations, including constraints like position/lookAt pairing and fieldOfView/focalLength exclusion. The description merely lists the parameter categories and does not add meaningful semantics beyond what the schema already provides, so a baseline score of 3 is appropriate.

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

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

The description uses a specific verb--create or update--and identifies the resource as a named camera, with the adjustable parameters listed. It clearly distinguishes itself from sibling tools like keyshot_list_cameras or keyshot_apply_camera_preset by emphasizing direct camera configuration and scene saving.

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

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

The description clearly implies the tool is for directly configuring a camera and saving the result, but it does not explicitly address when to use it instead of alternatives such as applying a camera preset. The absence of explicit exclusions keeps it from a perfect score, though the context is unambiguous.

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 states it 'save[s] the edited scene', which is consistent with the destructiveHint=true annotation. It also discloses that it selects an environment and optionally changes brightness/rotation, providing behavioral context beyond the hint. No contradictions found.

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

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

The description is a single sentence that front-loads the core purpose, then lists optional adjustments and the save action. Every word earns its place with no redundancy.

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

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

The description covers the key aspects: selection methods, optional parameters, and saving behavior. With an output schema present and annotations disclosing destructive behavior, the description does not need to explain return values or safety. It is complete enough for a tool with six parameters and two required fields.

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

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

Schema description coverage is 100%, so the schema already explains all parameters (e.g., environmentName vs environmentPath mutual exclusion, outputScenePath destination). The description adds a little by saying 'optionally change brightness and rotation' and 'select by library name or local file', but this mostly reflects existing schema descriptions. Baseline 3 is appropriate.

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

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

The description uses a specific verb-resource pair: 'Select an environment' and then explains the optional modifications and save action. It clearly distinguishes from sibling tools like keyshot_set_camera (camera setup) and keyshot_save_scene (just saving), as this tool combines environment selection/editing with saving.

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

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

The description gives clear context on when to use: when the user wants to change the environment in a KeyShot scene by library name or local file, adjust brightness/rotation, and save the result. It does not explicitly mention exclusions or alternatives, but the purpose is stated clearly enough that an agent can infer its use case.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable context beyond annotations by noting it performs a 'minimal KeyShot headless startup' and explicitly states the tool does not modify a user scene, which reinforces the non-destructive nature.

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, well-structured sentence that uses a strong verb ('Diagnose') and lays out all covered areas without extra words. It is front-loaded and immediately communicates the tool's purpose.

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

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

With zero parameters, rich annotations, and an output schema (as indicated by context), the description fully covers what is needed: what the tool checks and its safety guarantee. No additional return-value explanation is required due to the output schema.

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

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

The tool has zero parameters, so there is nothing to describe beyond the schema. The schema coverage is 100% (empty object), and the description does not need to add parameter meaning. The baseline for 0 parameters is 4, which is appropriate here.

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 identifies the tool as a diagnostic action ('Diagnose') and specifies the exact resources it covers (local installation, output access, presets, bridge files, minimal headless startup). This distinct focus on status checking differentiates it from sibling tools like rendering, importing, or material operations.

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 (to check local installation and setup status) but does not explicitly mention alternatives or situations to avoid. However, the diagnostic purpose is self-evident relative to the sibling tool names, which are all action-oriented (render, apply, import).

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

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

Annotations already flag destructiveHint=true, lowering the burden. The description adds useful behavioral context: it detects changes, copies to a collision-safe path (avoiding overwrites), and optionally returns a preview. It also notes the tool is a stable alternative to GUI control, giving insight into its operating style. No contradictions with 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 two sentences, front-loaded with the core workflow, and contains no filler. It efficiently conveys the main actions and the key differentiator (stable alternative to GUI control) without redundancy.

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

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

With 9 parameters and an output schema, the description provides a solid high-level overview of the workflow, covering the main steps and the preview option. It does not delve into all edge cases, but the schema and output schema fill in the necessary detail. The description is complete enough for an agent to understand the tool's role and scope.

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

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

Schema description coverage is 100%, so the baseline is 3. The description's reference to 'collision-safe output path' and 'detect whether it changed' aligns with outputScenePath and previousFingerprint, but it does not add additional meaning beyond the schema. The schema already explains all parameters clearly, so the description adds minimal incremental 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's function: find a .bip file, detect changes, copy to a collision-safe path, and optionally generate a preview. It names the specific resource (.bip) and scope (newest in one folder). It also distinguishes itself as the stable alternative to unsupported persistent GUI control, setting it apart from sibling tools focused on rendering or scene inspection.

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 when syncing saved KeyShot scenes is needed and positions it as an alternative to GUI control. However, it does not explicitly state when to use this tool versus sibling tools like keyshot_save_scene or keyshot_inspect_scene, and gives no exclusion criteria. The guidance is implied rather than explicit.

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