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

With no annotations, the description carries the full disclosure burden and does clearly state a read-only behavior ('Read') while enumerating returned attributes. It does not discuss output structure, live-versus-cached data, or error behavior, but the non-destructive nature and scope are transparent enough for a simple 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?

The description is a single sentence, front-loaded with the action and resource, and contains no filler or redundancy. Every phrase contributes meaningful 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 parameterless read operation, the description adequately conveys what data is returned and at what granularity (per-slot). It does not specify return structure or behavior when no AMS unit is available, but these are minor gaps 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?

The input schema is empty with 0 parameters and 100% schema description coverage, so there are no parameter semantics for the description to add. The baseline of 4 applies, and the description adds useful context by clarifying what the parameterless call returns.

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

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

The description uses a clear action verb ('Read'), names the resource ('AMS units'), and enumerates the specific data returned: filament type, color, nozzle range, and active slot. This makes it easily distinguishable from siblings like temps or list_files, which target different concerns.

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 when-to-use or when-not-to-use guidance is provided, and no alternative tool is mentioned. The AMS-specific wording implies usage when filament/AMS data is needed, but it does not clarify how this relates to the broader status tool.

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

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

No annotations are provided, so the description must carry the full burden. The description only says 'list files' and mentions the connection details, but does not disclose whether the operation is read-only, whether authentication is required, whether there are side effects, or what the return payload looks like. For a tool with zero annotations, this is a significant gap.

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

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

The description is a single, focused sentence with no filler words. The essential information (verb, resource, connection detail) is front-loaded. Every word contributes 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?

The tool is simple: one optional parameter, no output schema, no annotations. The description tells the agent what the tool does and the endpoint, but it does not mention the return format (e.g., a list of filenames, with metadata) or any prerequisites. While it may be adequate for a simple listing operation, an agent might need more context about the expected output, so completeness is only partially achieved.

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 'dir' is already described in the schema with 100% coverage. The tool description adds no extra meaning about the parameter (e.g., syntax, format, or examples). Since the schema fully documents it, the baseline of 3 is appropriate; the description does not degrade it but also does not enhance 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 states a specific verb ('list') and a specific resource ('files on the printer FTPS cache'), and includes the protocol/port detail. It clearly distinguishes from all sibling tools (stop, upload, print, etc.), which are about other operations. The purpose is unambiguous.

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

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

The tool's purpose is self-evident, and none of the sibling tools overlap with listing files, so explicit 'when not to use' guidance is not critical. However, the description does not explicitly state when to use it (e.g., 'use this to see available files'), but the context makes it obvious. It is clear enough for an agent to route to 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 are provided, so the description carries the full burden. It mentions 'Requires confirm: true', but the schema already documents that confirm must be true after operator agreement, so this adds no new information. The description does not disclose side effects, reversibility, or any state changes beyond the obvious pause action.

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

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

The description is extremely concise with two sentences, each serving a distinct purpose: stating the action and stating the key requirement. There is no filler or redundant detail, making it appropriately sized and 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 simple tool with one fully described parameter and no output schema, the description is adequate. It tells the agent what the action is and that confirmation is required. It does not mention edge cases like behavior when no print is running, but that is not essential 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 coverage is 100%, and the property description already explains that confirm must be true after operator agreement. The tool description merely restates this requirement without adding any deeper meaning, so it stays at the baseline for full 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 description clearly states the action (pause) and resource (the running print), making the purpose unambiguous. It does not explicitly contrast with sibling tools like 'stop' or 'resume', so it doesn't fully meet the 'distinguishes from siblings' bar, but the verb is specific enough.

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. It does not mention that pause is for temporary halts or that stop is for permanent cancellation, nor any conditions under which pause should be preferred. The agent is left to infer usage 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?

With no annotations, the description carries the behavioral disclosure burden, and it does disclose meaningful traits: it refuses non-final file forms, requires confirm:true only after operator agreement, and may merge defaults from a sibling .print.json. It does not mention the default FTPS upload behavior implied by alreadyUploaded, but the schema partially covers that.

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

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

Three compact sentences, front-loaded with the file pattern and no filler. Each sentence carries a distinct piece of behavior or constraint, so the description is appropriately sized.

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

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

