Kiln

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

With no annotations, the description carries the full behavioral burden and largely fails. The one genuinely useful disclosure is "Requires Kiln Pro", a prerequisite, but it says nothing about side effects, reversibility, permissions, or whether this mutates printer state.

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?

Only the first line relates to the tool's function; the remaining three lines are tier advertising and an upgrade URL. This is padded, not concise, and the promotional content crowds out actionable content.

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

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

For a 2-required-parameter tool with no annotations and no output schema, an agent needs parameter meaning and behavioral context, neither of which is present. The tier requirement is the sole complete piece of contextual information.

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

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

Schema description coverage is 0% for two required parameters (material, printer_id), so the description must compensate and does not. The parameter names are fairly self-explanatory, which keeps this above a 1, but no formats, accepted values, or ID conventions are given.

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 opening line "escalates the abrasive-filament warning by nozzle" names an action and resource, but "escalate" is semantically ambiguous — it is unclear whether this raises a severity flag, notifies someone, or blocks a print. The bulk of the description is plan-tier marketing rather than purpose, and nothing distinguishes it from siblings like nozzle_wear_status or get_material_warnings.

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 preconditions for the operation, and no routing to alternatives among the many nozzle/wear siblings. The Free/Pro+ tier sentences describe plan entitlements, not invocation 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?

No annotations are provided, so the description carries the full behavioral burden. It discloses exclusivity and that timeout_seconds is a maximum wait, but does not state what happens on timeout, how long the lock persists, whether it is reentrant, or what release behavior is 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?

The core action is front-loaded in the first sentence, followed by a brief rationale and compact Args list. Every sentence is relevant and there is 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 stateful, concurrency-sensitive tool with no annotations and no output schema, the description is only partially complete. It should explain lock failure/lifecycle behavior and explicitly point to release_printer_lock or similar cleanup.

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 67%, with printer_name undocumented in the schema; the description compensates by explaining that it is the printer to lock and clarifies holder and timeout_seconds semantics. It still lacks format details for printer_name and holder.

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: "Acquire an exclusive lock on a printer." The scope and concurrency purpose are clear and distinguish it from the complementary release_printer_lock sibling.

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?

Explains the usage context: safe concurrent access and preventing multiple agents from controlling the same printer simultaneously. It does not explicitly say when not to use it or name release_printer_lock as the required follow-up.

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

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

The description discloses the write operation to '~/.kiln/license' and the return of tier info, which are key behaviors. With no annotations provided, this adequately covers transparency, though it could mention if any authentication is needed.

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

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

The description is concise, front-loading the purpose in the first sentence, and every sentence adds value. 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?

Given the simplicity of the tool (one parameter, no output schema), the description is adequate. It covers the action, side effects, and return value. Minor room for improvement: mentioning any prerequisites or error conditions.

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 only parameter 'key' is described with format examples ('kiln_pro_...' or 'kiln_biz_...'), adding significant meaning beyond the schema's simple string type.

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

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

The description clearly states 'Activate a Kiln Pro or Business license key,' specifying the verb and resource. It distinguishes itself from the sibling tool 'license_status' by mentioning it.

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

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

Explicitly advises to 'Use license_status to check the current tier first,' providing clear context for when to use this tool versus an 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?

With no annotations, the description carries the full burden. It usefully explains that negative clearance is required for interference_fit and that unknown magnet polarity blocks downstream shipping instructions, but it does not describe mutation side effects, required permissions, idempotency, or what the call returns.

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

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

The description is structured and front-loaded: purpose first, then a well-organized Args section. It is somewhat verbose and includes informal phrasing, but nearly every sentence adds practical information for correct invocation.

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 mutation tool with no annotations and no output schema, the parameter semantics are strong, but the description omits return behavior and mutation effects. An agent still lacks clarity on whether assembly_json is updated in place, whether the tool returns a new assembly state, and how errors are surfaced.

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 only 29%, but the description compensates thoroughly. It documents defaults for joint_type and clearance_mm, explains the non-obvious negative-value rule for interference fits, clarifies when magnet_polarity_aligned is meaningful, and lists supported fastener keys.

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: add a mating interface between two parts in an assembly, including joint type and clearance. It is clearly distinct from generic part-addition siblings, but it does not explicitly name alternatives such as add_pin_joints or get_joint_recommendation.

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 explains that the interface is used during validation and clearance checking and that fastener data helps downstream manuals and BOM tools. However, it does not state when to use this tool versus sibling tools like add_pin_joints, recommend_joint_strategy, or add_assembly_part, nor does it give exclusions.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that the tool parses assembly JSON, appends the part, and returns the updated assembly state, but it does not cover permissions, validation failures, duplicate part_id behavior, or whether the operation writes to disk.

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 main operation is front-loaded in the first sentence, followed by a compact behavioral summary. The Args block is slightly repetitive but earns its place by documenting parameter meaning and defaults.

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

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

For a mutation tool with no annotations and no output schema, the definition covers the core input semantics and notes that updated assembly state is returned. It remains incomplete on error behavior, validation rules, and the shape of the returned state.

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 only 63%, but the description compensates by explaining all eight parameters, including units for positions, default values, accepted mesh file types, the source of assembly_json, and that part_id must be unique within the assembly.

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 clear verb and resource: 'Add a part to an existing assembly.' The phrase 'existing assembly' distinguishes it from create_assembly, but it does not explicitly differentiate it from siblings like add_assembly_interface or compose_assembly_parts.

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 implies that the tool is for adding a part to an existing assembly, but it gives no explicit when-to-use guidance, prerequisites, or alternatives. It never says when to choose this over create_assembly or other assembly-composition tools.

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

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

With no annotations, the description carries the full burden. It does disclose that a UI stage opens and that oversized meshes are decimated, but for a tool that alters G-code mid-print it says nothing about whether the printer is commanded, whether output writes to disk (output_dir), whether the original file is preserved, or what happens on failure. The marketing sentence about Free-vs-Pro features adds no behavioral information.

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 useful content (one sentence of purpose) is buried under a subscription upsell with a pricing URL and a duplicated INLINE 3D STAGE section that repeats what the first paragraph already said about the stage and browser link. Roughly half the text earns no place in a tool definition and dilutes the front-loaded signal.

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 22-parameter, no-annotation, no-output-schema tool that mutates a live print, the description leaves far too much unsaid: no return value description, no error or failure behavior, no explanation of the AMS/filament matching parameters, and no statement of what the print does while the slice runs. It is complete only about licensing and the UI stage.

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?

Twenty-two parameters with only 73% schema coverage, and most of that coverage is placeholder text like 'Default: 65.' or 'Default: ""'. Required parameters feature, gcode_path, current_layer, plus placement, printer_bed_size, source_3mf_path, target_ams_slot and require_ams_match are undocumented in both schema and description. The description mentions 'pause_z' but not that this maps to the optional pause_z_mm parameter, and adds no field semantics anywhere.

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 opening line names a specific action and target: slice a new mesh at a Z pause and resume the print. It does not distinguish it from the closely named sibling add_feature_during_print_fleet, nor from decorate_during_print or deboss_during_print, so an agent must infer which mid-print mutation applies. The parenthetical '(Pro)' is the only disambiguating signal.

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 only stated precondition is licensing ('Requires Kiln Pro'), which does function as a usage gate but is a commercial one, not a task one. Nothing says when to choose this over the fleet variant or over splice_mesh_at_z, and nothing states the obvious prerequisite that a print must already be in progress and paused. Usage is implied rather than specified.

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

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

