KeyShot MCP

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

Annotations already declare readOnlyHint=false, destructiveHint=true, and idempotentHint=false. The description adds that it creates/updates a camera and saves the edited scene, confirming the mutation, but does not elaborate on what gets overwritten, auth needs, or rate limits.

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

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

A single, front-loaded sentence with no redundant or filler content. Every clause 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 a destructive write tool with an output schema and annotations that cover safety hints, the description states the core action and the save step. It is largely complete, though it omits how it relates to sibling camera 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?

Schema description coverage is 100%, so all four parameters are documented in the schema. The description mentions the preset concept but adds no meaning beyond the schema's parameter descriptions (e.g., cameraName default). Baseline 3 applies.

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?

States a specific verb and resource: create or update a saved camera from a preset, then save the edited scene. Clear what the tool does, but does not differentiate it from siblings such as keyshot_set_camera or keyshot_save_scene.

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

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

Usage is implied by the operation, but the description provides no explicit when-to-use guidance, no alternatives (e.g., keyshot_set_camera), and no exclusions. An agent must infer the appropriate context.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false and idempotentHint=false, so the safety profile is covered. The description adds meaningful context beyond that: it discloses that the operation ends by saving the edited scene, telling the agent the call results in a persisted output rather than an in-memory edit.

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?

A single sentence with no filler, and the material-then-object-then-save sequence is front-loaded logically. It is appropriately sized, though it is terse enough that a little more usage guidance could have been added without bloat.

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 an output schema present and annotations covering the destructive/idempotency profile, the description only needs to convey the mutation-and-save flow, which it does. Minor gaps remain around duplicate-name disambiguation and the exactly-one-of parameter pairings, though those are largely handled 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?

Schema description coverage is 100%, so the schema already explains all six parameters, including the either/or pairing of objectName/objectPath and materialName/materialPath. The description adds nothing about parameter formats or constraints beyond restating 'library material or local material file', so the baseline of 3 applies.

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?

States a specific verb ('Apply'), a specific resource ('KeyShot library material or local material file'), and scope ('to a specific object, then save the edited scene'). It implicitly separates itself from keyshot_apply_material_preset by naming library/local material files, but it never names that sibling explicitly, so differentiation is left partly to inference.

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

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

Usage is implied by the wording ('library material or local material file'), which points an agent toward the materialName vs materialPath options, but there is no explicit when-to-use/when-not guidance and no routing to alternatives like keyshot_apply_material_preset or keyshot_list_material_presets.

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, idempotentHint=false and openWorldHint=false, so safety is covered structurally. The description adds useful workflow context ('resolve a preset', 'apply to one scene object', 'save a new scene'), signaling a new file rather than in-place edit, but it does not explain what is overwritten or what permissions/paths are required.

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?

A single front-loaded sentence that moves from resolution through application to the save outcome with no filler. It is efficient, though slightly terse given the tool's mutation semantics.

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 a full input schema, an output schema, and annotations covering the safety profile, the description only needs to convey the workflow, which it does. The main residual gap is the absence of any mention of the sibling apply_material alternative.

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 documents all five parameters, including the objectName/objectPath alternative and the output-directory constraint. The description adds no syntax or format meaning beyond that, making the baseline 3 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 gives a specific verb sequence (resolve, apply, save) and names its resource (a material preset) and target (one scene object). It implicitly distinguishes itself from the sibling keyshot_apply_material by specifying presets, though it never names that sibling explicitly.

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

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

Usage is only implied: the mention of resolving a 'configured material preset' points the agent toward the preset workflow, but there is no explicit when-to-use, when-not-to-use, or comparison against keyshot_apply_material. Prerequisites such as having a preset listed are left to the schema.

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, non-idempotent, non-read-only, so the description should explain *how* it's destructive (overwriting existing files). It only implies writing into a directory and never mentions overwrite behavior, side effects, or that it is a heavy/long operation, adding little 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?

