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

With no annotations, the description carries the full burden and delivers the key traits: 'Calls can modify the active Blender scene and are never automatically retried.' That mutation warning and no-retry disclosure are exactly the safety context an agent needs. It omits auth/permission or concurrency details, so not a full 5.

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

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

Three sentences, front-loaded with the core action and the discovery prerequisite. Each sentence carries information, though the mid-sentence mention of execute_blender_code's parameters is slightly tangential to the tool's own 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?

No output schema exists, but the description compensates by stating it preserves 'its full MCP content and errors.' Combined with the mutation and no-retry disclosures and a documented timeout default, an agent has enough 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?

Schema coverage is 100%, so the schema already documents tool_name, arguments, and timeout_ms. The description only lightly augments this, noting that execute_blender_code accepts Python code and user_prompt. 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 and resource: 'Call a discovered tool on the configured Blender MCP server.' It names the sibling it depends on (blender_mcp_status) and clarifies the proxy nature of the tool, distinguishing it from the actual Blender tools it dispatches to.

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 clear prerequisite flow: 'Discover tool schemas with blender_mcp_status first,' and names a concrete example (execute_blender_code). It does not, however, explain when to prefer this over blender_mcp_edit_model, leaving one sibling relationship implicit.

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

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

With no annotations, the description carries the full burden, and it delivers real behavioral claims: output is verified, existing scene objects are preserved, and a shared filesystem plus Object Mode are required. It stops short of stating reversibility or permission/auth implications, but the preservation and requirement disclosures are substantive beyond anything structured data provides.

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, no filler, front-loaded with the core action and pipeline before the requirements and the optional bridge. Every clause (verified output, scene preservation, prerequisites, legacy bridge) carries distinct information.

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

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

For a complex 7-parameter mutation tool with no output schema, the description covers purpose, prerequisites, side-effect profile, and the alternate bridge path. It does not clarify the difference between standard and bridge execution or what 'verified output' concretely means, which is a modest remaining 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?

Schema description coverage is 100%, so the schema already documents all seven parameters in detail (execute, output_path defaults, timeout, operations syntax). The description adds only the bridge concept, so the baseline 3 for schema-dominant definitions 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?

States a specific three-part verb (import, edit, export) on a concrete resource (a local STL) through a named mechanism (standard Blender MCP). An agent can separate it from blender_mcp_export_stl (export only) and blender_mcp_call (generic) without opening 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?

Prerequisites are stated (shared local filesystem, Blender Object Mode) and the legacy-bridge path is flagged, which is useful context. However, it never states when to prefer this tool over siblings like blender_mcp_call or blender_mcp_export_stl, or when the bridge path applies, so usage remains implied rather than directed.

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

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

With no annotations, the description carries the full burden and does so well: world-space geometry, modifiers applied, no mutation of scene/selection/mode, and a verification step reporting triangle count and bounding-box dimensions from the written file. This is exactly the side-effect profile an agent needs for a write-to-disk 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?

Three dense sentences, front-loaded with the action and its guarantees, followed by usage routing and prerequisites. No filler and nothing that repeats structured fields verbatim.

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 the absence of an output schema, the description states what the caller gets back (triangle count and bounding-box dimensions) and covers prerequisites and non-destructive behaviour. Nothing needed to invoke it correctly is missing.

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

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

Schema description coverage is 100%, so every parameter is already documented, including the mm-vs-metres scale rationale and the no-overwrite rule for output_path. The description adds no parameter meaning beyond that, which is the expected baseline 3 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 ('export named objects from the live Blender scene to a new, verified STL') and explicitly distinguishes itself from the sibling export path by noting that Blender MCP's own export_scene writes GLB/FBX only. An agent can select it without opening 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?

Gives an explicit trigger ('use this after editing or modelling through blender_mcp_call') and names the alternative that does not do this job. Prerequisites (standard Blender MCP, shared local filesystem) are also 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?

With no annotations, the description carries the burden and does reasonably well: it states 'Connecting does not edit the scene' (a safety-relevant clarification), warns that include_schemas is large, and the schema documents the timeout default. It does not cover auth or failure behavior, keeping it short of a 5.

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

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

Three tight sentences, front-loaded with the core capability, then the tool_names behavior, then the safety note and sibling pointer. Little waste, though the parenthetical 'large' warning and the closing routing note slightly crowd the structure.

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 4-param, no-output-schema, no-annotation discovery tool, the description covers both operating modes, the schema-fetching path, the large-payload warning, and the correct sibling for scene checks. Only deeper behavioral detail (error handling, discovery limits) is missing.

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

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