With no annotations, the description carries the full burden. It discloses the Business tier requirement and the important precondition that printers are paused, but it omits mutation side effects, reversibility, per-printer failure behavior, and what happens after the feature is added.

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 key operation and scope are front-loaded in the first sentence. The remaining lines are short, though the pricing/upgrade line is somewhat promotional rather than operational.

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

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

This is a multi-printer mutation with no annotations and no output schema. The description gives tier and state preconditions, but it lacks enough detail about effects, failure handling, and results for an agent to invoke 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 coverage is 75%, so the schema already documents most parameters. The description adds limited semantic value by clarifying that the feature is shared across printers and that printers are paused, but it does not explain the optional parameters.

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: adding the same feature to N paused printers, with a concrete example. The fleet scope distinguishes it from single-printer siblings, though it does not explicitly name add_feature_during_print 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?

Provides useful prerequisites: Business+ and paused printers. However, it does not explicitly say when to choose this over add_feature_during_print or decorate_during_print_fleet, nor does it describe when not to use it.

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

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

With no annotations at all, the description must carry the full burden. It discloses the rule model (trigger/action/priority/message semantics) but not whether rule creation affects an in-flight print, whether rules persist across sessions, whether validation errors are returned, or that it is a mutating operation. Useful but incomplete for an unannotated 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?

The one-line purpose is front-loaded, and the argument list is dense with no filler. It retains raw docstring 'Args:' formatting, which is functional but less scannable than prose or a table.

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. However, for an 11-parameter rule-creation tool with no annotations, the description leaves out prerequisites (interception active, session validity) and the blast radius of a rule that can block or pause printing.

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 only 18% and zero parameters carry enums, so the description carries the load: it enumerates the valid trigger types, action types and priority levels, and ties conditional params to their triggers (blocked_commands for command_blocked, pattern for pattern_match, threshold_max for range triggers). It omits required-vs-optional marking and the interaction between threshold and threshold_max.

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 line states a specific verb and resource: 'Add a custom interception rule to an active session.' That clearly separates it from remove_interception_rule or list_interception_sessions. It stops short of naming the related lifecycle siblings (start_gcode_interception, load_safety_interception_rules) that an agent must consider first.

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 only contextual clue is the phrase 'active session', implying a session must exist, but there is no statement about whether gcode interception must be running, whether this is safe mid-print, or when to prefer load_safety_interception_rules. No when-not conditions or alternatives 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?

With no annotations at all, the description carries the whole burden and does so well: it discloses that output is written to an .stl with the CAD beside it, that refusals explain why, that plan_only builds nothing, and that an inline 3D stage opens with automatic decimation for oversized meshes. The remaining gap is that it never states whether the source file is left untouched versus overwritten, though the defaults imply new files.

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?

Front-loaded with the core action, then edge-case semantics, then the display contract, then params and returns — a sensible ordering. Some sentences repeat themselves ('same CAD route, same edge selection, same reply' and the later restatement of literal bevel behavior) and could be tightened without losing 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 10-parameter mutation tool with no annotations and no output schema, the description covers the gap: it enumerates the return keys (path, step_path, edges with finished/left-sharp/cautions, sized_for, volume_mm3, before/after measurements), describes refusals, and sets the agent-display expectation. Nothing needed to call 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 coverage is 70%, and the description adds real meaning beyond it: distance_mm is measured along each face from the edge, angle_threshold_deg defines when an edge counts as sharp, edges defers to add_mesh_fillet for selection syntax, and plan_only is explained behaviorally rather than just as a boolean. Empty-defaulted string params like material and printer_id get only one-line glosses, which is the main shortfall.

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+scope: bevel a part's edges, exactly, on its CAD file. It then distinguishes itself from its nearest sibling by naming add_mesh_fillet and characterizing the difference (flat-faced twin, same CAD route and edge selection). An agent can pick between the two without opening either 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 'flat-faced twin of add_mesh_fillet' framing plus the plan_only flag gives clear conditions for use and for dry-running first. Refusal cases (no CAD file behind the mesh, OpenSCAD-script parts) route the agent elsewhere. It stops short of an explicit 'use chamfer when X, fillet when Y' rule, so it is clear context rather than full exclusions.

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

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

With no annotations, the description carries the full burden, and it discloses only one behavioral fact: a Kiln Pro entitlement requirement, stated vaguely enough ("Everything in Free, plus...") to be ambiguous about whether this tool is gated. It says nothing about mutation effects, whether the comment is append-only, whether the target version must be locked or in a particular state, or what happens on failure.

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

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

The useful content is one sentence; the remaining three lines are subscription upsell copy with a marketing URL that does not help an agent invoke the tool. The front-loading is good but roughly three-quarters of the text is waste.

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

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

A six-parameter mutation tool with no annotations and no output schema needs the description to explain parameter intent, entitlement gating and success behavior. Almost all of that is missing, and the paywall text is too imprecise to tell an agent whether the call will be rejected on a free tier.

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 33% and only schema defaults for scope and anchor are documented; body, author, artifact_type and artifact_version_id have no descriptions anywhere. The description nods at two of these ("region-anchored" hints at anchor, "versioned artifact" hints at artifact_version_id) but adds no format, valid value, or default semantics to compensate for the gap.

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 opening sentence gives a specific verb and resource ("Add a region-anchored comment to a versioned artifact"), which is materially clearer than the bare tool name. However, it never distinguishes itself from the nearby comment siblings (list_mesh_comments, reply_to_comment, resolve_comment_thread, get_comment_thread), so an agent cannot tell from the text which of these to pick.

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 reply_to_comment or resolve_comment_thread, and no prerequisites such as needing an existing artifact version or thread. The only conditional language present is a paywall notice, which is not invocation 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 so: it discloses silent radius reduction on narrow faces, sharp-hole-rim defaults, a refusal for CAD-less meshes (with the reason), OpenSCAD-script refusal, the `left_sharp`/`cautions` reply fields, and automatic stage decimation. It also states a display contract telling the agent to read the before|after self-check before declaring the job done.

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?

Front-loaded with purpose, then exceptions, then parameters — a sensible order, and every paragraph carries information. It is long and occasionally convoluted ('an open surface and a bigger part on every part measured'), and the capitalization-heavy AGENT DISPLAY CONTRACT / INLINE 3D STAGE blocks add visual weight without much new semantic content.

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

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

Ten parameters, no annotations, and no output schema — yet the description covers the return shape (`path`, `step_path`, `edges`, `sized_for`, `volume_mm3`, before/after measurements), the failure mode, and the post-call verification obligation. Nothing material for a correct invocation 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 coverage is 70% and the schema descriptions are mostly bare defaults, so the prose is doing real work: it defines how `edges` is expressed (positional words, inside/outside, `holes`, or ids from `plan_only`), explains what `angle_threshold_deg` measures, and clarifies `output_path` writes the CAD alongside. It stops short of units/format constraints for a few parameters like `material` and `printer_id`.

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?