A single efficient sentence front-loads the verb and output. It is appropriately short, though slightly thin given the tool's complexity.

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 an output schema present, return values needn't be explained, and the schema covers parameters fully. However, for a destructive batch render tool with many configurable options, the description omits overwrite/destructive behavior and alternative-tool routing, leaving notable 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 100%, so all 10 parameters (cameras, outputDir, qualityPreset, samples, maxTimeSeconds, etc.) are fully documented in the schema. The description adds no parameter semantics beyond what the schema provides, so baseline 3 applies.

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?

States a clear verb (render) and resource (explicit list of saved cameras) plus the destination (output directory). It distinguishes itself somewhat from siblings like keyshot_render_all_cameras (all vs. explicit list), though it does not name that distinction explicitly.

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 word 'explicit list' implies you must already know camera names, and the schema notes to call keyshot_list_cameras first. But the description itself gives no when-to-use vs. keyshot_render_all_cameras or keyshot_render 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?

Annotations already declare the safety profile (destructiveHint=true, idempotentHint=false), so the description only needs to enrich it. It does add that a new scene is written, but it does not state what gets destroyed (does it overwrite an existing outputScenePath file?), that the operation is not idempotent, or any failure behavior. Some added value, but the destructive consequence is left implicit.

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?

A single front-loaded sentence that sequences the three actions (import, compose, save) with no filler or repetition. Every clause carries 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?

An output schema exists, so return values need not be described, and the 100%-covered schema carries the parameter burden. What is missing is the mutation-risk context an agent needs for a destructive, non-idempotent tool: overwrite semantics for outputScenePath, whether an existing scene is replaced, and any environmental prerequisites.

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 all seven parameters are already documented with meaning and constraints (model formats, KEYSHOT_OUTPUT_DIR rule, 'when supported' caveats). The description only gestures at 'requested composition options', which adds no semantics beyond the schema, so the baseline 3 applies.

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?

States a concrete verb+resource ('Import a supported local model') and scopes it to a specific target ('empty or base scene') followed by a save step, so an agent can distinguish it from the render/material/camera siblings. It does not explicitly name which sibling to use instead for plain scene saving, so it falls just short of a 5.

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 'into an empty or base scene' plus the baseScenePath semantics implies when this tool applies (starting a new scene), but there is no explicit when-not guidance, no mention of prerequisites (e.g. KeyShot must be running, scene must not be locked), and no pointer to keyshot_save_scene for simple save cases. Usage is inferable rather than stated.

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, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered by structured data. The description's 'read-only' merely restates that, but it does add useful behavioral detail about what gets returned (including external references), which is more than the annotations provide.

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, front-loaded with the action and scope, with the return contents enumerated compactly. Nothing is wasted or buried.

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 a rich annotation set, a fully documented single parameter, and an output schema present, the description need not explain return values or safety. The only shortfall is the absence of routing guidance relative to sibling inspection 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?

Schema coverage is 100% and the single parameter's description is thorough, including that input files may lie outside the configured output directory. The description adds no parameter-level meaning beyond the schema, so the baseline of 3 applies.

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 pairs a specific verb ('Open ... read-only') with the resource ('a KeyShot scene') and enumerates the returned payload (metadata, objects, cameras, material assignments, model sets, external references). This is clearly distinct from siblings like keyshot_list_cameras or keyshot_status, though it never explicitly names those alternatives.

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

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

Usage is only implied by 'read-only' — an agent can infer this is for non-mutating inspection. There is no statement of when to prefer this over keyshot_list_cameras, keyshot_status, or keyshot_sync_saved_scene, and no prerequisites or exclusions are given.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and a closed world. The description adds real value beyond them by stating it reads a pre-configured preset JSON file and requires no KeyShot session — a meaningful operational precondition. It stops short of describing failure modes (malformed/missing JSON) or how 'valid' is determined.

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?

