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

Beyond the destructiveHint=true annotation, the description discloses genuinely additive traits: the confirmation is five-minute and single-use, project confirmation resolves the destination, and it binds the existing-file SHA256. It still does not say what the confirmation yields or what happens on expiry, but the behavioral context is richer than the annotations alone.

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

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

Three tight sentences, front-loaded with the core action and followed by the operation list and the preview instruction. Density is high with no filler, though the SHA256 binding phrase is jargon-heavy for its one clause.

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

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

For a 9-parameter, destructive, no-output-schema tool this covers the workflow and safety gate adequately, but it omits what the confirmation returns (token/id?), its relationship to create_cura_confirmation, and behavior on timeout or reuse, which an agent would need to chain this into an execution step.

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 44% across 9 parameters, so the description is expected to compensate. It clarifies the action families and the 'resolved destination' for save/save_as, but says nothing about values, extruder, build_plate, or file_path, leaving several parameters undocumented outside 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 action (prepare a one-use confirmation) and enumerates the covered operations (settings, slicing, G-code export, project Save/Save As), which maps cleanly onto the action enum. It does not, however, distinguish itself from the sibling create_cura_confirmation, leaving the create-vs-confirm boundary ambiguous.

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?

"Show the changes before executing" implies this is a preview/gate step that precedes execution, which is useful implied guidance. But no explicit when-to-use rule, prerequisite, or alternative (create_cura_confirmation, cura_operation, confirm_printer_api_write) is named, so the agent must infer the routing.

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

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

Beyond the annotations it discloses several non-obvious traits: the token is one-use, expires in five minutes, is bound to the exact request and current printer state, and requires explicit human approval, and that this call itself performs no write. That is substantial extra context for a tool annotated only as destructive/open-world. The only tension is that destructiveHint=true sits oddly with 'Does not perform the write', though it is reconcilable as a hazard class for the downstream write rather than this call.

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 short sentences, front-loaded with the token's defining constraints (one-use, five-minute, bound) followed by the workflow and the negative scope. Every sentence carries information and nothing is repeated.

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, yet the description never says what is returned (presumably a confirmation token/id) or that the token must be supplied back to printer_api_write to authorize the write. The five-minute/state-binding wording partially covers invalidation, but the return-value and hand-off contract is left implicit for a fairly complex 8-parameter tool.

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

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

Schema description coverage is only 25% across 8 parameters (api, method, body, form, files, query, path_parameters are undocumented in the schema). The description adds only the loose hint that the arguments must mirror 'the exact documented write request'; it says nothing about what api/method/body/form/files/query mean or how they must correspond to printer_api_catalog entries. With low coverage, the description should compensate more than it does.

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?

Specific verb and resource ('Prepare a one-use five-minute confirmation'), with the scope of the token spelled out (bound to the exact write request and current printer state). It explicitly distinguishes itself from the sibling that does the work by closing with 'Does not perform the write', so an agent can tell it apart from printer_api_write 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?

It names the alternative (printer_api_write) and the ordering ('obtain specific approval before printer_api_write'), which is genuinely actionable routing guidance. It does not, however, distinguish this confirmation from other confirmation-style siblings such as create_print_confirmation, confirm_cura_operation or preflight_print_action, so the when-to-use case is only partly closed.

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=false, destructiveHint=false, openWorldHint=false; the description adds genuinely new behavior: the token is one-use, and the call itself does not modify Cura (accurate against destructiveHint=false). The token's lifetime/expiry and how it is redeemed are not covered, keeping this below a 5.

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

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

Two sentences, zero filler, with the operation and its non-side-effecting nature front-loaded. Nothing needs trimming.

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 should clarify the returned token and how it is consumed downstream; it says 'one-use' but not who redeems it or how long it lasts. For a 3-param, 0%-coverage tool with an enum-heavy schema, the definition is functional but leaves real gaps.

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

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