Opens with a specific verb+resource+scope: 'Round a part's edges, exactly, on its CAD file.' It also names the output artifacts (mesh `path` and CAD `step_path`), which pins down what the tool actually produces versus a pure mesh operation.

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 concrete entry conditions: pass a STEP file or a Kiln-converted mesh that still sits beside it, and use `plan_only` to get edge ids before building. It doesn't explicitly contrast with the sibling `add_mesh_chamfer` or say when a chamfer is preferable, so routing to the right edge treatment is left partly 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 real behavior: the tool opens an interactive 3D stage on success, attaches a browser stage link in some hosts, and auto-decimates oversized meshes for the stage. The tier note ('Requires Kiln Pro') hints at an authorization gate. What is missing is equally important for a geometry mutation tool: whether input meshes are modified in place or new files are written, and what happens on failure.

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

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

The purpose is correctly front-loaded, but the definition is then padded with a pricing pitch and upgrade URL that carry no tool-selection value. The inline-stage behavior is stated twice — once in the lead sentence and again in a dedicated all-caps paragraph — so the description spends its length on repetition and marketing rather than on the nine parameters.

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?

There is no output schema and no annotations, so the description must cover both semantics and return behavior. It does partially cover results by describing the interactive stage and the PNG preview fallback, which is helpful. It remains incomplete for a nine-parameter mutation tool: nothing about output file locations, whether existing geometry is altered, or error conditions.

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 78% across nine parameters, so the schema already documents defaults for scale, material, clearance_mm, pin_diameter_mm, application_class, design_id, and output_dir. The description adds no parameter-level meaning at all — notably nothing about how clearance_mm interacts with pin_diameter_mm or what application_class controls, which is exactly the kind of guidance a pin-joint tool needs. Baseline 3 is appropriate given the high schema coverage.

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

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

The opening sentence names a concrete verb and resource: give two touching parts a pin-and-socket joint. That is far more specific than the name alone, and the requirement that parts be touching is a useful scoping fact. It does not, however, distinguish this from adjacent siblings such as get_joint_recommendation, recommend_joint_strategy, or add_assembly_interface, so an agent must infer when to create joints versus request a recommendation.

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 only usage condition offered is 'two touching parts,' which is a geometric precondition rather than guidance on when to select this tool. There is no mention of when not to use it, no named alternative from the many joint/assembly siblings, and no prerequisite steps such as having both parts loaded or validated.

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 entitlement gate and that an interactive 3D stage opens (with automatic decimation for oversized meshes), which is useful, but it never states whether the source STL is modified in place or a new artifact is produced, nor what the output looks like. The core mutation semantics of a write tool are left unaddressed.

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 is reasonably front-loaded, but the entry is bloated by a large all-caps "INLINE 3D STAGE" paragraph, a marketing upgrade URL, and the Business requirement stated twice. The stage behavior is explained redundantly in both the opening and the dedicated section, so several sentences do not earn their 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 7-parameter write tool with no annotations and no output schema, the description is incomplete: it omits parameter meaning, the mutation/destructive profile, and return behavior. The space it does use is spent on promotional content and repeated stage messaging rather than the operational detail an agent needs 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?

Seven parameters with only 57% schema coverage, and the description mentions none of them explicitly. The phrase "scannable at print size" loosely gestures at size/placement/QR content but provides no syntax, defaults, or meaning for product_stl_path, qr_content, placement, nozzle_mm, or pad_height_mm. It fails to compensate for the coverage gap.

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 ("Add a scannable QR code to any product STL") and ties it to the Business tier, so the core action is unambiguous. It does not, however, distinguish itself from sibling tools like generate_qr_decoration or the other QR/decorate tools, leaving the agent to infer which QR tool applies.

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 states the entitlement prerequisite ("Requires Kiln Business") with an upgrade link, which is real usage context. But it never says when to choose this over the many alternative QR/decoration tools, and the duplicated "Requires Kiln Business" line adds no new guidance.

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

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

With no annotations provided, the description carries the full burden and does so thoroughly: it discloses local-only storage, no upload/sharing, tightening-only semantics, owner-supplied labeling, signed-in and human-confirmation requirements, and Klipper/Moonraker proposal behavior. These are behavioral details beyond what any structured field 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?

The definition is front-loaded and well organized around the primary action, wrong-tool alternative, confirmation flow, and Klipper proposal path. It is long, but the length is mostly justified by the complexity of the safety override and human-confirmation workflow.

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 no output schema and no annotations, the description gives enough context for correct invocation, including prerequisites, the code-confirmation loop, local persistence behavior, proposal/caution concepts, and fallback behavior. Nothing essential for an agent to call this safely appears 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 coverage is low at 33%, but the description compensates by documenting `printer_model` as a short identifier, `profile` as a dict with required and optional fields, and `printer_name` as only relevant when `profile` is omitted. It adds substantial meaning not present in 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 first sentence gives a specific verb and resource: adding a local safety-profile override for a printer model. It also distinguishes the tool from nearby alternatives by naming `select_printer_variant` for upgraded-hotend cases and explaining when `profile` is omitted.

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

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

The description explicitly states when to use this tool, when it is the wrong tool, and which sibling to use instead. It also documents prerequisites for unknown printers, including sign-in and the person-confirmation code flow through `give_print_code`.

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 states that a correction changes only the amount, that Kiln's automatic count-down can drift and the person's word wins, and that the spool is retained at zero grams. It stops short of stating error behavior (unknown spool_id, duplicate adds) or permission 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?

Front-loads the add-vs-correct split before the Args block, which is the right order. The Args section partly restates schema titles, but it adds real meaning (defaults, mode-required fields, examples) rather than pure duplication; total length is justified for a dual-mode tool.

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

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

Seven parameters, no annotations, no output schema — the description covers both modes and every parameter, which is the core need. It never says what comes back (e.g., the new spool_id), which matters for a create operation that an agent may need to reference later.

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 only 14% (just the weight_grams default), so the description must compensate and does: it defines all seven parameters in an Args block, marks material as required for adding, marks spool_id as the correct-mode key, and supplies material examples (PLA, PETG, ABS) that the schema's bare string type lacks.

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?

Opens with a specific verb+resource ('Add a filament spool to inventory') and immediately names the second capability ('correct how much is left on one'). The two modes are separated into labeled paragraphs, so an agent can tell exactly which operation it is invoking.

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: pass material to ADD, pass spool_id (from list_spools) with remaining_grams to CORRECT. It also names the boundary case that would otherwise confuse an agent — remaining_grams=0 keeps the spool on the list while remove_spool takes it off.

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 it does contribute one genuinely useful behavior: the organisation owner must be on Kiln Business, not the caller. Beyond that gating fact it is silent — no idempotency on re-adding, whether the invitee is notified, required caller permissions, or reversibility.

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 operative sentence is front-loaded and tight, but everything after it is promotional copy ("the whole shop works from one library") and a bare upgrade URL. Those sentences do not earn their place in a tool definition.

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?

A mutation tool with no annotations, no output schema, and 25% parameter coverage needs the description to explain prerequisites, effects, and failure modes. It covers only the plan gate, leaving success behavior, duplicate handling, and role semantics entirely unaddressed.

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 only 25% (just a default for role). The description hints that tenant_id is the added party and team_id the destination, but role and added_by are undocumented in both places, and there is no format guidance or explanation of what values tenant_id accepts.

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?

"Add *tenant_id* to *team_id*" supplies a verb and a target, but it describes the operation in raw parameter names rather than saying what a tenant actually is (a user, an org, a service account) or what membership grants. It also fails to distinguish itself from the adjacent manage_team_member and remove_team_member siblings.

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

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