A single front-loaded sentence with no filler: the action, the source, the output, and the offline constraint are all packed in 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 an output schema present and rich annotations, the description need not explain return values, and it covers the read-only, offline nature of the call. The remaining ambiguity is the source/configuration of the preset JSON, which leaves a minor gap for an agent deciding whether results will be current.

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 takes zero parameters, so the baseline of 4 applies. The description correctly implies no inputs are needed, though it does not explain where the 'configured camera preset JSON' comes from or whether it is user-supplied configuration.

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

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

The description states a specific verb and resource — reads the configured camera preset JSON and returns valid standard or absolute camera presets — which is distinct from siblings like keyshot_list_cameras and keyshot_apply_camera_preset. It is clear, though it never explicitly names which sibling to prefer when an agent wants live camera data rather than stored 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?

Usage is only implied: an agent can infer this is a discovery step before keyshot_apply_camera_preset, and the 'without opening KeyShot' clause hints at the offline precondition. There is no explicit when-to-use or when-not-to-use guidance versus keyshot_list_cameras or keyshot_inspect_scene.

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, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered elsewhere. The description's 'without saving changes' merely restates that, and it adds no other behavioral detail (no note that the scene file is opened, no output/ordering info).

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

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

Two short, front-loaded sentences with no padding. The clause 'without saving changes' is slightly redundant against the annotations, costing it the top score.

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 single-parameter read-only list tool with a full output schema and complete annotations, the description supplies what it does and when to use it. Minor gap: it does not mention that the scene is opened as a side effect of passing scenePath.

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?

Only one parameter with 100% schema description coverage, so the baseline is 4. The description adds nothing about scenePath, but the schema already explains it as an absolute path to an existing scene file.

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?

States a specific verb and resource ('Return saved camera names') and implicitly distinguishes scene cameras from the sibling keyshot_list_camera_presets by saying 'saved camera names'. Clear to an agent, though it never explicitly names the preset-list sibling as the alternative.

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?

Gives a concrete when-to-use condition: 'Use this before selected-camera rendering when names are unknown.' That is actionable context, but there is no when-not guidance and no mention of the camera-preset alternative.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds genuine value beyond that by disclosing the source of truth (local preset JSON config) and that no KeyShot instance is required, which the annotations do not convey.

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?

A single front-loaded sentence with no filler. The verb comes first and the offline constraint is packed into the same clause, so 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?

With an output schema present, the description need not document return values, and it still summarizes them ('valid preset names and material sources'). For a zero-parameter read tool this is essentially complete; only an explicit alternative-tool pointer is missing.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate. Baseline 4 applies; the description correctly does not invent or omit any parameter detail.

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

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

States a specific verb ('Read') and resource ('configured local material preset JSON') with the output scope ('valid preset names and material sources'). This clearly separates it from the mutation-oriented siblings like keyshot_apply_material_preset, though it never names that sibling explicitly.

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?

'...without opening KeyShot' implies the usage context (offline, no live app needed), which is a real hint. However, it gives no explicit when-to-use vs the apply_material_preset or other list_* siblings, so the agent must infer the routing.

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 readOnly/idempotent/non-destructive, so the bar is lower; the description still adds real lifecycle context beyond them — temporary previews are deleted after embedding, and an optional safe output path preserves a copy. It stops short of naming the 'never overwrites existing files' rule that lives 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?

Two dense sentences with no filler, front-loading what the tool produces before the lifecycle caveat. Every clause 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?

An output schema exists, so return values need no explanation, and annotations plus schema cover safety and parameters. The only gap is prerequisites (e.g. scene must exist, KeyShot running), which an agent must infer from the required scenePath.

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 all seven parameters are already documented with defaults, ranges and constraints; the description only echoes outputPath preservation at a high level. Baseline 3 is appropriate since the schema does the heavy lifting.

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?

