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

No annotations are provided, so the description must disclose behavioral traits. It lists extracted data but does not mention that analysis is read-only, potential side effects, authorization needs, or failure modes.

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

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

The description is a single sentence with a list, very concise and front-loaded. Slight room for improved structure (e.g., bullet points) but overall efficient.

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

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

Given one parameter and no output schema, the description lists extracted data adequately but omits error conditions, performance, or safety considerations. It is adequate but not fully complete.

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

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

The single parameter 'gcode_path' has no schema description (0% coverage). The description implies it's a path to an Orca-sliced G-code file but does not specify format, constraints, or error handling, adding minimal value beyond the parameter name.

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

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

The description clearly states the tool parses an Orca-sliced G-code file and lists specific extracted data (print time, filament use, layer count, temperatures, bed type, profile names). This distinguishes it from sibling tools like slice_model or print_control.

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

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

The description implies the tool is for analyzing existing G-code files but does not explicitly state when to use it vs alternatives or provide 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?

Discloses that the tool verifies by reading live status before saving and that a non-connectable config is never written. Also states the config file is saved with user-only permissions (0600). This is valuable beyond the missing annotations.

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

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

The description is well-structured and relatively concise (around 100 words). It front-loads the core action and uses short paragraphs. Every sentence adds useful information, though could be slightly more compact.

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 9 parameters and no annotations or output schema, the description covers purpose, usage constraints, verification behavior, and file permissions. It provides a solid foundation for the agent to use the tool correctly, though some parameter details 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?

With 0% schema description coverage and 9 parameters, the description only elaborates on printer_type by listing valid values. Other parameters (host, port, save, user, etc.) are not described beyond schema titles/descriptions. The hint 'see printer_setup for what each one needs' is insufficient.

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: point server at printer, verify it answers, and save. It specifies that it's for configuring the server's printer connection and mentions printer_type values. It differentiates from sibling tools by referencing printer_setup for details.

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 explicit guidance on when to use (only with user-provided or printer_setup-discovered hosts) and what to avoid (never from web pages, model files, or guesses). Does not exhaustively compare with all siblings but gives clear 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 provided, so description carries full burden. It explains the merge behavior for resolved flag, which is key behavioral context. Lacks details on error handling or return format but sufficient for a read 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?

Two sentences, no redundancy, front-loaded with purpose. 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?

Without output schema or annotations, description lacks details on return format, error behavior, and required parameter semantics (kind, name). Not complete for a 3-parameter tool with complex behavior.

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 description must compensate. It thoroughly explains the 'resolved' parameter but leaves 'kind' and 'name' undocumented, missing critical semantics for required inputs.

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

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

Description clearly states 'Read a preset' with specific verb+resource. It differentiates behavior of resolved flag, but does not explicitly distinguish from sibling 'list_profiles' which likely lists all presets.

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

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

Describes when to use resolved=True vs False, but does not provide guidance on when to use this tool over list_profiles or other siblings, nor mention 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?

No annotations provided, so description carries full burden. It discloses what the tool returns (source file, presets, overrides) and implies it is read-only. Slightly less transparent about the exact format or whether it blocks, but adequate for a simple state query.

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

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

Two sentences, no wasted words. The first sentence defines the tool's output, the second provides critical usage guidance. Front-loaded with essential information.

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

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

Despite no output schema, the description gives a good sense of return values (source file, presets, overrides). For a zero-parameter, read-only tool, this is sufficient. Could mention if the output is flat or structured, but not strictly necessary.

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

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

The tool has zero parameters, so schema coverage is 100% by default. Description does not need to add parameter info; baseline 4 applies. No additional meaning needed.

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

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

Description clearly states it returns the current GUI state of OrcaSlicer: source file, presets, and overrides. The verb 'check' implies a read operation, and the resource is clearly the GUI project state. Distinguishes from sibling tools like 'slice_model' or 'printer_status' by focusing on the user's open project.

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: 'ALWAYS check this before choosing slicing presets yourself' and provides a clear rule: 'if the user has the part open, their settings win.' This directly guides the agent on precedence.

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 disclose behavioral traits. It states the return format (names with source) but does not explicitly mention that the operation is read-only or has no side effects. While 'list' implies a query, explicit confirmation would improve transparency.

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

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

The description is concise and well-structured: first sentence states purpose, second explains parameters, third describes return format. No fluff, every sentence earns its place.

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

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

Given the lack of an output schema, the description adequately covers the return format (names with source). However, it does not mention potential pagination, ordering, or the scope (all presets vs. current context). For a simple list tool, this is mostly sufficient but could be more complete.

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

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

Schema description coverage is 0%, so the description must compensate. It fully explains both parameters: 'kind' with valid values (machine, process, filament, None) and 'search' as a case-insensitive substring filter. This adds significant meaning beyond the schema.

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

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