Schema description coverage is 0% across 3 parameters, so the description carries the burden and fails: it never explains the 'action' parameter, its only legal value (load_cura_file), or the project_mode enum (open_as_project vs open_as_model). Only file_path is vaguely gestured at via 'one staged 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?

Names a specific verb and resource: 'Create a one-use confirmation token for loading one staged file into Cura.' The scope (one staged file, not a general write) is precise, though it never names the sibling that consumes the token (e.g. confirm_cura_operation) or that distinguishes it from cura_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?

Usage is implied — you call this to obtain a confirmation token before loading a staged file — but there is no explicit when-to-use, no mention of what must precede it (staging the file), and no direction to the sibling tools that perform the actual load. The agent must infer the workflow.

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

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

Annotations declare readOnlyHint=false, destructiveHint=false, openWorldHint=false, and the description adds real context beyond that: the token is short-lived, no printer write is performed, and a human-visible warning is required before the write step. It stops short of stating token lifetime, whether it is single-use, or what invalidates it.

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 short sentences, front-loaded with the core action and immediately followed by the critical negative claim and the human-in-the-loop requirement. No filler, no restatement of the name or title.

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

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

Covers the precondition (read status first), the artifact produced (a short-lived token), the safety constraint (no printer write, human review required), and the follow-up step. With no output schema, it would help to say what the token is for and how it is handed to the write tool, but the workflow is otherwise callable as described.

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% across three parameters, so the description carries the full burden. It gestures at the two enum branches ("staged toolpath upload or queued-job print start") but never explains that action selects between them, nor how job_uuid and file_path map to each branch. An agent must infer the parameter contract from the schema alone.

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

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

States a specific verb and resource ("Create one short-lived token") scoped to "a specific staged toolpath upload or queued-job print start," and explicitly negates what it does not do ("Performs no printer write"). This distinguishes it cleanly from the write siblings (start_print, upload_gcode, confirm_printer_api_write) 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?

Gives a clear operating sequence: read printer status first, then create the confirmation, show the human the target and warning, then invoke the write tool. It routes the agent to the write tool as the follow-up action. It does not, however, contrast itself against the similar-sounding sibling confirm_printer_api_write or state when a confirmation is not needed.

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, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds one genuinely new behavioral fact — the read happens 'explicitly on its main thread' — which implies a thread-affinity constraint the agent would not otherwise know. It says nothing about cost, latency, or whether the read is safe to 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?

A single sentence with no filler, front-loaded on the verb and the resource list. The trailing 'explicitly on its main thread' is the only slightly awkward clause, but it carries real information rather than padding.

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 no-argument, read-only inspection tool with no output schema, the description covers the domain of what is returned (machine, materials, scene, backend, build plates) well enough to set expectations. The main gap is that it never clarifies how this differs from cura_status when both are available.

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 per the baseline this scores 4. The description correctly adds no parameter discussion, and the empty schema plus additionalProperties=false leaves no ambiguity about the call shape.

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 opens with a specific verb ('Read') and enumerates the exact resources it touches: machine/profile, extruders/materials, scene objects, backend state, and sliced build plates. That enumeration meaningfully distinguishes it from siblings like cura_status and cura_settings, though it never names those siblings directly to draw the contrast.

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

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

There is no explicit when-to-use guidance, no statement of when not to use it, and no routing to an alternative such as cura_status or cura_settings. 'Live' hints that it reads current state rather than cached data, but the agent is left to infer the selection criteria.

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 a destructive, non-readOnly, closed-world write, so the safety profile is covered. The description adds genuinely new behavior: project saves are asynchronous and return an operation_id that must be polled, and the tool intentionally never triggers a print or upload. It doesn't spell out what a set_settings or slice does to existing output, but the added async and no-side-effect context is real value beyond 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?