The description covers critical preconditions and validations, but for a tool with six parameters, no annotations, and no output schema, it leaves optional parameter semantics and runtime behavior undocumented. An agent still has to infer what happens after a successful call and how plate/useAms/amsMapping interact.

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 50%, so the description needs to compensate. It clarifies the required file pattern, the confirm condition, and that plate/AMS defaults may come from .print.json. However, plate, useAms, and amsMapping still lack semantic explanation.

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

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

The description uses a specific verb ('Start printing') and identifies the exact resource pattern ({part}-{variant}-{rev}.gcode.3mf), making it distinguishable from sibling operations like upload, slice_hook, or stop. The refusal constraints further clarify what this tool does not do.

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 names the valid input family and explicitly says it refuses bare STL, wip-*, and scratch/, so an agent knows when not to attempt a call. It also states the confirmation requirement clearly. It does not explicitly route to sibling tools like upload, so alternative guidance is not fully 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 are provided, so the description carries the full burden of behavioral transparency. 'Resume' implies a state change, but the description does not disclose whether the action is reversible, requires authentication, or has side effects like discarding buffered commands. The confirm requirement is a small behavioral note but insufficient for a mutating action.

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

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

The description is a single sentence, which is concise and front-loaded with the main action. The confirm requirement is included, and there is no wasted text. It could be improved with more context, but it is appropriately sized.

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

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

Given no output schema, no annotations, and a single required parameter, the description must explain both the action and its implications. It only covers the basic action and the confirm requirement, omitting details like error conditions, effect on print history, or what happens if the printer is not paused. For a state-changing tool, this is incomplete.

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

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

The schema description coverage is 100%, so the parameter semantics are fully documented in the schema. The description adds a minor behavioral note ('Requires confirm: true') but no additional meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description states the verb 'Resume' and resource 'a paused print', which is clear enough. However, it doesn't explicitly differentiate from sibling tools like 'start' or 'pause', though the context of 'paused print' implies it. It lacks detail on scope or effect.

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 when to use it (when a print is paused) and mentions a requirement (confirm: true), but does not explicitly state when not to use it or mention alternatives. The sibling list includes 'pause' and 'stop', but no guidance on choosing between them is given.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It discloses that the tool does not upload or print and that it uses a CLI, which is helpful. It does not mention side effects like file output location, overwrite behavior, or the settings prerequisite for bare STL, so transparency is only partial.

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, front-loaded with the main action, and every sentence adds useful context: slicing scope, output naming, non-upload/non-print behavior, and the bare-STL allowance. There is no wasted text.

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

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

The tool has 10 parameters, no output schema, and low schema coverage, so the description must carry significant weight. It explains the core purpose and one key output pattern, but omits output directory behavior, settings requirements, and the meaning of several parameters, leaving an agent under-equipped 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 20%, and the description adds little about the many parameters. It clarifies that part, variant, and rev shape the output filename, but plate, orient, arrange, filaments, outputDir, and the exact role of settings remain unexplained in the main 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 names a specific verb ('Slice'), a specific resource ('STL or mesh-only 3MF'), and an output pattern ('{part}-{variant}-{rev}.gcode.3mf'). It also distinguishes itself from likely siblings by explicitly stating it does not upload or 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?

It clearly indicates this tool is for local slicing only and calls out non-upload/non-print behavior, which helps an agent rule it out for upload/print tasks. It also notes that bare STL input is allowed only here, giving a useful scoping cue. However, it does not explicitly name sibling tools or provide a direct 'use X instead when...' comparison.

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 states 'Read', implying a non-destructive operation, and lists the data fields. However, it does not disclose error behavior (e.g., what happens if the printer is unreachable) or any other behavioral details beyond the read nature. For a simple status tool, this is adequate but not rich. A score of 3 reflects the minimum viable 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?

A single, front-loaded sentence that states the action and resource first, then lists the specific data points. Every word earns its place, and there is no redundancy. The structure is optimal for quick agent comprehension.

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, the description is responsible for explaining the return value. It lists all key fields (gcode_state, progress %, remaining minutes, layer, job name) in a clear manner, providing enough detail for an agent to understand what it will receive. The tool is simple (no parameters, read-only), so this is complete.

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

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

The tool has zero parameters, and the schema is empty. Per the rubric, a baseline of 4 is appropriate when there are no parameters. The description does not need to add parameter semantics, and there is nothing to explain. The description's mention of the return fields is sufficient 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 action ('Read') and the resource ('Bambu LAN print state'), then enumerates the specific fields returned (gcode_state, progress %, remaining minutes, layer, job name). This is specific and distinct from sibling action tools like stop, pause, and resume, which perform state changes rather than reading 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?