States a specific verb+resource ('Render a bounded PNG preview from an existing scene') and the delivery mechanism ('return it directly as MCP image content'). The word 'preview' plus 'bounded' separates it from full renders like keyshot_render, though it never names those siblings explicitly.

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

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

Usage is implied through 'preview' and the temporary-vs-persisted output choice, but the description never states when to prefer this over keyshot_render, keyshot_product_render, or keyshot_render_queue. No explicit when/when-not guidance is given.

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

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

Annotations already declare destructiveHint=true, idempotentHint=false, and openWorldHint=false, lowering the bar. The description adds that the run is headless and that a scene copy is saved, but it does not disclose what the destructive behavior actually overwrites despite the 'overwrite' option – a notable gap for a mutation tool.

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

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

A single front-loaded sentence that enumerates the workflow stages in order and wastes nothing. Given the complexity of 32 parameters, this is admirably tight.

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

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

An output schema exists, so return values need not be explained, and the schema fully covers the 32 parameters. The description adequately conveys the workflow scope, though it could say more about when this tool supersedes the granular siblings.

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 documents all 32 parameters, including enums and cross-parameter constraints. The description adds no parameter-level detail, so the baseline 3 applies.

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 names a specific composite verb set (open/import, assign materials, configure camera and environment, save, render) and the resource (a product workflow). It clearly positions itself as the one-shot orchestrator versus the granular siblings, though it never explicitly states that contrast.

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 'in one headless process' implies batch/automated usage and contrasts implicitly with calling the individual sibling tools, but there is no explicit when-to-use / when-not-to-use guidance or named alternative. Usage is only inferable.

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 declare destructiveHint=true, readOnlyHint=false and idempotentHint=false, but the description says nothing about overwriting an existing outputPath, permission requirements, or what a render run actually modifies. With annotations carrying the safety profile, the description should at least flag the overwrite/queue behavior, and it does not.

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?

A single front-loaded sentence with no waste, though it is arguably thin for a nine-parameter rendering tool rather than optimally sized.

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 nine-parameter, non-idempotent render tool with several near-identical siblings, an output schema and rich annotations, the description leaves the agent without routing guidance or output/overwrite semantics. The schema and output schema cover the mechanical details, but the definition does not fill the remaining gaps.

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

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

Schema coverage is 100% and every parameter, including enums for format and qualityPreset and mutual exclusions for samples/maxTimeSeconds, is documented in the schema. The description adds no parameter meaning beyond it, so the baseline 3 applies.

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?

States a specific verb (render) and resource (active or named camera from an existing scene) with the output being an image file. It does not, however, distinguish itself from the many sibling render tools (preview_render, product_render, batch_render, render_all_cameras), so the agent must infer the boundary.

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 when-to-use guidance and no mention of alternatives, despite five sibling tools that also render. An agent cannot tell from this sentence why it would pick keyshot_render over keyshot_preview_render or keyshot_render_all_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 destructiveHint=true, readOnlyHint=false, and non-idempotent, so the mutation/safety profile is covered. The description still adds non-obvious behavior beyond that: collision-safe file naming, a single headless process, and per-camera results. It does not explain the overwrite semantics tied to the destructive hint, which is the one notable gap.

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?

A single dense sentence, front-loaded with the verb and resource, that carries the batch scope, execution model, and output behavior without filler. Nothing is redundant with the title or schema.

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

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

An output schema exists, so return values (per-camera results) need not be re-explained, and annotations cover the safety profile. What remains thin is routing guidance among the many sibling render tools and the destructive-overwrite relationship, so the definition is adequate but not complete for a 10-parameter tool.

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

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

Schema description coverage is 100%, so the schema already documents width, height, samples, maxTimeSeconds, overwrite, continueOnError, and the rest. The description adds no parameter-level semantics (no default format, no preset/sample interaction), so it sits at the baseline for fully documented schemas.

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?