Three short sentences, front-loaded with the action list, then the async save caveat followed by poll routing, then the safety boundary. No filler or restatement of the name.

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, nested values object, 40% schema coverage, no output schema, and a destructive annotation, the description covers the dispatch and save lifecycle but omits the confirmation_token origin, what values must contain, and how mode/file_name/folder interact. It is adequate but leaves an agent guessing on the multi-step save 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 coverage is only 40% across 10 parameters, so the description bears extra burden and only partially meets it: the four action verbs disambiguate the action enum (which has no per-value schema descriptions), which is the key dispatch parameter. It says nothing about values, extruder, build_plate, file_path, or that confirmation_token comes from the confirmation siblings, leaving several parameters unexplained in both places.

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 specific verbs and resources (apply settings, slice, export G-code, save 3MF project) that map one-to-one onto the four action enum values, so the agent knows exactly what the tool does. It also distinguishes itself from siblings by declaring it never prints or uploads automatically, ruling out start_print/upload_gcode confusion.

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 clear usage context: 'Apply approved' ties this to the confirmation flow, and the save branch explicitly routes the agent to cura_project_save_status for polling. It also names a when-not condition ('never prints or uploads automatically'). It stops short of saying when to prefer cura_settings or create_cura_confirmation first, so it isn't a full 5.

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 establish readOnlyHint=true, destructiveHint=false and openWorldHint=false, so safety is covered. The description adds a real boundary disclosure — 'Does not return file contents' — which prevents the agent from misusing this as a file-read tool, plus the specific fields it does surface.

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

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

Two sentences, zero filler, with the core action and inspected attributes front-loaded and the negative constraint placed last where it reads as a qualifier.

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

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

No output schema exists, and the description compensates by naming the returned fields. For a one-parameter read-only inspection tool, nothing further is needed 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 single parameter has 0% schema description coverage, so the description carries the burden. It specifies 'one absolute path', which conveys both the cardinality and the path format constraint the schema leaves 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?

Specific verb (Inspect) plus resource (one absolute path) and an enumeration of exactly what is checked (existence, type, readability, resolved path, OS error). It does not differentiate itself from the sibling cura_inspect, which leaves an ambiguity the agent must resolve elsewhere.

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 'from Cura itself' implies the tool operates inside Cura's environment rather than the host, but no condition for choosing this over cura_inspect or load_cura_file is stated. No when-not guidance and no prerequisites are given.

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

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

Annotations already declare a safe read-only, non-destructive operation. The description adds real behavioral content beyond them: it enumerates the possible outcomes (completion, validated archive size/hash, or failure) and warns that a 'running' result does not mean the save finished, which is meaningful state semantics for a poller.

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 tight sentences with zero filler; the outcome summary leads and the state-semantics caveat follows. Every clause carries information an agent needs.

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 appropriately enumerates the return states rather than leaving the agent guessing. The main gap is the undocumented operation_id and any retry/polling cadence, but for a single-read status tool it is nearly 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 carry the burden for the single operation_id parameter, yet it never mentions operation_id, its origin, or format. The only parameter is left entirely undocumented in both schema and 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?

States a specific verb ('Read') and resource ('completion, validated archive size/hash or failure for a project save'), so the agent knows this is a save-status poll rather than a generic status call. It does not explicitly contrast itself with siblings like cura_status or cura_operation, leaving some ambiguity about which status 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?

The sentence 'A running response is not a completed save' implies the tool is meant for polling an in-progress save, giving some contextual usage guidance. However, it never states when to call it versus cura_status or cura_operation, nor prerequisites such as needing an operation_id from a prior save call.

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, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds real behavioral context: the omit-keys listing mode and the 200-key ceiling. It does not disclose how unknown keys are handled or the response shape, so this is solid but not rich.

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 tight sentences with no filler; the core read action is front-loaded and the two operating modes plus the cap follow immediately. Every clause earns its place.

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

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

For a two-parameter read tool with no output schema, the description covers the listing-versus-fetching behavior adequately. But with 0% schema coverage, the unexplained 'extruder' parameter and the global-vs-extruder scoping rule leave a real gap an agent must guess at.

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 carry parameter meaning. It does explain the 'keys' parameter well (omit to enumerate, provide up to 200 for values) but says nothing about 'extruder' — not what index 0 means, nor what happens when it is omitted versus supplied. Partial compensation only.

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

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