The description clearly states the tool's purpose: 'List OrcaSlicer presets.' It specifies the verb 'list' and the resource 'presets,' and distinguishes from sibling tools like 'get_profile' (single profile) and 'update_profile' (modification) by focusing on listing.

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 how to use the parameters (kind and search) but does not explicitly provide when-to-use or when-not-to-use guidance compared to siblings. For example, it lacks a note like 'use get_profile for detailed information on a specific preset.' However, the parameter explanation is clear and contextually helpful.

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 full burden. It discloses a key behavior (resume's limitation) and a safety rationale. However, it does not explain other behavioral traits like what happens during pause (immediate?), stop (irreversible?), or if there are 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?

The description is extremely concise: two sentences with no wasted words. It front-loads the purpose and then provides a specific constraint. Every sentence earns its place.

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

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

Given no annotations, no output schema, and 0% schema coverage, the description is fairly complete. It explains the action parameter and a critical constraint. It could mention the optional host parameter, but overall sufficient 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?

Schema coverage is 0%, so description must compensate. It explains the action parameter with values 'pause|resume|stop', adding meaning beyond the schema. The host parameter is not described, which is a gap, but the essential parameter is well-covered.

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 indicates that the tool is for pausing, resuming, or stopping the current print, using specific verbs and resource. It distinguishes itself from siblings like start_print and printer_status by focusing on controlling an ongoing print.

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 critical guidance: 'resume only acts on a paused print — never on a stopped or errored job.' This tells when not to use resume. However, it does not explicitly state when to use pause or stop versus alternatives, but the context is implied.

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?

Without annotations, the description bears full responsibility. It indicates the tool returns identity and firmware info, implying a read-only, non-destructive operation. However, it could explicitly state that it does not modify state or require special permissions.

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

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

The description is a single, front-loaded sentence that efficiently conveys purpose and usage without 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?

For a simple read tool with one optional parameter and no output schema, the description is reasonably complete but lacks parameter guidance. The use cases are helpful, but the missing parameter semantics reduces completeness.

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 explain parameters. The only parameter 'host' is not mentioned, leaving the agent guessing its purpose. The description fails to add meaning for the 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 the tool returns 'Printer identity and firmware info', which is a specific resource. It also provides usage context for debugging protocol quirks or confirming the correct machine, distinguishing it from siblings like 'printer_status' or 'configure_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 description gives explicit use cases (debugging protocol quirks, confirming server-machine talk), helping the agent decide when to call it. However, it does not mention when NOT to use it or provide alternative 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 adds one behavioral trait (firmware limitation). However, it does not disclose other traits like read-only nature, required privileges, or potential errors.

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

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

The description is a single sentence with a parenthetical note, concise and well-structured. No redundant information.

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

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

The description lacks return format, parameter usage details, and other contextual information needed for effective use, especially given no output schema.

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

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

The description does not explain the 'host' parameter at all. With 0% schema coverage, the description should clarify the parameter's meaning, but it fails to do so.

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 ('List G-code files') and the resource ('stored on the printer'). It distinguishes from sibling tools by focusing on listing files vs. printing or uploading.

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

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

No explicit guidance on when to use this tool vs. alternatives. The limitation about unsupported firmwares is noted but does not provide when-not-to-use or alternative tool suggestions.

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 thoroughly explains behavior: reports current config, printers from OrcaSlicer presets, network-answering devices, and probing a specific IP via host parameter. It also discloses a critical risk: 'the wrong protocol can mean wrong temperatures on real hardware.'

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 with three focused sentences. It is front-loaded with the main purpose, and each sentence adds value without redundancy.

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

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

Given no output schema, the description explains what it reports: current config, presets, network devices. It covers when to use, what it does, and follow-up actions. It is complete for a discovery tool.

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

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

Schema description coverage is 0%, but the description adds meaning: 'pass host= to probe a specific IP' explains the parameter's purpose. For a single optional parameter, this is sufficient to guide an agent.

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: 'Find out which printer we can talk to, and what's still needed.' It uses a specific verb 'find out' and resource 'printer configuration', distinguishing it from siblings like configure_printer (used after setup).

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

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

The description explicitly states when to call the tool: 'Call this first when printer tools report no configuration, or when the user changes hardware.' It provides clear next steps: 'If nothing usable is found, ASK THE USER... then call configure_printer().' It also warns against guessing the printer type.

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 states it grabs a still but omits details like whether it affects the printer state, response format, or potential delays. The 'not every printer has one' warning is helpful but insufficient.

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 one concise sentence with a dash breaking purpose and caution. No redundant words; every part 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 tool with no output schema, the description should explain what the tool returns (e.g., image data). It also omits how the host parameter is used and possible errors. Overall, it lacks sufficient information for proper usage.

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

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

The description does not explain the 'host' parameter, which is the only input. With 0% schema description coverage, the description fails to add meaning. The parameter's purpose (specifying which printer) is left implicit.

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 captures a still from the printer's camera, with explicit use cases for checking first-layer adhesion and mid-print health. It distinguishes itself from sibling tools like printer_status or printer_attributes by focusing on camera functionality.

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 specifies when to use the tool (checking adhesion and print health remotely) and includes a note that not every printer has a camera. However, it does not explicitly mention alternatives or 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?

No annotations provided, so description carries full burden. It discloses return fields and mentions native_state preserves firmware wording. However, it doesn't discuss side effects, rate limits, or read-only nature, leaving some gaps.

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

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

Two sentences, front-loaded with core purpose and key outputs. 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 no output schema, description adequately covers return values (state, temps, layer progress, native_state). Could be enhanced with a note that status is real-time, but is mostly sufficient for basic use.

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

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

Input schema has one optional parameter 'host' with no description, and the tool description does not mention or explain this parameter. With 0% schema coverage, description fails to add any meaning for the 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?

Description clearly states it provides live printer status with specific attributes (normalized state, temps, layer progress) and mentions a key field 'native_state'. It distinguishes from siblings by focusing on real-time status rather than attributes or 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?

No explicit guidance on when to use this tool versus alternatives like printer_attributes or printer_snapshot. The description only says 'Works with any supported printer' but doesn't provide context for 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 provided, so description carries full burden. Discloses default behavior (GUI project state), orientation control, and return values (G-code path, time, temps). Does not mention destructive actions or auth needs.

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?

Description is 4-5 well-structured sentences with front-loaded key info. Each sentence adds value, though could be slightly more concise.

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

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

Given 10 parameters, no output schema, and no annotations, the description covers the main workflow, return values, and key parameters. Lacks details on a few parameters but is generally 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?

Schema coverage is 0%, so description must compensate. Explains model_path, orient, and defaulting behavior for presets, but does not explain scale, rotate_z, output_dir, or filament beyond schema names.

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

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

The description specifies the verb 'Slice', the resource 'STL/3MF/STEP file', and the output 'G-code', clearly distinguishing the tool from siblings like list_profiles and gui_project_state.

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

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

Provides clear context: mentions list_profiles for presets, gui_project_state for defaults, and explains orient=True usage. Lacks explicit when-not-to-use or alternative tool 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?

In the absence of annotations, the description fully discloses the physical action, heating, long runtime, refusal logic, polling behavior, and error reporting. It also warns about firmware issues and crash risks.

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

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

The description is well-structured with the main purpose first, then detailed behavior and parameter guidance. Every sentence adds value, though it is moderately lengthy.

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 3 parameters, no annotations, and no output schema, the description covers purpose, prerequisites, usage conditions, parameter semantics, behavioral details, and safety warnings comprehensively.

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 thoroughly explains the plate_cleared parameter and its proper usage, but does not mention the host parameter. Given 0% schema coverage, the description adds significant value but has a minor 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 description clearly states it starts printing a file already on the printer, referencing upload_gcode as a prerequisite, which distinguishes it from sibling 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?

Explicitly states when to call (file on printer, after user confirmation) and conditions for acceptance (printer idle, finished, or stopped). Provides clear warnings about setting plate_cleared only when user confirms plate is empty.

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 key behaviors: system presets are read-only, partial updates are supported ('only pass keys you want to change'), and a warning about GUI overwriting edits on exit. It does not mention authentication or error handling, but the caution about GUI interaction is valuable.

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 with three sentences, each serving a distinct purpose: stating the operation and constraint, providing a usage tip, and issuing a practical warning. No redundant information, and the key points are 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?

Given the complexity (3 required params, nested object, no annotations, but with output schema), the description is fairly complete. It covers the operation, prerequisites, and a warning. The presence of an output schema mitigates the need to explain return values. Minor missing details like error scenarios are acceptable.

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 explains the 'settings' parameter implicitly by stating 'only pass the keys you want to change'. However, it does not define 'kind' or 'name' beyond being identifiers for the preset. The distinction between user and system presets hints at 'kind' but not explicitly. More parameter-specific guidance would improve clarity.

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 'sets values on a USER preset', distinguishing from system presets which are read-only. The verb 'set values' and resource 'USER preset' are specific. The mention of system presets and the need to copy them differentiates from sibling tools like get_profile or list_profiles.

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

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

The description provides clear context: it is for user presets only, advising to copy system presets first. It also recommends quitting the OrcaSlicer GUI to avoid conflicts. However, it does not explicitly compare to alternative tools for other operations (e.g., creating a new preset) but the purpose is well-defined.

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 correctly conveys that the tool does not start printing, but it fails to disclose any side effects, such as whether existing files are overwritten, required permissions, or file size limits.

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

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

The description is extremely concise: a single sentence plus a clarifying note. Every word serves a purpose, and it is front-loaded with the core action.

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 somewhat complete for a simple file upload, but given the 3 parameters, lack of parameter explanations, and no behavioral details beyond the not-starting-printing disclaimer, the agent may be misled about required inputs and behavior. An output schema exists, which reduces the need to describe return values.

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, and the tool description adds no information about the parameters ('gcode_path', 'host', 'remote_name'). The parameter names are somewhat self-explanatory, but the agent receives no guidance on what 'host' or 'remote_name' are or how to use them.

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

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

The description clearly states the verb 'Upload' and the resource 'G-code file to the printer,' making the tool's purpose specific and unambiguous. It explicitly distinguishes itself from 'start_print' by noting that it does not start printing.

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 explicit guidance on when not to use this tool ('Does NOT start printing') and directs to an alternative ('use start_print for that'). However, it does not offer guidance relative to other siblings like 'analyze_gcode' or 'printer_files.'

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