There is no explicit when-to-use statement and no mention of the alternative tools (manage_team_member for role changes, list_team_members to check existing membership). The closest thing to guidance is a plan-entitlement note, which is a prerequisite rather than a routing rule.

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 reveals the core optimization objective but not whether the tool is read-only, what it returns, how failure/no-feasible-scale cases are handled, or whether it has any side effects.

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?

It is a single front-loaded sentence with zero filler, and the 'EVERY part' constraint is emphasized efficiently.

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 nontrivial five-parameter advisory computation with no annotations and no output schema, the description is too sparse. It omits return value details, feasibility semantics, parameter expectations, and any indication of what the agent should do with the result.

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

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

The description provides no parameter-level detail, and schema coverage is only 60%. The part_paths and nozzle_mm parameters are undocumented, and the description does not explain units, path format, or how bed and nozzle dimensions affect the result.

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: find the largest scale for an entire kit. The 'EVERY part of a kit' scope distinguishes it from individual-part scaling tools, though it does not explicitly name sibling 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?

It implies this is for scaling multi-part kits, but gives no explicit when-to-use guidance, prerequisites, or alternatives such as scale_mesh_to_fit or verify_mesh_fit. An agent must infer the use case from the one-line purpose.

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: it discloses silent-failure semantics (values below 45 are silently ignored by the printer), pre-flight ceiling validation (65 C / 85 C) and that nothing is sent when the check cannot run, that stops are always sent, and the return shape. These are non-obvious behaviors an agent could not infer from 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?

Front-loaded with the action and the hardware scope, then the start/stop split, then per-parameter notes. Well organized, though the START/STOP paragraph is dense and the ceiling-limit fact is repeated in both the prose and the temp_c note.

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 eight-parameter mutation tool with no annotations and no output schema, the description covers applicability, required-vs-optional inputs, validation rules, failure modes, and return value. Nothing an agent needs to invoke it correctly appears to be 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 coverage is only 13% (just duration_min), so the description must compensate, and it documents all eight parameters in prose — including the crucial numeric encoding of mode (1/0), the 0-based ams_id, per-unit temperature ceilings, and the humidity/rotate_tray hints. The two optional flags (humidity, rotate_tray) are described only vaguely ('Optional target humidity', 'Optional tray-rotation flag'), leaving their valid ranges and effects unstated.

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 pair (start/stop) and a specific resource (AMS 2 Pro / AMS HT active dry cycle), scoped to Bambu printers that own one of those units. This separates it cleanly from advisory siblings like drying_advisor and from status readers like ams_status.

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 branching: mode=1 start requires temp_c, duration_min > 0, and cooling_temp_c >= 45; mode=0 stop needs only ams_id. It also states when the tool is not applicable ('other printers and plain AMS / AMS Lite units return an error'), which is exactly the exclusion guidance an agent needs.

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 exist, so the description carries the full burden and does so: it explains field-level semantics (unit vs tray_id vs name, feeding/feeding_source), edge cases (tray_now '254'/'255', A1/AMS Lite reporting), and bitmask meaning. It also discloses that this dump has no fault line and that faults surface via printer_status or the printer_fault field on other results — non-obvious cross-tool 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?

Front-loaded with purpose, then differentiation, then use cases, then payload semantics, then fault caveat — a sensible ordering. It is long and dense, but with no output schema the field documentation is load-bearing rather than filler; a small amount of repetition around tray naming keeps it just short of a 5.

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

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

With no output schema and no annotations, the description must explain both the return payload and the safety/behavioral profile, and it does: return fields, edge cases, and fault-reporting behavior are all covered, plus where to look to monitor a print instead.

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 instead invests its detail in return-value semantics, which is appropriate given the empty input schema.

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

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