States a specific verb (Read) and resource (effective global or extruder settings), which distinguishes it from siblings like cura_inspect, cura_status, and printer_status. It stops short of explicitly naming which sibling to use instead, so it lands 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?

The description implies two usage modes (omit keys to list, supply keys to fetch values) and gives a 200-key cap, which is genuinely useful guidance. However it never says when to prefer this tool over alternatives such as cura_inspect or printer_status, nor any prerequisites, so usage is only 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds genuinely new behavioral context beyond that: the returned fields are deliberately inert placeholders and startup intentionally skips reading Cura configuration. It stops short of describing the response shape, which no output schema supplies.

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 short clauses, front-loaded with the purpose, and each sentence carries distinct information (what it checks, what the fields mean, what it avoids doing). No filler or repetition of the title.

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

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

With no parameters and no output schema, the description must carry the meaning of the result, and naming the printer/profile/extruder/scene fields plus warning that they are placeholders goes a long way. It never states the actual ready/not-ready outcome contract, leaving a small gap for a status 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 tool takes zero parameters, so the baseline is 4 and there is nothing for the description to disambiguate. No misleading parameter claims are made.

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 up front ('Check whether the local Cura bridge is ready'), which is far more precise than invoking the tool name. It also implicitly separates itself from siblings like printer_status ('does not contact a printer') and cura_inspect ('fields are placeholders, not live measurements'), though it never names an alternative explicitly.

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

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

The description conveys that this is a readiness/health check at startup, which implies when to call it, but it never states the condition that selects it over cura_inspect, cura_settings, or printer_status, nor any exclusions. Usage is inferred rather than guided.

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=false and destructiveHint=true, so the mutating nature is known; the description usefully adds that it will not slice or trigger a print. It does not, however, explain what 'loading' changes in the workspace or why the operation is destructive, nor anything about the confirmation-token requirement beyond the adjective 'confirmed'.

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 tight sentences with the core action front-loaded and the boundary immediately after. Every clause earns its place with no filler or 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?

For a destructive, write-mode tool with no output schema and zero param documentation, the description covers purpose and scope but omits the confirmation flow that the required confirmation_token implies and the effect of project_mode. An agent could call it, but key mechanics remain unclear.

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 three parameters, and the description compensates for none of them. It never explains file_path, the purpose of confirmation_token, or how project_mode's open_as_project/open_as_model enum changes behavior, so an agent must infer parameter meaning entirely from names and types.

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 (loads) and resource (a confirmed staged model/project/G-code/UFP file) with a clear target (the active Cura workspace). The boundary sentence 'It does not slice or send a print' implicitly separates it from siblings like start_print and preflight_print_action, though it never names an alternative directly.

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

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

The word 'confirmed staged' implies a prerequisite flow (create_cura_confirmation/confirm_cura_operation) and the 'does not slice or send a print' clause gives an implicit when-not boundary. But it never explicitly states when to choose this tool over cura_operation, start_print, or upload_gcode, leaving the routing to inference.

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

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

The description asserts 'It performs no write,' while the annotations declare readOnlyHint=false, i.e. that the tool is not a read-only operation. That is a direct factual conflict about side effects, and no other behavioral context (permissions, failure modes) is given to resolve it.

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

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

Two short sentences with the purpose front-loaded and the side-effect claim immediately after; 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?

There is no output schema, so the description would ideally say what a 'safe' vs 'unsafe' result looks like and how to react, which it does not. For a one-parameter check tool the gap is small but real.

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 single parameter is a self-documenting enum, and the description's phrasing ('upload or print-start operation') loosely maps to the two enum values. It adds no format or constraint detail beyond that, so it only partially compensates 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 and object ('Check whether an upload or print-start operation is currently safe'), which cleanly separates it from the sibling write tools upload_gcode and start_print. It does not name those siblings explicitly, but the 'preflight' framing makes the distinct purpose evident.

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

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