States a specific verb (render) and resource (every saved camera in the scene), scoping it as a whole-scene operation. This distinguishes it from keyshot_render (single render), keyshot_list_cameras (discovery only), and keyshot_batch_render without needing to open any schema.

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 'render each view in one headless process' implies the batch/campaign use case, but there is no explicit when-to-use vs. keyshot_render, keyshot_preview_render, or keyshot_batch_render, and no stated prerequisites or exclusions. Usage is left to inference from the name.

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, non-idempotent, non-read-only, so the safety profile is carried by structured data. The description adds genuinely useful context (serial execution to avoid license/output contention) but says nothing about what destruction actually means here — e.g. whether existing files at outputPath are overwritten, or that failure stops the queue by default.

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?

A single front-loaded sentence with no filler; the operative behavior (sequential execution) and its reason are both delivered immediately.

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

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

An output schema exists, so return values need not be explained. However, for a destructive, non-idempotent queue tool whose key semantics (overwriting outputs, default stop-on-error, ordering guarantees) live only in schema defaults, the description is thinner than the complexity warrants.

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 documents scenePath, outputPath, camera, qualityPreset, samples/maxTimeSeconds exclusivity, etc. The description adds no parameter-level detail, which is the expected baseline when the schema does the heavy lifting.

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?

States a specific verb and resource ('Render ... jobs'), and the adverb 'sequentially' plus 'independent scene and camera jobs' distinguishes it from a single-render tool. It does not name the close siblings (keyshot_batch_render, keyshot_render_all_cameras) it most resembles, so the distinction is implicit rather than explicit.

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

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

The rationale 'so KeyShot processes do not compete for a license or output files' implies when to choose this over firing off parallel renders, but no explicit when-to-use or when-not-to-use guidance against the sibling render tools is given.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, and idempotentHint=false. The description adds useful scoping context (the safe output directory, input files allowed outside it) but never explains what is destructive — e.g. whether an existing file at outputScenePath is overwritten — which is the key behavior the destructive hint flags.

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?

A single front-loaded sentence with no filler. The operation and its destination constraint come first, and nothing is wasted.

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

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

With an output schema present, return values need no explanation, and both required parameters are covered. The only real gap is the unaddressed destructive behavior (overwrite semantics), which matters given destructiveHint=true.

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 both parameters are already fully documented in the schema, including the output-directory restriction. The description's mention of the safe output directory restates that constraint rather than adding new meaning; baseline 3 applies.

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 names a specific verb pair (open + save a copy) and the resource (KeyShot scene), plus the destination constraint. It is clear what the tool does, though it does not explicitly distinguish itself from the similar-sounding sibling keyshot_sync_saved_scene.

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 when-to-use guidance is given, and no alternatives are named. The presence of a sibling named keyshot_sync_saved_scene makes the omission notable, since an agent must guess which one applies to its situation.

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 the write/destructive/idempotent profile (readOnlyHint=false, destructiveHint=true, idempotentHint=false), so the bar is lower. The description adds the useful side-effect that the scene is saved, but does not disclose what destructiveHint means here (e.g., an existing camera of the same cameraName being overwritten, or outputScenePath being clobbered).

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?

A single tight sentence with the action front-loaded and no filler. It could arguably be split to front-load the required scenePath/outputScenePath behavior, but nothing is wasted.

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

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

With 9 parameters, full schema coverage, an output schema, and rich annotations, the definition is adequate but thin: it omits the required input/output scene paths, the cameraName update-vs-create semantics, and the optional 'up' vector, so an agent still needs the schema to call it correctly.

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

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

Schema description coverage is 100%, so the schema already documents every parameter including mutual exclusions (fieldOfView vs focalLength, position+lookAt coupling). The description only restates a subset of these fields in prose and adds no format or constraint detail beyond the schema.

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

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

The description states a specific verb+resource pair ('Create or update a named camera') and enumerates the geometry inputs (position, target, distance, FOV, focal length), plus the save step. It is clearly distinguishable from list/inspect/preset siblings, though it never names an alternative directly.

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

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