Schema description coverage is 100%, so the schema already documents connect, timeout_ms, tool_names, and include_schemas with defaults and bounds. The description adds the intent behind tool_names ('the tools you will call') but no syntax or format detail beyond the schema, matching the baseline 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 names a specific resource (Blender MCP configuration / remote server tools) and the two distinct actions: inspect config or connect and discover tools. It is clearly distinguishable from blender_mcp_call, but the dual-mode framing (inspect vs. connect) makes the primary purpose slightly less crisp than a single-verb statement.

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 gives concrete usage direction: 'pass tool_names for the full input schemas of the tools you will call' and 'use get_scene_info through blender_mcp_call to check the Blender addon,' routing the agent to a sibling for scene verification. Absent is explicit when-not-to-use guidance, but the context is clear.

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

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

No annotations are provided, so the description carries the full disclosure burden. It does not state that cancellation is destructive and non-resumable, whether it aborts an in-progress print or just clears the queue, or what authentication/permissions 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 with zero filler. It is efficient, though its brevity is partly under-specification rather than disciplined economy.

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 destructive mutation tool with no annotations, no output schema, and six connection parameters silently defaulting from environment variables, the description is too thin. It should at minimum say the cancel is irreversible and note that host/type/api_key default from env.

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% and all six parameters are optional with env fallbacks, so the schema already documents everything. The description adds no parameter-level meaning beyond that, which warrants the baseline 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?

States a specific verb (Cancel) and resource (the current print job), which is enough to distinguish it from siblings like start_print or process_and_print_stl. It does not explicitly call out cross-printer scope, but the core action 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?

No when-to-use guidance, no prerequisites, and no reference to alternatives such as get_printer_status to confirm an active job before cancelling. The agent must infer all of this from the tool name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It says the tool translates the model, but does not state whether it modifies the file in place, returns a new file, requires write permissions, or what side effects occur.

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 specifies the operation and the target result with no wasted words.

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

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

For a simple one-parameter tool, the description adequately conveys the core action. However, without annotations or an output schema, it leaves open important behavioral details such as whether the original STL is modified or a new file is produced.

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%, and the single stl_path parameter is fully documented in the schema. The description adds no parameter-level meaning beyond the schema, 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 uses a specific verb ('Translate') and states the exact geometric outcome: centering the model at the origin (0,0,0). It is clear what the tool does, though it does not explicitly differentiate itself from the sibling translate_stl tool.

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 explicit guidance on when to use this tool versus alternatives such as translate_stl, nor any prerequisites or exclusions. Usage is only implied by the outcome described.

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

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

No annotations are provided, so the description carries full behavioral burden, and it does not disclose that run_bridge_probe spawns a bridge host process, that bridge_command is an executable that will be launched, or that some inputs are gated behind MCP_ALLOW_EXECUTABLE_ARG=1 (that constraint appears only in the schema). It also says nothing about side effects or environment requirements.

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 that front-loads the inspection targets and appends the optional probe last. No filler, though the packing of five distinct concerns into one clause makes it slightly harder to scan.

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 7-parameter diagnostic tool with no annotations and no output schema, the description should convey what the inspection returns and what the optional probe yields, but it stops at naming the targets. An agent cannot predict the shape or content of the result, leaving a significant 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?

Schema description coverage is 100%, so all seven parameters (including the enum platform and the executable-gated paths) are already fully documented in the schema, setting the baseline at 3. The description adds no parameter-level meaning beyond what the schema provides.

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

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

States a clear verb (inspect) and specific resources (FULU OrcaSlicer-bambulab install, runtime payload, setup commands, BambuNetwork bridge), so an agent knows this is a diagnostic/inspection tool. It does not explicitly distinguish itself from the related sibling fulu_bambu_network_rpc, which is the only differentiation gap.

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 no when-to-use or when-not-to-use guidance and names no alternatives. The only usage signal is the word 'optionally probe', which hints at a conditional mode but never says when an agent should enable it versus run a plain inspection.

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

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