The word 'currently' implies this is meant to be consulted before the corresponding write, but the description never says to call it before upload_gcode/start_print nor what to do when the check fails. Usage is inferable rather than stated.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds that the catalog enumerates R/W endpoints and can return full operation definitions, which is useful context beyond the annotations, but says nothing about size, pagination, or whether the catalog is static or dynamically derived.

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 tight sentences with the primary capability front-loaded, followed by the drill-down instruction. No filler, though it could be marginally more explicit about the no-parameter discovery mode.

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 must carry return-value burden, and it only gestures at 'operation details and definitions' without describing the shape of a catalog listing versus a single-endpoint detail response. Adequate for basic invocation but incomplete for an agent planning multi-step API exploration.

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 50%: the endpoint parameter has a description that usefully ties back to the catalog ('Exact endpoint template from printer_api_catalog'), while the api enum is undocumented. The description corroborates the two-phase pattern but adds no syntax or format detail beyond the schema.

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

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

States a specific verb and resource: 'Inspect all documented local S5 printer/cluster R/W endpoints and schemas.' An agent can tell this is a discovery/catalog tool for the printer API. It does not, however, explicitly differentiate itself from siblings like printer_api_read or printer_api_write, which is the remaining gap.

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

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

The phrase 'Specify api + endpoint to include operation details' implies a two-phase drill-down workflow, but there is no explicit when-to-use guidance and no mention of when to prefer this over printer_api_read or printer_api_write. Usage is inferable rather than stated.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds real value on top: it warns that responses may include sensitive network/system details and that unbounded camera streams are unsupported. That is behavioral context an agent would not get from the structured fields alone.

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 short sentences, front-loaded with the core action and followed by the exclusion and the data-sensitivity caveat. Efficient, though slightly cryptic in places ('bounded local printer endpoint').

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, nested-object tool with no output schema and very low schema coverage, the description is too thin. It omits how the body/form/query/files parameters map to endpoints and omits any reference to printer_api_catalog as the source of valid endpoint templates, leaving significant 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?

Schema description coverage is only 29% across 7 parameters, so the description carries the burden of explaining parameter roles and does not. It adds nothing about api, form, files, query, path_parameters, or body, and only the schema's own endpoint/body descriptions hint at usage.

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

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

The description gives a specific verb (GET) and resource (a documented bounded local printer endpoint), so the agent knows this is a read call against known endpoints. It does not, however, differentiate itself from the sibling printer_api_write or explain what 'bounded' means, leaving the read/write distinction to be inferred from 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?

'Does not support unbounded camera streams' is a genuine when-not exclusion, and 'request only what is needed' is soft usage guidance. But it never names the alternative tools (printer_api_catalog to look up endpoints, printer_api_write to mutate them), so routing is only 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?

Annotations already declare destructiveHint=true, readOnlyHint=false and openWorldHint=true, so the safety profile is covered structurally. The description goes beyond them by disclosing the approval gate, the confirmation-token requirement, and the side effect that auth pairing stores credentials in the OS credential store and requires on-display approval. It stops short of saying what is lost on a destructive call (e.g. aborting a print).

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

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

Three dense sentences; the operation-gating rule and the approval requirement are front-loaded before the category list. No filler, though the trailing auth-pairing sentence is somewhat tangential to invoking 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 destructive, open-world write tool with no output schema and low parameter coverage, the description adequately conveys the approval workflow and scope but omits how the confirmation token is obtained and how the endpoint/body fields are assembled. Enough to avoid reckless invocation, not enough to call it correctly without consulting siblings.

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

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

Schema description coverage is only 22% across 9 parameters, so the description must do the explaining and largely does not. It mentions the confirmation token and hints at endpoint templates, but gives no meaning for api, method, body vs form vs files, query, or path_parameters, leaving most of the payload contract undocumented.

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: 'Execute an explicitly approved documented S5 write with its matching confirmation token', and enumerates the operation families it covers (motion, temperature, pause/abort/resume, jobs/materials/configuration/firmware/network). This distinguishes it from the read-side sibling printer_api_read, though it does not explicitly name any sibling as an 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?