There is no when-to-use guidance and no routing against the obvious alternatives (keyshot_apply_camera_preset, keyshot_list_cameras, keyshot_apply_camera_preset). The agent is left to infer when creating a custom camera beats applying a preset.

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 readOnly=false, destructive=true and non-idempotent, so the safety profile is partly covered. The description adds the open-edit-save flow ('save the edited scene'), but with destructiveHint=true it should disclose what the save overwrites or clobbers; that risk is never mentioned.

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?

A single front-loaded sentence that packs the selection modes, the optional edits, and the save step with zero filler. Nothing here is redundant or buried.

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 an output schema present, return values need no explanation, and the 100%-covered schema carries the parameter detail. The remaining gap is that the required scenePath/outputScenePath workflow and destructive overwrite behavior are not surfaced in the description.

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%, so brightness, rotation, environmentName/environmentPath and the scene paths are fully documented in the schema. The description only restates the same concepts at a higher level and adds no syntax, defaults, or interaction rules beyond the schema.

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

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

The description names a specific verb+resource ('Select an environment') and enumerates the two selection modes plus the optionals it also mutates (brightness, rotation) and the save step. It is clearly distinct from render/material/camera siblings, though it never names a sibling to differentiate itself.

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

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

It describes what the tool does but gives no when-to-use guidance, no prerequisites (scene must exist, output dir constraints), and no exclusions. The mutual exclusivity of environmentName/environmentPath is left entirely to the schema.

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, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds genuinely non-obvious context beyond those: it performs a 'minimal KeyShot headless startup' yet does so 'without modifying a user scene', which tells the agent a process launch occurs as part of a supposedly read-only check.

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?

A single front-loaded sentence with the verb first and the checked areas enumerated compactly. No filler, no 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?

An output schema exists, so return values need no explanation, and the description fully covers what is probed and confirms the non-destructive guarantee. The only gap is the absence of guidance on when this check should be triggered relative to the render siblings.

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 takes zero parameters, so the schema imposes no semantic burden and the baseline of 4 applies. Nothing in the description conflicts with the empty parameter object.

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?

States a specific verb (diagnose) and enumerates the exact resources checked: installation, output access, presets, bridge files, and headless startup. This clearly separates it from every sibling, which are render/scene/material/camera 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 diagnostic framing implies this is a pre-flight/health-check tool, but the description never states when to run it (before renders? on failure?) or names any alternative. Usage must be inferred from the name and scope.

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 idempotentHint=false, so the safety profile is partly covered. The description adds useful behavioral context (change detection, collision-safe naming, Agent-visible preview), but it never explains what is actually written or mutated on disk or where KEYSHOT_OUTPUT_DIR fits, which is exactly the gap the destructive hint raises.

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

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

Two sentences, both front-loaded and free of filler: the first gives the operation pipeline, the second gives the positioning rationale. It is well sized for a 9-parameter tool, though the first sentence is a fairly dense compound clause.

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 a full output schema and 100% parameter coverage, the description need not explain return values, and it correctly covers the core flow plus fingerprint-based skipping. It is nearly complete, missing only explicit guidance on the destructive/write side effects the annotations imply.

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 parameters are already fully documented; baseline is 3. The description only restates the sourcePath dual behavior (file vs. newest .bip in a folder), adding no syntax or format detail beyond the schema.

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

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

The description names a specific verb (sync) and resource (saved .bip scene) and enumerates the operation's concrete steps: locate the file, detect change, copy to a collision-safe path, optionally preview. It is clear what the tool does, though it does not name any sibling tool (e.g. keyshot_save_scene or keyshot_inspect_scene) to sharpen differentiation.

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

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

"This is the stable alternative to unsupported persistent GUI control" implies when to reach for it, but there is no explicit when-not guidance and no sibling is named as the alternative. The agent must infer selection from the phrasing alone.

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