Opens with a specific verb+resource+scope: 'Full AMS hardware dump — all trays, humidity, RFID (Bambu Lab only).' It also explicitly names the two nearest siblings (get_active_material, get_material) and states how this tool differs, so an agent can distinguish it without opening schemas.

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 both routing rule ('For just the currently-active material, use get_active_material instead. For Kiln's software material tracker, use get_material.') and positive use cases ('check filament levels before printing, verify the correct material is loaded, or select the right ams_mapping for start_print()'). When-to-use, when-not, and alternatives are all explicit.

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 behavioral burden and does disclose the return contents and the internal relationship with design_session. It does not state whether the lookup is read-only/side-effect free, deterministic, or subject to rate limits, leaving a minor gap for a tool agents might call repeatedly.

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?

Front-loaded with the one-line purpose, then context, then examples, then Args — a readable structure. It is somewhat long, and the seven-item example list plus the multi-clause design_session explanation carry mild redundancy, but every section serves the router/analysis decision.

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 and no annotations exist, so the description must explain returns, which it does by enumerating the five output categories. The Args block plus examples cover both inputs. Only the absence of safety/permission context keeps it short of a 5.

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

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

Schema description coverage is 0%, so the description must document the parameters itself, and it does: requirements is explained as natural-language functional needs/environment/loads with seven concrete example strings, and material is documented as an optional override (e.g. "petg") with default-recommendation behavior.

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 ('Analyze a functional requirement and return technical recommendations') and then enumerates the exact output categories: material recommendations, design patterns, dimensional constraints, print orientation rules, and expert guidance notes. It explicitly differentiates itself from sibling tools like design_session and the user-facing flow.

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

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

Explicitly states when to use it versus the alternative: it is 'the internal-lookup tool' and a 'pre-design analysis pass, not the user-facing entry point,' directing agents to design_session(verb="start") for the user-facing goal-capture flow. Both the when and the when-not are covered.

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 mentions the Kiln Pro requirement and that the gated capability would compute a load verdict with factor of safety and derate chain, but it does not confirm actual behavior, side effects, return format, or what happens when Kiln Pro is unavailable.

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

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

The description is short and starts with the domain, but it spends substantial space on Kiln Pro promotion and an upgrade URL that do not help an agent invoke the tool. It is not bloated, but some sentences are marketing rather than operational guidance.

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 analysis tool with no output schema and no annotations, the description is far too incomplete. It states a Kiln Pro gate but does not explain inputs, outputs, or usage conditions sufficiently for an agent 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?

There are 11 parameters with only 9% schema description coverage, and the description adds no meaning for cols, rows, braces, joints, panels, members, brace_kind, bay dimensions, brief, or mode. The parameter burden is almost entirely undocumented in both the schema and the description.

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 identifies the domain as diagonals in a shelf, rack, frame, or lattice, but does not use a clear action verb for the tool itself. The sentence about what Kiln Pro 'would compute' is conditional and framed as an upsell, so an agent cannot confidently tell exactly what analyze_frame_bracing does or how it differs from sibling structural-analysis 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 lists applicable structures (shelf, rack, frame, lattice) and states 'Requires Kiln Pro', which gives a prerequisite. However, it provides no guidance on when to use this tool versus alternatives such as analyze_structural_risks, assess_load_bearing, or recommend_joint_strategy, and no when-not-to-use conditions.

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 exist, so the description carries the full burden. It does disclose the return shape ('feedback with specific constraints to add to the generation prompt'), which matters since there is no output schema. However, it says nothing about whether the analysis is read-only, whether it is slow or costly, whether it reads local vs cloud files, or what happens on invalid input.

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 two-sentence purpose and return statement are front-loaded, followed by an organized Args block. The structure is efficient, though the docstring formatting is slightly verbose for a tool description and the file_path/original_prompt entries add little.

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 8-parameter analysis tool with no annotations and no output schema, the description covers the core behavior and every parameter but omits operational details an agent needs: accepted failure_mode values, whether the file is local or remote, expected latency, and what the returned constraints look like structurally.

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 low (38%), and the description compensates by documenting all eight parameters, adding units ('degrees', 'mm'), examples for failure_mode ('adhesion', 'spaghetti'), and clarifying the conditional nature of the boolean defect flags (has_bridges, non_manifold, has_floating_parts). It still lacks enumeration of valid failure modes or guidance on which optional flags the caller must supply.

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 and resource ('Analyze a generated model') and states the outcome ('get feedback for improvement' with constraints for the generation prompt). This clearly distinguishes it from geometry-only siblings like analyze_model_geometry or diagnose_mesh, but it never explicitly names an alternative tool, which keeps it at 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?

Usage context is only implied: the failure_mode parameter hints at post-print analysis ('if the model was printed and failed'), and the return-value sentence implies a fix-then-regenerate loop. There is no explicit statement of when to call this versus improve_generation_prompt or analyze_model_geometry, and no prerequisites or exclusions.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered, but the description adds rich behavioral context well beyond them: automatic CAD conversion, that every metric is measured on Kiln's mesh copy except an added 'exact' block read from the CAD surfaces, that the two disagree slightly, and that 'exact' should be quoted to users. This is exactly the kind of subtle, non-obvious behavior structured fields cannot carry.

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?

Well front-loaded: purpose and metric list come first, then usage, then the CAD caveat, then the param/return notes. Each paragraph earns its place, though the CAD-conversion discussion is somewhat long and slightly interrupts the core usage guidance. No filler or tautology.

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?

There is no output schema, so the description must describe returns, and it does ('Dict with full mesh analysis metrics, plus exact for CAD input'). For a single-param read-only analysis tool, an agent has everything needed to decide when to call it, what formats are accepted, and what to expect 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?

With a single parameter and 0% schema description coverage, the description carries the burden and does so: file_path accepts a mesh (.stl, .obj, .glb, .3mf) or a CAD file (.step, .stp) which is converted automatically. It also documents the return shape ('Dict with full mesh analysis metrics, plus exact for CAD input'). Valid formats and conversion semantics add real value beyond the bare string 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?

Names a specific verb (analyze) and resource (mesh geometry) and enumerates exactly what is computed: volume, surface area, center of mass, overhang detection, connected components, degenerate triangles, and mesh_check_score. It explicitly disambiguates itself from analyze_printability ('It is not the printability score') and points to mesh_quality_scorecard, so an agent can distinguish it from siblings without opening a 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?

States the trigger ('Use this after generating a model to understand its geometry and identify printability issues before sending to the slicer'), the exclusion (it is not the printability grade, call analyze_printability for that), and an alternative for fuller reports (mesh_quality_scorecard). Both when-to-use and when-not-to-use are explicit.

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 exist, so the description carries the full disclosure burden and fails: it never says whether the call is read-only or mutates state, whether it writes to engine_output_dir, or what a result looks like. The only real behavioral disclosure is the entitlement requirement 'Requires Kiln Pro', which is useful but far from sufficient for a 4-param tool touching gcode and output directories.

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 one useful clause is front-loaded, but roughly two-thirds of the text is pricing copy and a marketing link rather than tool semantics. That is wasted space in a definition that needs the room for parameter and behavior disclosure.

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 four undocumented parameters, no annotations, and no output schema, the description should explain inputs, side effects and results; instead it explains none of them and substitutes a feature-tier pitch. An agent could not reliably invoke this tool from the definition alone.

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 nominally 100%, but every parameter 'description' is a placeholder like 'Default: ""' or 'Default: 0.0.', conveying no semantics. The tool description adds nothing about what session_id, carved_gcode_path, engine_output_dir, or requested_depth_mm mean or how they interact, so an agent cannot resolve them from either source.

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 phrase 'Pre-commit truth gate: which layers will actually change' gestures at a diff/preview of layer impact, but never states plainly that this analyzes mid-print edit consequences. The remainder of the description is a Pro upsell, and nothing distinguishes it from the many sibling tools about mid-print edits (add_feature_during_print, decorate_during_print, revert_mid_print_fleet).

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?

Only the word 'Pre-commit' implies timing, suggesting it should be run before committing a mid-print change. There is no explicit when-to-use statement, no prerequisite (e.g., an active print session or a carved gcode), and no naming of alternatives such as revert_mid_print_fleet or generate_recovery_gcode.

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 zero annotations, the description carries the full behavioral burden; 'detect' and 'analyzes' imply a read-only operation but this is never stated explicitly. It does disclose one useful behavioral trait — that output regions receive adaptive slicing parameters — plus the model_stats-over-model_path precedence rule, but says nothing about cost, file access requirements, auth, or whether any state is mutated.

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 statement is front-loaded in the first sentence, with region types and the Args section following in a predictable docstring structure. Every part earns its place given the empty schema, though the em-dash aside and parenthetical could be tighter.

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

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

For a tool with no annotations, no output schema, and no schema descriptions, the description should say what the analysis returns (e.g., a region map, statistics, or a modified plan). It explains the input side well but leaves the return value and the relationship to the persisted adaptive plan entirely implicit.

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

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

Schema coverage is 0%, so the description must compensate, and it largely does: model_path is documented as 'Path to an STL or 3MF file' and model_stats is documented as a pre-computed dict from slicer preview or external tools with example keys (height_mm, overhangs, bridges, thin_walls). The precedence rule ('model_stats takes precedence') adds genuine meaning beyond the schema, though the full set of valid keys remains undefined.

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 ('Detect geometric regions in a 3D model that affect slicing') and enumerates the region classes it identifies, so an agent knows exactly what analysis it performs. It does not, however, differentiate itself from plausible siblings such as analyze_mesh_geometry, segment_mesh_regions, or analyze_printability, which leaves ambiguity about which analysis call to pick.

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 description notes regions feed into 'the adaptive plan', hinting the tool precedes generate_adaptive_slicing_plan or quick_adaptive_plan, but it never names an alternative or states when NOT to use it. There is also no mention of prerequisites (e.g., whether a design must be loaded, whether the file must be uploaded first).

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

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

With no annotations provided, the description carries the full burden — and delivers exceptionally. It discloses the non-obvious STEP/STP conversion behavior, warns that the count reflects 'KILN'S TESSELLATION' not the user's file, and codifies an 'AGENT CONTRACT' requiring attribution via the subject field. The explicit note that this 'is not a finding about the user's file' is precisely the kind of behavioral nuance that prevents agent misuse.

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?

Front-loaded with a crisp purpose sentence, and each subsequent paragraph addresses a distinct concern (classification semantics, usage timing, CAD caveat, params, returns). The prose is somewhat verbose — the subject/message attribution warning is restated twice — but the repetition serves a genuine safety purpose for agent 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 single-parameter, read-only tool with no annotations and no output schema, the description covers every gap: input file types, return dict contents ('edge count breakdown, watertight status, subject, message, and (CAD only) converted_from'), and an important behavioral edge case (CAD conversion). Nothing needed for correct invocation or interpretation 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 schema's bare 'File Path' title conveys almost nothing, so the description must compensate — and does. It documents accepted formats ('.stl, .obj, .glb') and the additional STEP/STP CAD path, transforming an opaque string param into a fully specified input contract. For a single-parameter tool, this is complete coverage.

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

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

The opening sentence 'Count and classify non-manifold edges in a mesh' pairs a specific verb with a clear resource, and the three-way classification (boundary/T-junction/manifold edges) precisely specifies scope. It distinguishes itself from diagnostic siblings like repair_mesh by explicitly labeling itself 'the diagnostic version of the manifold check,' making its role unambiguous.

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

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

The description gives explicit usage timing: 'use it to understand exactly how many edges are problematic before deciding whether to repair.' It clearly positions itself within a workflow (diagnose before repair), but stops short of naming alternatives or stating explicit when-not-to-use conditions, relying on the reader to infer which sibling does the repairing.

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=true and destructive=false; the description adds substantial behavioral context beyond that: free-tier vs Kiln Pro thresholds, which checks depend on material/printer, and the session-level fastener_advice dedup behavior including reading agent_instruction. This is rich, actionable transparency.

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

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

The purpose and key guidance are front-loaded, but the description is long and includes a complex fastener_advice paragraph that is useful but verbose. Some scaffolding text could be trimmed without losing 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 9-parameter, no-output-schema tool, the description supplies enough: what is analyzed, what is returned at a high level, which parameters materially affect results, and important session-level dedup caveats. Nothing critical is missing for correct invocation.

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

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

Schema description coverage is only 33%, so the description carries the burden and does so well: it explains nozzle_diameter fallback logic (printer record → printer setting → stock → nozzle unknown → 0.4), max_overhang_angle defaults and rationale, material default, and printer_id's role. Build volumes are left to the schema but are self-explanatory.

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

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

The description clearly states it analyzes an STL/OBJ mesh for FDM printability, enumerating overhang detection, thin walls, bridging, bed adhesion, and support volume. It also describes the return (score, grade, recommendations). It does not explicitly differentiate itself from nearby siblings like check_print_readiness or validate_print_quality, 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?

It explains when to pass material and printer_id so warping/thermal/adhesion checks use real filament data (and notes free-tier safe-floor thresholds). It does not explicitly say when to use this tool versus similar readiness/quality tools, but the context for its inputs is well specified.

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 must fully disclose behavior. It explains that the tool examines job record, events, and printer state, and produces a diagnosis. However, it does not explicitly state whether it is read-only or if it modifies any state, so a 3 is appropriate.

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

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

The description is concise (5 sentences) and well-structured, with a clear purpose statement, process explanation, args section, and output description. No unnecessary information.

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

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

Given the single parameter and lack of output schema, the description adequately covers input and process, and describes the output as a structured analysis. It could be more explicit about the output format, but it is largely complete.

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

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

The description adds meaningful context to the single parameter 'job_id' by specifying its source: 'from job_history or job_status'. This goes beyond the schema's minimal definition, though the schema coverage is listed as 0%, the description effectively covers it.

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

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

The description clearly states the tool's purpose: analyze a failed print job and suggest causes/fixes. It specifies the verb (analyze) and resource (failed print job). However, it does not differentiate from sibling tools like 'detect_print_failure' or 'analyze_print_failure_smart', so a 4 is appropriate.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention when not to use it. It lacks any conditional or contextual advice, earning a 2.

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 supplied, the description carries the full burden; it does disclose that classification is heuristic (not deterministic) and explains exactly what the gated nozzle_wear_hypothesis fields mean and when they appear, which is genuinely useful. It does not say whether the tool is read-only/advisory or whether it records anything, nor what the failure classes or recovery plan look like.

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 core purpose and heuristic basis are front-loaded and waste-free, but the middle paragraph spends four sentences on the Kiln Pro upsell and the exact gated field names, which is disproportionate for a 4-parameter, zero-required analysis call.

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 and no annotations exist, so the description should convey more about the return shape (failure categories, recovery plan structure) than it does. It covers inputs and the one gated output field well but leaves the primary return value unexplained.

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 only 25% (only progress carries a 'Default: 0.0' note), so the description's Args block is doing real work by defining all four parameters, including progress units 0.0-1.0. It stops short of saying which parameters are optional or how the heuristic behaves when job_id/error_message/printer_name are null, and the schema shows zero required parameters.

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: classify a print failure and suggest recovery steps, with the heuristic basis (error messages, progress, failure history) spelled out. It does not differentiate itself from near-identical siblings such as analyze_print_failure, diagnose_print_failure_live, troubleshoot_print_issue, or plan_failure_recovery, so an agent cannot tell from the description alone which of these to call.

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, when-not-to-use, or alternative-naming guidance at all, despite several siblings that appear to overlap heavily. The only conditional language concerns the Kiln Pro gating, not tool selection.

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

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

No annotations are provided, so the description carries full burden. It explains it reads the file header (non-destructive) and lists the metadata extracted. However, it does not explicitly state that the operation is read-only or mention potential side effects.

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

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

The description is concise, well-structured with a note, and front-loaded. Every sentence adds value without waste.

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

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

The description is quite complete for a simple tool: purpose, usage context, input format, and return structure. It could mention error cases or prerequisites, but overall sufficient.

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

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

The schema has 0% coverage, but the description adds meaning by specifying the filename is as shown by 'printer_files()'. This helps the agent locate the correct 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?

The description clearly states the tool analyzes a G-code file and extracts metadata. It specifies the verb 'analyze' and resource 'G-code file', and distinguishes from siblings like 'printer_files' and 'list_plate_objects'.

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

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

The description explicitly says when to use: 'when filenames are meaningless' and recommends an alternative tool ('list_plate_objects') for multi-object files. This provides clear 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?

No annotations are provided. The description describes the analysis but does not explicitly state that it is read-only or non-destructive. For a tool with no annotations, the burden is on the description to disclose behavioral traits; it partially meets this by describing the checks but omits safety information.

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

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

The description is concise: two sentences plus an args line. It front-loads the action and contains no unnecessary words.

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

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

Given the tool's simplicity (1 param, no output schema, no annotations), the description covers the purpose and checks but lacks specification of return value (e.g., score, boolean) and error cases. Moderate completeness for a simple tool.

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

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

The single parameter file_path is described as 'Path to the snapshot image file,' providing context beyond the schema's type string. With 0% schema description coverage, this compensation is adequate but not exceptional.

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

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

The description clearly states the tool analyzes a webcam snapshot for print monitoring quality, listing specific checks (brightness, variance, resolution, format) and the output determination (usability). It distinguishes itself from sibling tools like analyze_print_file by focusing on snapshots.

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

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

The description implies usage for webcam snapshots but does not explicitly state when to use this tool vs alternatives (e.g., analyze_print_failure). No exclusions or prerequisites are mentioned.

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 bears full burden. It discloses that the tool 'parses parameters, modules, and library imports' to understand architecture, implying a read-only analysis. However, it does not explicitly state that it is non-destructive or mention any limitations or side effects.

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

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

The description is concise and front-loaded with the core purpose. The inclusion of an 'Args' section with parameter description is useful, though slightly redundant with the schema. Every sentence contributes valuable information with minimal fluff.

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 that there is no output schema, the description should specify the return format or structure to inform the agent's next steps. It mentions understanding architecture but does not describe the output (e.g., list of modules, parameters, imports). This leaves the agent without sufficient guidance on how to use the result.

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

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

The input schema has 0% description coverage, but the description adds crucial meaning by stating 'OpenSCAD source code' for the 'scad_code' parameter. This clarifies what the string should contain beyond the bare type, though further detail like encoding or size limits is absent.

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

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

The description clearly states 'Analyze the structure of OpenSCAD code' with a specific verb and resource. It details what is parsed (parameters, modules, library imports) to understand architecture, distinguishing it from sibling tools like 'compile_scad' or 'modify_scad_module'.

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

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

Explicitly advises 'Use this before modifying code to know what modules exist and what each one does,' providing clear when-to-use context. It implicitly positions itself as a prerequisite for modification tools, though it does not mention when not to use it or list alternatives.

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 exact risk taxonomy detected, that locations are returned as (x, y, z) coordinates in mm, and the overall return shape. It does not mention cost/runtime, input file limits, or whether the analysis is read-only – modest gaps for a non-mutating analysis 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?

Front-loaded with the purpose, then a scannable bullet list of risk types, then return semantics and params. Slightly long (the risk list repeats the enum-like categories), but every line adds information an agent needs to interpret the output.

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 or annotations exist, so the description must cover everything; it does explain the return dict structure (risks list with location, severity, description) and documents all three parameters. Missing only operational details such as expected file format constraints, runtime, or how severity should be acted upon.

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 67%, and the description supplies the missing meaning: 'Minimum safe cross-section area (default 4)' and 'Angle for sharp edge detection (default 60)' explain what each threshold controls, beyond the schema's bare 'Default: 4.0.' wording. It does not clarify acceptable ranges or units interaction for these thresholds.

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 ('Analyze an STL mesh for structural weak points') and immediately enumerates the six risk classes it detects. It also explicitly distinguishes itself from printability analysis ('Goes beyond printability'), which cleanly separates it from siblings like analyze_printability and analyze_mesh_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?

The phrase 'Goes beyond printability to find structural risks' implicitly tells the agent when to prefer this tool over printability checks. However, it never names a specific sibling alternative or states exclusions (e.g., that it requires an STL and won't work on SCAD or 3MF), so routing is left partly 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 mostly meets it: it discloses exactly what is inspected, the cross-reference against material thermal properties, and the full shape of the result including risk_level values and score_deduction. It stops short of stating that the call is purely read-only and side-effect free, or any cost/latency characteristics.

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 opening sentence is front-loaded and the sections are cleanly separated into behavior, return fields, args, and examples. The seven-field return list is long but earns its place given there is no output schema; the two examples are short and illustrative rather than padded.

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 annotations and no output schema, so the description must cover inputs and outputs alone, and it does: accepted formats, default material, optional printer influence, and a field-by-field account of the return value including bounded risk_level values. An agent can call this correctly without opening anything else.

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 only 67% and the schema descriptions are bare defaults, so the description does the real work: it lists the accepted file formats (STL, OBJ, GLB, 3MF), gives material ID examples and what the value is used for, and explains that printer_id must be a registered printer whose real geometry and calibration feed the analysis. That meaning exists nowhere in 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?

States a specific verb and resource ("Analyze warping risk for a 3D model") and names the basis of the analysis (geometry plus material). It is cleanly separable from siblings like analyze_printability, analyze_structural_risks, and analyze_model_geometry because the scope is warping-specific.

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 context is implied by the enumerated risk factors (flat surfaces, tall/narrow geometry, sharp base corners) and by the note that it shares its adhesion output with analyze_printability. However, it never says when to prefer this over analyze_printability or analyze_structural_risks, and gives no exclusions or prerequisite conditions beyond the optional printer_id.

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 discloses that Kiln Pro is required, which is useful, but it does not say whether setting an annotation overwrites an existing one, what permissions are needed, or what the tool returns.

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 first sentence is concise and front-loaded, but the remaining text is promotional material about Kiln Pro and pricing rather than tool guidance. Those sentences dilute the definition and do not help an agent invoke the tool correctly.

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

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

For a mutation tool with no annotations, no output schema, and 0% parameter description coverage, the definition is incomplete. The purpose is clear, but key details about overwrite behavior, prerequisites, branch ID format, and annotation constraints are 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 0%, so the description should compensate for both undocumented parameters. It implies that annotation corresponds to the purpose string and branch_id identifies the preset branch, but it does not specify ID format, length limits, or formatting expectations for either parameter.

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

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

The description clearly states a specific verb and resource: setting the human-readable purpose string for a decoration preset branch. It is understandable without opening the schema, though it does not explicitly distinguish itself from sibling annotation tools such as annotate_design_branch or annotate_feature_branch.

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 explains what the tool does but gives no guidance on when to use it versus alternatives, nor any preconditions for use. The only contextual note is the Kiln Pro requirement, which is unrelated to choosing this tool over its 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. It does disclose one genuinely useful behavioral fact — the Kiln Pro entitlement requirement — but says nothing about whether the annotation overwrites an existing one, who may set it, or what happens on failure. The remainder is promotional copy rather than behavioral disclosure.

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 first sentence is tight and front-loaded, which is correct. The two following sentences are subscription marketing and an upsell URL that consume most of the description's length without helping an agent invoke the tool.

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

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

For a two-parameter mutation with no annotations, no output schema, and 0% schema description coverage, the definition should cover permissions, overwrite behavior, and branch scoping. It covers none of these, and the space is spent on pricing copy instead.

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

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

Schema description coverage is 0% for two required parameters, so the description must compensate and largely does not. 'Human-readable purpose string' loosely clarifies the annotation parameter, but branch_id is never explained (which branch namespace? ID format? design vs feature branch?) and the schema offers only bare titles.

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 opening sentence gives a specific verb and resource: setting a human-readable purpose string on a branch. However, it never distinguishes 'branch' from the sibling tools annotate_feature_branch and annotate_decoration_preset_branch, so an agent cannot tell which branch type this applies to without inspecting the name.

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 tool, no prerequisites beyond a paywall note, and no mention of the near-identical annotation tools for feature and decoration-preset branches. The agent is left to infer routing entirely from 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 behavioral burden. It discloses only that Kiln Pro is required, but says nothing about whether setting the annotation overwrites an existing one, what permissions are needed, whether the operation is reversible, or what the response looks like.

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 first sentence is concise and front-loaded. The remaining sentences are an unrelated marketing upsell listing calibration, mid-print edits, and textures, none of which help an agent invoke this tool.

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

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

For a simple two-parameter tool with no annotations or output schema, the description supplies the basic purpose and a licensing prerequisite, but omits branch-type scope, parameter constraints, and mutation semantics. The promotional text competes with the operational information instead of completing it.

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

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

Schema coverage is 0%, so the description must compensate. It loosely maps annotation to a 'human-readable purpose string' and branch_id to a 'branch,' but provides no branch ID format, annotation length or character constraints, or validation rules.

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: setting a human-readable purpose string on a branch. It is clear what the tool does, but it does not distinguish this from sibling annotation tools such as annotate_design_branch or annotate_decoration_preset_branch.

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 guidance on when to use this tool versus alternatives, nor any conditions beyond the Kiln Pro requirement. It does not explain which branch types are valid or when annotation is appropriate.

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

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

No annotations are provided, so the description carries full burden. It states the function but does not disclose consequences (e.g., mutability, reversibility, or error handling). The tool modifies a print record, but safety or side effects are unaddressed.

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 extremely concise: a single sentence for the main action, followed by a brief parameter list. No redundant information; every sentence adds value.

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

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

For a simple tool with two required parameters, the description covers the core function and parameter meaning. However, it omits behavior for edge cases (e.g., appending vs. overwriting notes, handling nonexistent print IDs) and does not describe the return value.

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

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

The description includes an 'Args:' section that explains each parameter beyond the bare schema (e.g., 'job_id: The job ID of the print to annotate,' 'notes: The annotation text to attach'). Since the input schema lacks property descriptions, this adds meaningful context.

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

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

The description clearly states the tool's action ('add notes to a completed print record') and gives examples ('quality observations, issues'). The verb 'annotate' is specific, distinguishing it from recording other outcomes. However, it doesn't explicitly differentiate from siblings like 'record_print_outcome' which may also accept notes.

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

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

The description implies usage for completed prints but provides no guidance on when to use this tool versus alternatives (e.g., 'record_print_outcome' for structured data). No exclusions or prerequisites are mentioned.

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 present, so the description carries the full behavioral burden. It discloses that Kiln Pro is required, which is useful entitlement context, but says nothing about answer quality, limitations, or output behavior, and much of the text is unrelated subscription marketing.

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?

Only the first sentence serves the tool invocation. The remaining sentences are an upsell for Kiln Pro features that are unrelated to answering a material question, making the description noisy and poorly front-loaded.

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 two-parameter tool with no annotations and no output schema, the description is too thin. It omits what kind of engineering answer to expect, constraints on question scope, and any meaningful input semantics.

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

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

Schema coverage is 0% and both parameters are undocumented in the schema. The description implies that 'material' and 'question' are inputs, but it adds no format, scope, or example details beyond the parameter names.

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

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

The first sentence states a specific verb and resource: answer one engineering question about one material. It is clear what the tool does, but it does not distinguish itself from nearby material-related siblings such as get_material_properties or recommend_material.

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

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

The description gives a constraint of 'one specific question about one material' but does not explain when to use this instead of alternatives. There are many material and engineering-advice siblings, and no routing guidance is provided.

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

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

No annotations are provided, so the description carries the full behavioral burden. It gives only the question scope and domains; it does not state whether this is read-only, what data source it uses, whether authentication or printer access is required, how uncertainty is handled, or what the answer format is.

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?

It is a single front-loaded sentence with no wasted words. The examples are compact and directly clarify the intended question types.

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 Q&A tool, the description is enough to identify the basic call pattern and question domains. With no annotations and no output schema, however, it leaves gaps around return format, limitations, and how this differs from alternative diagnostic or material-question 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 0%, so the description must compensate. It implies that printer_id selects one printer and that question should be a single question in the listed domains, but it does not specify printer_id format or question constraints.

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: answer one question about one printer. It also names useful question domains (hardware facts, thermal-runaway protection, screw locations), but it does not explicitly distinguish this from nearby siblings such as answer_material_question or troubleshoot_printer.

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 examples imply the kinds of questions this tool is for, and the one-question/one-printer scope is clear. However, there is no explicit when-to-use guidance versus alternatives, and no stated exclusions or prerequisites.

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, yet it only hints at consequences via 'soft defaults' without explaining what that means (overridable? per-printer scope? does it alter future slicing?), what happens when Kiln Pro is absent, or whether the change is reversible. Two of four sentences are promotional copy rather than behavior.

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

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

The operative sentence is front-loaded and useful, but the remaining text is an upsell pitch and a purchase URL that do nothing to help an agent decide or invoke the tool correctly.

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 eight-parameter mutation with a nested object, no annotations, and no output schema needs more than this: nothing is said about the effect on the stored profile, error behavior without a Pro license, or the existence of revert_calibration_recommendations as the undo path.

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 88%, so the schema documents the eight parameters (including defaults for source, noise_floor_mm, clarification_threshold). The description adds no additional meaning about how these values map to the persisted profile, 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 first sentence names a specific verb+resource: persist calibration tuning overrides as soft defaults. That is concrete and distinct from siblings like revert_calibration_recommendations or assess_calibration_status, though it never explicitly contrasts itself with them.

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 (apply the recommendations produced by calibration analysis) plus a hard gating condition, 'Requires Kiln Pro.' No explicit when/when-not guidance or reference to the sibling that reverts these overrides.

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 discloses that depth, mode, and image style are auto-resolved from the recipe, that oversized meshes are auto-decimated, and that an interactive 3D stage is opened on success. It omits permission/auth requirements and error behavior, but the automatic side effects are genuinely useful context.

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

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

Front-loaded with the core action, but the second sentence restates the first, and the 'This is the magic tool' pitch is redundant marketing that repeats the one-call replay idea. The stage paragraph is useful but long, so several sentences do not fully earn their 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 no annotations and no output schema, the description must carry everything. It covers action, auto-resolved settings, side effects, and a brief returns summary, but omits the prerequisite that a saved decoration must already exist and says nothing about failure modes or output structure beyond 'dict with decorated model path and settings used'.

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 only 60% (most schema descriptions are bare 'Default: X'), but the :param block compensates: name accepts 'name or slug', model_path is 'STL or OBJ', material is an override where empty means use-proven-or-detect, and printer_id enables material detection. The face values are only partially enumerated ('auto, top, bottom, etc.'), leaving a small gap.

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 — 'Apply a saved decoration to a new model' — and clarifies it uses a previously saved recipe rather than fresh settings. However, it never names or contrasts with near-siblings like apply_decoration_preset, decorate_surface, or smart_decorate, so the agent must infer the distinction. Clear but not fully sibling-differentiated.

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: 'Loads a previously saved decoration' suggests a prerequisite (something must have been saved via save_decoration), and 'replayed on any model' hints at the reuse scenario. There is no explicit when-to-use/when-not or named alternative, and no statement of what to do if the decoration doesn't exist.

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 disclose real behavior: the operation opens an interactive inline 3D stage on success, oversized meshes are auto-decimated, the PNG preview is only a floor, and no signing is needed. It omits whether existing decoration is overwritten, scope/permission needs, and reversibility, so it is strong but not complete.

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 repeats itself: the opening sentence already says it opens the inline 3D stage, then a dedicated 'INLINE 3D STAGE' paragraph restates the same orbit/zoom/decimation behavior at length. The Kiln Pro upsell and pricing URL consume space without helping invoke the tool.

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

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

For a 9-parameter mutation tool with no output schema and no annotations, the description should explain what the applied preset does to the host mesh and what the parameters control. Instead it explains staging/decimation and upsell, leaving the core operation and parameters undocumented.

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?

Nine parameters with only 22% schema description coverage, and the description explains none of them (face, scale, offsets, preset_id, preset_release_id/version_id, base_mesh_version_id). It mentions the preset's 'own recorded settings' in passing but adds no meaning an agent could use to set values, failing to compensate for the coverage gap.

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: 'Apply a saved decoration preset to a mesh', and the clause 'the preset's own recorded settings, no signing required' distinguishes it from the signing/release siblings and from plain apply_decoration. However, it does not name the nearest alternative (apply_decoration, preview_decorated_mesh) directly, so sibling differentiation rests on 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 only implied. The phrase 'no signing required' hints that a signed-preset path exists elsewhere, and 'Requires Kiln Pro' gives a prerequisite, but there is no explicit when-to-use/when-not or named alternative among the many decoration tools. Minimal viable guidance.

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