The context is clear: this is a read operation for current print state, making it obvious when to call it (whenever the agent needs current print status). It does not explicitly name alternatives or state when not to use it, but given the sibling set (actions vs. this read), the usage is unambiguous. A score of 4 reflects clear context without explicit exclusion 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 of behavioral disclosure, and it delivers key traits: the operation is irreversible ('not resumable') and requires explicit confirmation ('Requires confirm: true'). This gives an agent a clear safety profile for the tool without needing additional 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?

The description is a single sentence that front-loads the core action ('Cancel the running print') followed by the key caveat and the parameter requirement. Every word earns its place, with no redundancy or filler.

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

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

For a simple one-parameter tool, the description covers the essential elements: the action, irreversibility, and the confirmation requirement. It does not mention edge cases like errors when no print is running, but this is acceptable given the low complexity and absence of an 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?

Schema description coverage is 100%, so the schema already fully documents the confirm parameter. The description's 'Requires confirm: true' essentially restates the schema's requirement without adding new semantic detail, so it does not go beyond the baseline.

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

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

The description states the specific verb 'Cancel' with the resource 'the running print,' making the tool's function immediately clear. The parenthetical '(not resumable)' further distinguishes it from sibling tools like pause and resume.

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 'not resumable' implies this tool is for permanent cancellation, contrasting with pause/resume siblings, but it does not explicitly state when to use stop versus those alternatives. 'Requires confirm: true' is more of a parameter requirement than usage guidance. The usage context is implied rather than explicitly stated.

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

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

No annotations exist, so the description carries the full burden, and it delivers: it discloses units (°C), the three components covered (nozzle, bed, chamber), and that both current and target values are returned. This is honest, specific behavioral context beyond the tool name.

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

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

A single, front-loaded sentence with zero filler. Every element (verb, resource, units, scope, value types) earns its place, packing maximum signal into minimal length.

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

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

For a zero-parameter read tool with no output schema, the description covers the essential information: what is read, in what units, and what value types are returned. It does not describe the output format/structure, but for a simple telemetry read this is a minor gap.

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

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

The tool has zero parameters, which warrants a baseline of 4. The description appropriately compensates by clarifying what the tool will report (current + target temps across three components), which is the only semantic content an agent needs.

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

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

States a specific verb ('Read'), a specific resource (temperatures), and the scope (nozzle/bed/chamber) with units (°C) and value types (current + target). This clearly differentiates it from siblings like stop, slice_hook, and upload without needing to inspect any schema.

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

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

No guidance on when to use this tool versus alternatives. Sibling tools include status and ams, which could plausibly overlap in reporting machine state, yet the description provides no when/when-not or alternative routing.

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

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

There are no annotations, so the description carries the behavioral disclosure burden. It adds useful non-obvious traits: the transfer uses FTPS, the filename must match the {part}-{variant}-{rev}.gcode.3mf pattern, and the operation does not start a print. It stops short of describing overwrite behavior, authentication, or error conditions, but it does more than the minimum.

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 with no filler. The main action and transport are front-loaded, the naming constraint follows immediately, and the critical side-effect note ('Does not start a print') is saved for the end, which is efficient.

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

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

For a simple 2-parameter, no-output-schema tool, the description covers the essential invocation details: protocol, required file naming pattern, and the absence of a print side effect. It lacks details on overwrite or connection requirements, but nothing critical to calling the tool correctly is missing.

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

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

Schema description coverage is 100%, so the schema already documents localPath and remoteName including the default behavior. The description reinforces that the file is a .gcode.3mf artifact but does not add significant new meaning about either parameter beyond the schema.

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

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

The description names a specific verb ('Upload'), a specific resource ('sliced Imagine artifact'), and a specific transport ('over FTPS'). It also states a concrete side-effect boundary ('Does not start a print'), which separates it from sibling print tools. This is clear enough for an agent to know what the tool does.

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

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

The description implies a workflow position: the file must be a sliced artifact and uploading does not start a print, so it is likely used between slicing and printing. However, it never explicitly names alternatives or says 'use this when...' or 'do not use this when...'. The only exclusion given is indirect via the print boundary.

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