Clear preconditioning: the write must be 'explicitly approved documented S5' and carry a matching confirmation token, plus the hard rule 'Do not invoke without the human approving the exact action'. It lacks an explicit pointer to the prerequisite tools that mint the token (create_print_confirmation / confirm_printer_api_write), so routing detail is implied rather than stated.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds the data scope (inventory plus active and queued jobs), but says nothing about permissions, pagination, or response shape that would go beyond the annotations.

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

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

Two short sentences, front-loaded with the purpose and with no filler. The second sentence largely restates the readOnly annotation, so it is slightly redundant, but the definition stays tight.

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

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

For a zero-parameter read tool with no output schema, the description covers both the read-only nature and the contents returned (inventory, active and queued jobs). It could say a bit more about the shape of the job data, but it is adequate given the annotations.

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

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

The tool takes zero parameters, so the baseline is 4 by rule. There is nothing parameter-related for the description to clarify, and it introduces no misleading parameter claims.

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) plus the exact resource: the Cura Connect printer inventory along with its active and queued jobs. This clearly separates it from mutating siblings such as start_print, upload_gcode, and printer_api_write.

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 line 'This tool performs no printer write' implicitly signals that this is the read-side alternative to the write/print tools, but no explicit when-to-use, when-not-to-use, or named alternative is given. Usage is implied rather than stated.

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

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

Annotations already disclose destructiveHint=true, openWorldHint=true, and readOnlyHint=false, so the safety profile is covered. The description usefully adds that only a queued, confirmed, local job qualifies, but it omits the physical/irreversible nature of starting a print 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?

A single front-loaded sentence with no filler; the operative verb and scope appear immediately. It is efficient, though its brevity leaves the gaps noted in other dimensions.

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

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

For a destructive, open-world mutation with no output schema and zero schema coverage, the description should explain the confirmation prerequisite, irreversibility, and failure behavior. None of that is present.

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% and neither parameter has any documented meaning. The description hints at 'confirmed' (confirmation_token) and 'queued job' (job_uuid) but gives no format, provenance, or single-use semantics, so it does not 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?

Specific verb ('Commands ... to start printing') plus a tightly qualified resource ('one confirmed queued local printer job'). The qualifiers 'confirmed', 'queued', and 'local' meaningfully narrow the scope, though no sibling tool is named for contrast.

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

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

The word 'confirmed' implies a prerequisite confirmation flow, which is consistent with the required confirmation_token, but the description never states that a confirmation must be created first nor routes the agent away from siblings like preflight_print_action or create_print_confirmation. Usage is only inferable.

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

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

Annotations already flag destructiveHint=true and openWorldHint=true, so the safety profile is covered. The description adds genuinely new context beyond the annotations: the file must already be confirmed/staged, and the upload may auto-start a print if the queue policy permits. It still does not say what 'destructive' means here (e.g., queue overwrite) or what the token gates.

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

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

Two sentences, no filler, front-loaded with the action and the accepted file types. Every clause carries information.

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

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

For a destructive, open-world write with no output schema and undocumented parameters, the description covers the action and the auto-start side effect but omits token provenance, failure modes, and what an existing queue entry would be replaced by. Adequate but with clear gaps.

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

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

Schema description coverage is 0%, so the description carries the burden. It adds meaning for file_path by enumerating allowed extensions and the staging-folder origin, but says nothing about confirmation_token (its source or lifetime), leaving one of two required parameters entirely unexplained.

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 (uploads) and resource (one .gcode/.gcode.gz/.ufp file from the staging folder) with a clear destination (selected local printer). An agent can distinguish this from start_print and load_cura_file, though the description does not name those siblings explicitly.

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

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

The word 'confirmed' plus 'from the staging folder' implies prerequisites (staged + confirmation token issued) without spelling them out, and no alternative tool is named. The auto-start note hints at consequences but gives no when-not guidance.

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