With no annotations, the description carries the full behavioral burden and does disclose the key trait: it is read-only and does not itself gate printing, since printing tools enforce their own safety. It also defines the match rule (equality with the file's highest target). It does not say what is returned or what happens when a temperature fails to match, which matters for a verification tool with no 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?

Two sentences, front-loaded with the verb and resource, with no filler. The parenthetical enumeration of G-code forms is dense but each item is load-bearing for correct parsing expectations.

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?

Covers input semantics and scope well, but with no output schema and no return-value description, an agent cannot know whether a mismatch is reported as a boolean, an error, or a list of differing targets. For a confirmation/verification tool that gap is material.

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 the baseline is 3, but the description adds genuine meaning beyond the schema: it explains that bed_temp/extruder_temp match only when equal to the file's highest target, which is a non-obvious semantic the bare 'Expected highest bed target' wording does not convey. It also clarifies that targets are gathered from multiple G-code dialects, explaining why a single expected value is compared against many reported targets.

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 (report) and resource (every heater target in a G-code file), and enumerates the exact G-code forms covered (S/R, tool-addressed, RepRapFirmware G10/M568, Klipper SET_HEATER_TEMPERATURE). This clearly separates it from siblings like set_printer_temperature (which mutates) and get_printer_status (which reads live state, not a file).

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 pre-flight verification use case and notes that 'printing tools enforce their own safety gate,' which frames when this check belongs in a workflow. However, it never explicitly says when to use this versus get_printer_status or set_printer_temperature, nor what to do on a mismatch, leaving routing to inference.

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

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

No annotations are supplied, so the description carries the full behavioral burden for a mutation tool. It does not say whether the file is modified in place or a new file is written, whether the original is overwritten, what happens on failure, or what the response contains — all important for a destructive file 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, efficient sentence with the action and target front-loaded and zero wasted words. It is perhaps too terse given what is left unsaid, but nothing in it is redundant.

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

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

For a 2-parameter file-mutating tool with no annotations and no output schema, the description omits the essentials: in-place vs. new-file behavior, return value, and error conditions. An agent could call it but cannot predict the side effects.

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

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

Schema description coverage is 100%: stl_path ("Path to the STL file to modify") and extension_inches ("Amount to extend the base in inches") are both self-documenting, including units. The description's "by a specified amount" adds nothing 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?

The description gives a specific verb ("Extend") and a specific target region ("the base of an STL file"), which is clearer than the generic sibling names like modify_stl_section or translate_stl. However, it does nothing to distinguish itself from related STL-geometry siblings (scale_stl, rotate_stl, center_model, lay_flat), so an agent must infer the boundary on its own.

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 indication of when to use this rather than scale_stl, translate_stl, or modify_stl_section, no prerequisites (e.g., does the model need a flat base?), and no exclusions. The agent is left to guess how this differs from other geometry-editing tools in the list.

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

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

With no annotations, the description carries the full burden and does well: it discloses the default read-only posture, the mutating-method opt-in flag, the refusal class, and the reason (bypassing the print safety gate). It omits return/error behavior and timeout implications, but the safety semantics are unusually well communicated.

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

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

Three sentences, front-loaded with what the tool is, then the gating rules, then the refusal and alternative. Every sentence carries information; no filler or repeated schema text.

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 6-parameter passthrough with a free-form payload and no output schema, the description covers the safety model well but does not describe what an RPC call returns, how failures surface, or how to choose among the many allowed bridge methods beyond the schema's examples. Adequate but with clear gaps.

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

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

Schema description coverage is 100%, so the schema already documents method, payload, timeout_ms, bambu_model, bridge_command and allow_mutating_method. The description adds one genuinely useful nuance — that allow_mutating_method never enables print, printer-message or unknown methods — but otherwise restates schema-level guidance, fitting the baseline 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?

Names a specific resource (FULU BambuNetwork bridge RPC) used for diagnostics and development, and distinguishes its scope from print-oriented siblings by explicitly excluding raw print methods. The verb is generic (a passthrough RPC), so it is not a perfect verb+resource pair, but an agent can tell it apart from print_3mf and check_fulu_orca_setup.

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 explicit conditional routing: read-only methods allowed by default, agent/session setup methods require allow_mutating_method=true, and print/message/file-transfer/unknown methods are refused. It also names the correct alternative (print_3mf) for checked printing. It stops short of saying which diagnostic scenarios warrant calling this tool.

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

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

With no annotations, the description carries the full burden. It usefully discloses the output format (SVG) and that multiple angles are rendered, but says nothing about whether files are written to disk or returned inline, what the angle set is, dependencies (e.g., a rendering library), or performance 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 filler; every clause (generate, SVG, STL file, multiple angles) 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?

For a tool with no output schema, the description should say what the caller gets back (returned SVG content vs. written file paths) and roughly which views are rendered. The input side is fully covered by the schema, but the output side of the contract is not.

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%: stl_path, width, and height are all documented in the schema, including defaults. The description adds no parameter meaning beyond that, 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 (Generate) and resource (SVG visualization of an STL file) with the scope 'from multiple angles'. It is clearly distinguished from siblings like get_stl_info or blender_mcp_export_stl by the output artifact, though it never names a sibling to route against.

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 statement of when to use this versus alternatives such as get_stl_info, blender_mcp_export_stl, or slice_stl. The agent must infer the use case (visual inspection) on its own, and no exclusions or prerequisites are given.

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

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

No annotations are provided, so the description carries the full disclosure burden, yet it says nothing about authentication requirements, network behavior, failure modes, or whether it is a safe read operation. It discloses no behavior beyond the bare action.

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 wasted words. It is efficient, though its brevity is partly the source of the definition's gaps.

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 six connection parameters, no annotations, and no output schema, the description should explain what status information is returned and any connection/auth expectations. As written it is too thin for the tool's configured surface.

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 six parameters (host, port, type, api_key, bambu_token, bambu_serial) are already documented, including that they default from env. The description adds no parameter meaning 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 specific verb (Get) and resource (current status of the 3D printer), so the action is unambiguous. It does not differentiate from siblings such as list_printer_files or get_slice_settings, which also read printer state.

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, no mention of alternatives, and no prerequisites (e.g. needing a configured host or API key). Usage is only implied by the tool 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?

With no annotations, the description carries the full burden. It does disclose that this is a non-mutating inspection ('without slicing') and enumerates the setting categories returned (layer height, infill, walls, supports, brim, bed, printer, filaments), which partially compensates for the missing output schema. It says nothing about permissions, error behavior, or resolution precedence between source_path and template_name.

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 and resource first, followed by an efficient parenthetical field list. No filler, though the parenthetical is long enough that it slightly competes with the core claim.

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 three-parameter, zero-required read tool with no output schema, listing the returned setting categories goes a long way toward filling the return-value gap, and the schema covers source alternatives. The remaining gap is the precedence/interaction between source_path and template_name, which is only documented per-parameter.

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 three parameters and their source-resolution semantics. The description's mention of '3MF template or JSON/config profile' loosely maps to source_path and template_name but adds no format or precedence detail beyond the schema; 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 (inspect), a specific resource (slicer settings), and enumerates the source formats and the fields covered. The phrase 'without slicing' implicitly separates it from the sibling slicing tools (slice_stl, slice_with_template), though it never names them, so sibling differentiation is present but not 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 phrase 'without slicing' hints at the use case (read settings before committing to a slice), but there is no explicit when-to-use statement, no when-not-to-use, and no named alternative. Usage must be inferred from the contrast with the slicing siblings.

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

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

No annotations are provided, so the description carries the full burden. 'Detailed information' is undefined — it does not say whether this returns geometry stats, dimensions, triangle counts, or file metadata, nor whether it is a pure read with no side effects. The safety/behavior profile is left entirely 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 short sentence with zero padding, front-loaded with the verb. It is efficient, though its brevity is partly the cause of the gaps elsewhere rather than true economy of expression.

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 one fully-documented parameter and no output schema, the description is minimally adequate, but 'detailed information' gives the agent no expectation of the return payload for a tool whose entire value is the response shape. It should at least hint at what fields come back.

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% (the single stl_path parameter is documented as 'Path to the STL file'), so the schema does the heavy lifting. The description adds no format, path-style, or validation detail beyond that, which is the baseline-3 case.

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 ('Get') and resource ('STL file') with the qualifier 'detailed information', so the agent knows this is a metadata/inspection read. However, it does not distinguish itself from neighbors like generate_stl_visualization or slice_stl, which also consume an STL file.

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 statement of when to use this versus the many other STL-related siblings, nor any prerequisites (e.g., that the file must exist on the server). The agent must infer usage from the name alone.

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

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

With no annotations, the description carries the full burden, and it does disclose one genuine behavioral trait: 'attempt' signals this is best-effort and may not succeed. However, it says nothing about whether the STL is modified in place or a new file/geometry is returned, nor about failure behavior, which are the key traits for a mutation-style 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?

One front-loaded sentence that states the action and the target geometry with no filler. 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?

For a one-parameter geometry operation with no output schema and no annotations, the description explains the transformation adequately but leaves the agent unsure about persistence (in-place vs. return value) and failure modes, which matter for calling it correctly in a pipeline with slice_stl/print steps.

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% for the single stl_path parameter, so the schema already documents it fully. The description adds only the geometric goal, not any additional parameter 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 gives a specific verb (rotate) plus the exact geometric outcome (largest flat face onto the XY plane at Z=0), which clearly separates it from the generic rotate_stl sibling even though it does not name that sibling. The only gap is the lack of an explicit contrast with rotate_stl/translate_stl/center_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?

There is no guidance on when to prefer this over rotate_stl or center_model, no stated prerequisites (e.g., mesh must be watertight or have a detectable flat face), and no note about what happens if no flat face exists. The agent must infer usage entirely.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a safe read operation by using 'List,' but does not state authentication requirements, pagination behavior, output format, or any side effects. This is a notable gap for a printer-integration tool with six connection parameters.

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 zero wasted words. It is appropriately sized for the stated purpose.

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

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

For a listing tool with six optional connection parameters and no output schema, the description should explain what is returned or how the file list is structured. It also omits any mention of default environment configuration or authentication. The schema covers inputs, but the description is incomplete about behavior and 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%, so every parameter is already documented in the input schema. The description adds no parameter meaning beyond what the schema provides, 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?

The description states a clear verb and resource: 'List files available on the 3D printer.' It distinguishes the operation from other printer actions, but does not differentiate itself from siblings such as get_printer_status or upload_gcode beyond the obvious file-listing 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?

There is no explicit when-to-use guidance, no mention of prerequisites, and no named alternatives. The phrase 'files available' implies a listing context, but the agent must infer when this tool is appropriate versus other printer-related siblings.

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

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

With no annotations, the description carries the full behavioral burden. It discloses the source location and which file extensions are enumerated, which is useful, but says nothing about the return shape (names vs. paths), recursion, ordering, or behavior when the directory is absent.

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 verb and resource, with the parenthetical file types and the directory scope following. Nothing 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?

For a simple, zero-required-parameter read tool, the description covers what is listed and where. Since there is no output schema, a brief note on the return format would have closed the last gap, but nothing essential 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 single parameter has 100% schema description coverage, including its default resolution order (BAMBU_TEMPLATE_DIR, then ~/Sync/bambu/templates), so the schema already does the heavy lifting. The description's mention of the "local template registry directory" lightly reinforces that, but adds 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?

Clear specific verb (List) plus resource (saved slicing templates), with the file types (.3mf, .json, .config) and the scope (local template registry directory) spelled out. It is readily distinguishable from the write-oriented siblings save_template and slice_with_template, though it does not name them 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 by the name and by the presence of save_template/slice_with_template as siblings, but the description states no when-to-use condition, no prerequisite (e.g. registry directory must exist), and no alternative to prefer. Adequate but leaves selection to inference.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies mutation but never states that the file is modified in place, whether the original is preserved, what happens on failure, or how vertices are matched; only the tolerance semantics are conveyed.

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, target, and merge criterion are all stated up front.

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 two-parameter tool with a fully documented schema and no output schema, the description is close to sufficient. However, as an unannotated mutation tool it should disclose that it rewrites the STL in place and any file-state assumptions, which it does not.

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 (stl_path, tolerance) are already documented with units and default. The description's mention of 'closer than the specified tolerance' reinforces the filtering semantics but adds nothing beyond the schema's baseline.

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 (merge) and resource (vertices in an STL file) with the qualifying condition (closer than the specified tolerance), which is enough to distinguish it from siblings like scale_stl or rotate_stl. It stops short of explicitly contrasting with any sibling, so a 4 rather than 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?

There is no guidance on when to reach for this tool versus alternatives such as modify_stl_section or the blender_mcp_* editing tools, nor any mention of prerequisites like an existing valid STL file. The purpose is implied but selection context is absent.

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

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

With no annotations, the description carries the full behavioral burden, but it only implies a write operation via 'Apply'. It does not say whether the file is modified in place, whether the original is overwritten, what happens to geometry outside the section, what units or coordinate system apply, or how errors are handled.

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 wasted words. It communicates the core action immediately and does not bury the purpose in extra text.

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 12 parameters, two enums, no annotations, and no output schema, the description is incomplete. It does not explain how to interpret the transformation values, when custom bounds apply, file-side effects, or expected outcomes, leaving the agent heavily dependent on the schema and trial-and-error.

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%, and the schema documents all parameters including enums for section and transformation_type, axis values, and custom bounds. The description adds no parameter meaning beyond what the schema already provides, so a 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 states a specific verb ('Apply'), a specific resource ('STL file'), and a specific scope ('selected section'), which distinguishes it from whole-file siblings like scale_stl, rotate_stl, and translate_stl. However, it does not explicitly name those alternatives, so it falls short of the top score.

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

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

The description offers no guidance on when to use this tool versus alternatives, when to choose section-based modification versus whole-file transforms, or prerequisites such as valid STL paths or coordinate-system expectations. Usage is only implied by the phrase 'selected section'.

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

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

With no annotations, the description carries the full burden and does well: it discloses the plate inspection, a live MQTT cross-check of printer identity/state/filament, and a mandatory human confirmation step before upload and start. It omits auth requirements, error/failure handling, and whether anything is mutated irreversibly, which keeps it from a 5.

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

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

Two dense sentences with the purpose front-loaded, and no repeated or filler content. The second sentence is long but every clause (inspection targets, MQTT check, human confirmation) earns its place by conveying 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 23-parameter mutation-style tool with no annotations and no output schema, the description supplies the crucial workflow context a caller cannot infer: validation against live printer state and a human confirmation gate. The many tuning/override parameters are fully covered by 100% schema descriptions, so the remaining gap is minor.

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 23 parameters are already documented in the schema and the baseline is 3. The description adds no per-parameter meaning (e.g., override semantics or env defaults) beyond what the schema states.

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 ('Print a 3MF file on a Bambu Lab printer'), which is clearly distinct from generic siblings like upload_gcode and start_print. It does not explicitly name or contrast with the closest sibling, process_and_print_stl, so it stops 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 description sketches the internal workflow (inspect plate, check MQTT report, confirm, upload, start), which implies when the tool is appropriate. However, it never states when to choose this over process_and_print_stl or start_print, nor any exclusions or prerequisites, leaving selection to inference.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses the temperature-enforcement gate and that a mismatch refuses before upload, and 'start printing' signals a mutating, possibly irreversible action. However, it omits auth requirements, what happens on slicer failure, or the host/api_key defaulting behavior.

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

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

Two sentences, zero waste, with the core action chain front-loaded and the enforcement caveat second. 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?

For a 17-parameter mutation tool with no annotations and no output schema, the description covers the pipeline and the print gate but says nothing about return values, failure modes beyond temperature mismatch, or the relationship to the several sibling STL-modification tools. Adequate but with clear gaps.

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

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

Schema description coverage is 100%, so the 17 parameters are already documented in the schema. The description adds only the 'extend base' hint tied to extension_inches and reinforces the temperature-check semantics already in bed_temp/extruder_temp descriptions. Baseline 3 is appropriate 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?

The description names a specific multi-step operation — extend the STL base, slice, and print — and anchors it against siblings by referencing the same checked print gate used by upload_gcode/print_3mf. An agent can distinguish it from slice_stl or start_print, though the 'extend base' phrasing is terse.

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 pipeline nature implies usage (one call instead of slice_stl followed by start_print) but no explicit when/when-not guidance is given. The reference to the shared print gate hints at why this exists, but the agent must infer the alternative paths.

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

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

No annotations are provided, so the description carries the full burden. It does not disclose whether the rotation mutates the file in place or returns a new model, whether the original is preserved, or whether there are constraints on rotation values. For a mutation tool with zero annotation coverage this is a 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 efficient sentence with no wasted words, but it is arguably terse to the point of under-specification rather than optimally 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?

Parameters are fully covered by the schema and no output schema exists, so the description needn't explain returns. However, as a mutation tool with no annotations it should disclose the in-place-vs-new-model behavior, which it omits.

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 each parameter (rotate_x/y/z in degrees, stl_path) is already documented in the schema. The description adds nothing beyond that, so 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?

States a specific verb (rotate) and resource (STL model), which distinguishes it from siblings like scale_stl and translate_stl. The phrase 'around specific axes' is somewhat redundant since the schema names the axes, but the core purpose is clear.

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

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

No guidance on when to use this versus scale_stl, translate_stl, or modify_stl_section, and no prerequisites or context about the STL manipulation workflow. The agent must infer usage entirely 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?

No annotations are provided, so the description carries the full behavioral burden. 'Copy' usefully implies the source file is preserved rather than moved, but nothing is said about overwriting an existing template name, error behavior for unsupported formats, or permissions — significant gaps for a mutation tool with zero annotation coverage.

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

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

A single sentence with no filler; the action, the accepted formats, and the destination registry are all front-loaded. 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?

For a low-complexity, single-required-parameter local file operation with fully documented parameters and no output schema, the description is nearly sufficient. The only missing piece is collision/overwrite semantics for an existing template name.

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 source_path, template_dir (including the BAMBU_TEMPLATE_DIR default), and template_name (filename-derived default). The description adds no syntax or defaulting detail beyond that, 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 gives a specific verb (Copy) and a specific resource (into the local template registry) and names the accepted file types (.3mf, .json, .config). It is clearly distinct from siblings like list_templates or slice_with_template, though it does not explicitly name a sibling to contrast against.

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, no mention of prerequisites, and no reference to alternatives such as slice_with_template (which presumably consumes saved templates). The agent must infer that this is the way to persist a template before slicing.

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

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

With no annotations, the description carries the full behavioral burden and falls short: it does not say whether the STL is scaled in place or written to a new file, whether the original is destroyed, or whether scaling is reversible. For a mutation tool with zero annotation coverage this is a meaningful 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 tightly written sentence with the core operation front-loaded and no filler. 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?

Parameters are fully covered by the schema and no output schema exists, so return values need not be explained. However, for an unannotated 5-parameter mutation tool, the description should at least clarify output/destination behavior to be complete.

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

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

Schema description coverage is 100%, so the schema already documents scale_factor vs scale_x/y/z and the override behavior. The description's 'uniformly or along specific axes' adds conceptual framing but no syntax, range, or default details beyond the schema. 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 (Scale) and resource (STL model) plus the two supported modes (uniform or per-axis). It is clearly distinguishable from siblings like rotate_stl and translate_stl, which perform different transforms on the same resource.

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

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

No indication of when to use this versus rotate_stl, translate_stl, or modify_stl_section, and no prerequisites or preconditions mentioned. The uniform-vs-per-axis distinction is really parameter semantics rather than usage guidance.

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

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

With no annotations, the description carries the full burden and does substantial work: it discloses pre-connection validation, independent hardware and material ceilings, the ready-printer requirement, and a human-confirmation gate. It stops short of covering auth/permissions behavior, which would be the remaining 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?

Three tight sentences with no filler, and the most important branch (0 = off, ungated) is front-loaded ahead of the positive-target constraints. Efficient and well-ordered.

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 an 11-parameter mutation tool with no annotations and no output schema, the description conveys the key behavioral contract (validation, ceilings, confirmation) that an agent needs. It is nearly complete, missing only auth/permission expectations and explicit sibling routing.

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 the schema already documents all 11 parameters, including that 0 turns the heater off. The description adds gating semantics around temperature values but largely restates what the schema field descriptions already provide, 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?

The description states a specific verb and resource ("Set the temperature of a printer component") and even names the component concept. It is clear what the tool does, but it never names the obvious sibling (confirm_temperatures) or otherwise differentiates itself from related temperature tools.

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

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

It gives real usage conditions – temperature 0 is never gated, positive targets require a ready printer and a human confirmation – which tells the agent when a call will succeed. However, it never names alternatives such as confirm_temperatures or get_printer_status, so routing is left to inference.

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

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

With no annotations, the description carries the full burden, and it does disclose meaningful traits: the exact bambu_model/nozzle preset requirement, profile inheritance ordering, the plate-G-code requirement, and that failures surface the slicer's exit status. It omits, however, where output is written, what is returned, and the behavior of the non-Bambu slicing path.

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 purpose sentence is front-loaded and the remaining text is dense but meaningful, covering the Bambu-specific preconditions in two efficient sentences. No filler or repetition of the schema is present.

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 31-parameter tool with no annotations and no output schema, the description covers the Bambu path well but is thin on the generic path and on return/output destinations. It also never routes the agent between this and the closely related slice_with_template sibling.

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 31 parameters and the baseline is 3. The description adds the machine-preset semantics behind bambu_model/nozzle, but no per-parameter syntax beyond what the schema provides.

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

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

The first sentence states a specific verb and resource ('Slice an STL or 3MF file') and names the outputs (G-code or sliced 3MF). It does not, however, differentiate itself from the sibling slice_with_template, which an agent would need to distinguish this tool from.

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 implicitly conditions behavior on slicer type (Bambu-compatible path via bambustudio/orcaslicer-bambulab/orcaslicer+bambu_model), which is useful routing context. But it never states when to choose this tool over slice_with_template or process_and_print_stl, so alternatives are left to inference.

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

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

No annotations are provided, so the description carries the full disclosure burden. It usefully reveals that the template registry is resolved from BAMBU_TEMPLATE_DIR and that machine settings come from separate parameters, but says nothing about the output artifact, write location, or failure behavior of a slicing run.

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, front-loaded with the core action and scope, then the settings-precedence detail. No filler, no repetition of enum values or defaults already in the 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?

For a 31-parameter tool with no output schema, the description is lean but leaves gaps: it does not say what is produced (sliced 3MF vs G-code), where it is written, or how a missing/invalid template is surfaced. The rich schema compensates for most parameter ambiguity, so this is adequate but not complete.

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

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

Schema description coverage is 100%, so the parameters are already documented and the baseline is 3. The description goes slightly beyond the schema by clarifying the interaction between template_name, bambu_model, and nozzle_diameter — non-obvious precedence that the per-parameter schema text does not state jointly.

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 (Slice) plus resource (STL or 3MF) and the distinguishing mechanism (a named template from the local template registry). This separates it conceptually from the sibling slice_stl, though it never names that sibling or list_templates/save_template, so the contrast is implied 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 second sentence explains the division of labor (template supplies process settings; machine preset comes from bambu_model and nozzle_diameter), which implies when this tool is appropriate. However there is no explicit 'use this instead of slice_stl when...' guidance or note about what happens when the template name is not found.

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

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

No annotations, so the description carries the full behavioral burden, and it does meaningful work: it discloses that the server downloads and inspects the exact file, starts a uniquely named checked copy, and requires printer-state checks plus human confirmation. It omits what happens to an in-progress print and any auth/failure semantics, but the human-confirmation and refuse-behavior disclosures are well beyond structured fields.

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

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

Three sentences, front-loaded with the core action before the behavioral detail and the alternative. Dense but every clause earns its place; no 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?

For a 9-parameter mutation tool with no annotations and no output schema, the description supplies the key behavioral context (download/inspect, checked copy, human confirmation, refusal path) an agent needs. It stops short of describing failure modes or what a successful start returns, but the core is complete.

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

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

Schema description coverage is 100%, so the schema already documents all nine parameters including the material/Bambu constraints and enum. The description adds no parameter-level detail beyond what the schema provides, 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 (start printing) and resource (a G-code file already stored on the printer), and explicitly carves out the scope from siblings like upload_gcode and process_and_print_stl. An agent can tell this apart from other print tools without opening 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?

Gives explicit when-to-use and when-not: printers whose API cannot download files (Repetier, Prusa, Creality) refuse, and the description routes the agent to upload_gcode with print=true in that case. This is a named alternative with the selecting condition spelled out.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not disclose whether the STL is modified in place or a new file is written, what the tool returns, whether multiple axes can be combined, or any failure behavior — all important for a file-mutating geometry operation.

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

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

A single short sentence with no wasted words, front-loaded with the action. It is efficient, though bordering on under-specified rather than optimally concise.

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

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

With no annotations and no output schema, the description should explain mutation/return behavior and at least gesture at constraints. For a 4-parameter file-transforming tool, the one-line description leaves the agent without enough context to call it confidently.

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%, and the schema already documents each axis parameter with units (millimeters), so the baseline is 3. The description adds no additional semantics beyond the axes already captured in 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?

States a specific verb ('Move') and resource ('an STL model') with axis scope, which is clearer than a bare name restatement. However, it does not differentiate itself from near siblings like rotate_stl, scale_stl, or center_model, which also transform the model's geometry.

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, no mention of prerequisites (e.g. valid STL path, loaded model), and no reference to alternatives such as rotate_stl or scale_stl. The agent must infer usage purely from the verb.

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

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

With no annotations present, the description carries the full burden and does substantial work: it discloses that with print=true the exact bytes are inspected (S/R heater targets, tool changes, hardware and material ceilings), printer state is checked, and human confirmation is required. That is meaningful behavioral context beyond the schema. It still omits auth/credential requirements and failure behavior, keeping it short of a 5.

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

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

Two sentences, front-loaded with what is uploaded and then the conditional safety behavior. The second sentence is dense but every clause (byte inspection, state check, confirmation) earns its place by conveying risk-relevant 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 12-parameter, annotation-free tool with no output schema, the description covers the highest-risk aspect (printing after upload) thoroughly. Since no output schema exists, return values need not be described, but it could say more about the non-print upload path and credential handling to be 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?

Schema description coverage is 100%, so the schema already documents all 12 parameters in detail. The description reinforces that print=true requires a declared material from slicer metadata or the material argument, adding light emphasis but no syntax or format detail beyond the schema. 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?

States a specific verb (Upload) and resource (G-code content or local file path to the printer), covering both input modes in one sentence. This separates it from start_print (prints an existing file) and process_and_print_stl (slices then prints) without ambiguity.

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

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

The description clarifies the semantics of the print=true flag and the safety pipeline that then applies, which implicitly tells the agent when the risky path is taken. However, it never explicitly contrasts this tool with sibling alternatives like start_print or process_and_print_stl, leaving the use-this-vs-that decision to inference.

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