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 the backup is 'timestamped' (a useful behavioral detail) but lacks critical information: whether this operation is safe to run during machine operation, if it requires specific permissions, what happens on failure, or the format/location of the backup file. For a mutation tool with zero annotation coverage, this is 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 a single, efficient sentence that front-loads the core action ('Save') and includes all essential elements (what is saved, where it goes). There is no wasted verbiage, and every word earns its place.

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

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

Given the tool's moderate complexity (a mutation operation with one optional parameter), no annotations, and no output schema, the description is minimally adequate. It covers the basic purpose but lacks behavioral context (e.g., safety, side effects) and output details. It meets the bare minimum for understanding what the tool does but not how to use it effectively.

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 schema already documents the single optional 'description' parameter. The description doesn't add any parameter-specific details beyond what the schema provides, but with only one parameter (and zero parameters required), the baseline is high. A 4 reflects that the description doesn't detract from the well-documented 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 specific action ('Save') and the resources involved ('current FluidNC settings and work offsets'), distinguishing it from siblings like 'restore_config' (which would load from a backup) and 'list_backups' (which would only list existing backups). It provides a complete picture of 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 offers no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., whether the machine must be in a certain state), or compare it to siblings like 'restore_config' for recovery scenarios or 'list_backups' for viewing existing backups. Usage is implied but not 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes the action (resuming motion) and the implementation detail (sends '~' realtime command), which helps the agent understand the low-level behavior. However, it lacks information about potential side effects, error conditions, or response expectations.

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 short sentences) and front-loaded with the core purpose. Every word earns its place: the first sentence states what the tool does and when, while the second provides technical implementation detail 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 the tool's simplicity (0 parameters, no output schema, no annotations), the description is nearly complete. It covers the purpose, usage context, and behavioral mechanism. However, it lacks details on potential errors or confirmation of success, which would be helpful for a tool that interacts with physical machinery.

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 0 parameters with 100% schema description coverage, so the schema fully documents the input structure. The description appropriately adds no parameter information, as none is needed. A baseline of 4 is applied since no parameters exist, and the description does not introduce unnecessary complexity.

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 specific action ('Resume machine motion') and the specific trigger condition ('after a feed hold'), distinguishing it from siblings like 'feed_hold' (which pauses motion) and 'soft_reset' (which resets the system). It uses precise technical language that matches the domain context.

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

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

The description explicitly states when to use this tool ('after a feed hold'), providing clear context for its application. However, it does not mention when NOT to use it (e.g., if the machine is not in a feed hold state) or name specific alternatives, which prevents a perfect score.

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. It mentions the 'confirm=true' requirement, which hints at a safety mechanism, but fails to describe critical traits like whether the deletion is permanent, requires specific permissions, or has side effects. For a destructive operation, this lack of detail 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 extremely concise with only two sentences, front-loading the core action and a key requirement. Every word earns its place, with no redundancy or unnecessary elaboration, making it efficient for quick understanding.

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

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

Given the tool's destructive nature, no annotations, and no output schema, the description is incomplete. It lacks details on behavioral outcomes, error conditions, or what happens post-deletion. For a delete operation, this minimal information is inadequate to ensure safe and correct usage by an agent.

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 schema fully documents both parameters ('name' and 'confirm'). The description adds minimal value by reinforcing the 'confirm=true' requirement but doesn't provide additional context beyond what's in the schema, such as macro naming conventions or confirmation implications.

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 ('Delete') and resource ('a saved macro'), making the purpose immediately understandable. However, it doesn't differentiate this tool from other deletion tools like 'delete_sd_file' in the sibling list, which would require mentioning what distinguishes macro deletion from file deletion.

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 minimal guidance by noting the 'confirm=true' requirement, but it doesn't explain when to use this tool versus alternatives like 'list_macros' for viewing or 'save_macro' for creating. No context on prerequisites or exclusions is given, leaving usage unclear beyond the basic parameter constraint.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the confirm requirement, which is useful, but fails to describe other critical traits such as whether the deletion is permanent, if it requires specific permissions, potential side effects (e.g., affecting machine operations), or error handling. For a destructive operation with zero annotation coverage, 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 extremely concise and front-loaded, consisting of just two sentences that directly convey the tool's purpose and key requirement. Every word earns its place, with no unnecessary information 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?

Given the tool's complexity (a destructive delete operation), lack of annotations, and no output schema, the description is insufficient. It should address behavioral aspects like permanence, permissions, or consequences, but only covers the confirm requirement. This leaves critical gaps for safe and effective use by an AI agent.

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 both parameters (filepath and confirm). The description adds value by emphasizing that confirm 'must be true to delete', reinforcing its importance, but does not provide additional syntax or format details beyond what the schema specifies. This meets the baseline for high schema coverage.

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

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

The description clearly states the specific action ('Delete') and resource ('a file from the CNC controller's SD card'), distinguishing it from siblings like list_sd_files (which lists files) or upload_to_sd (which uploads files). It precisely identifies what the tool does without being vague or tautological.

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 by mentioning 'Requires confirm=true', indicating a prerequisite for use. However, it does not explicitly state when to use this tool versus alternatives (e.g., delete_macro for macros) or when not to use it, which prevents a perfect score.

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 discloses the action ('pause') and command sent ('!'), but does not mention side effects (e.g., whether motion stops abruptly or smoothly), prerequisites (e.g., machine must be running), or response behavior. It adds some context but lacks detailed behavioral traits.

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, efficient sentence that front-loads the key action ('Pause machine motion immediately') and adds necessary technical detail ('Sends '!' realtime command'). Every word serves a purpose with no waste.

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

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

Given the tool's complexity (simple command with no parameters) and lack of annotations/output schema, the description is minimally adequate. It states what the tool does but does not cover potential outcomes, error conditions, or integration with sibling tools, leaving gaps in 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?

There are 0 parameters, and schema description coverage is 100%, so no parameter documentation is needed. The description does not discuss parameters, which is appropriate, earning a baseline score above 3 due to the lack of parameters.

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

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

The description clearly states the specific action ('Pause machine motion immediately') and the resource affected ('machine'), distinguishing it from siblings like 'cycle_resume' (which resumes) or 'soft_reset' (which resets). It includes the exact command sent ('!'), making the purpose unambiguous.

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

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

The description implies usage context by specifying 'immediately' and naming the command, but does not explicitly state when to use this tool versus alternatives like 'soft_reset' or 'cycle_resume'. It provides clear intent but lacks explicit exclusions or comparisons.

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. It clearly indicates this is a read operation ('Get'), which implies non-destructive behavior. However, it doesn't mention potential side effects, authentication requirements, rate limits, or response format details that would be helpful for an agent.

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, efficient sentence that immediately states the tool's purpose and enumerates the specific state components retrieved. Every word serves a purpose with no redundancy or unnecessary elaboration.

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 annotations and no output schema, the description adequately covers the purpose but lacks details about the return format, error conditions, or how the retrieved state components are structured. Given the complexity of G-code state information, more context about the output would be beneficial.

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 with 100% schema description coverage, so no parameter documentation is needed. The description appropriately focuses on what the tool returns rather than inputs. A baseline of 4 is appropriate since there are no parameters to document.

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 specific action ('Get') and the resource ('active G-code modal state'), listing the exact components retrieved (motion mode, coordinate system, units, distance mode, spindle, coolant). It distinguishes from siblings like get_machine_settings or get_machine_status by focusing on G-code state rather than general settings or status.

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

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

The description implies usage when G-code modal state information is needed, but provides no explicit guidance on when to use this tool versus alternatives like get_machine_status or get_system_info. It doesn't specify prerequisites, exclusions, or comparative contexts with sibling 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?

No annotations are provided, so the description carries the full burden. It mentions the tool retrieves settings and allows filtering, but lacks details on behavioral traits like whether it requires authentication, has rate limits, returns structured data, or handles errors. This is a significant gap for a tool with no annotation coverage.

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

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

The description is front-loaded with the core purpose and efficiently adds the optional filter detail in a single, clear sentence. Every word contributes to understanding without redundancy, making it appropriately sized and well-structured.

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

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

Given the tool's low complexity (1 optional parameter, no output schema, no annotations), the description is adequate for basic usage but incomplete. It does not cover return values, error handling, or behavioral context, which are needed for full agent understanding. It meets minimum viability but has clear gaps.

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

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

Schema description coverage is 100%, so the schema already documents the single optional parameter. The description adds minimal value by giving examples of keywords ('accel', 'steps', 'max_rate'), which slightly clarifies usage but does not provide deep semantic insights beyond the schema. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the specific action ('Get all') and resource ('FluidNC/Grbl machine settings'), and distinguishes it from siblings by focusing on settings retrieval rather than operations like jogging, running programs, or managing files. It precisely defines the tool's scope.

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

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

The description provides clear context for usage by mentioning the optional keyword filter, which helps guide when to use it (e.g., to narrow down settings). However, it does not explicitly state when not to use it or name alternatives among siblings, such as get_machine_status or get_system_info, leaving some ambiguity.

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 the tool is for 'real-time' status, implying it's a read operation, but doesn't disclose behavioral traits like whether it requires specific permissions, rate limits, network latency effects, or error conditions (e.g., if machine is offline). For a tool with zero annotation coverage, this is a significant gap in 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 a single, efficient sentence that front-loads the purpose and lists specific data points. Every word earns its place with no redundancy or fluff, making it highly concise and well-structured for quick understanding.

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 (real-time machine monitoring), no annotations, and no output schema, the description is incomplete. It lacks details on return format (e.g., structured data vs raw text), error handling, or operational constraints. For a tool that likely involves dynamic, time-sensitive data, more context is needed to ensure proper agent 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 input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description adds no parameter information, which is appropriate. Baseline is 4 for zero parameters, as it doesn't need to compensate for any schema gaps.

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 'Get' and the resource 'real-time CNC machine status', specifying the exact data returned (position, state, feed rate, spindle speed, and overrides). It distinguishes from siblings like 'get_machine_settings' (likely static config) or 'get_gcode_state' (program state), though not explicitly. However, it doesn't fully differentiate from all siblings (e.g., 'get_system_info' might overlap), so it's not a perfect 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 provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., machine must be powered on), exclusions (e.g., not for historical data), or compare to siblings like 'get_machine_settings' or 'get_system_info'. The context is implied (real-time status), but explicit usage rules are absent.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states this is a read operation ('View'), implying non-destructive behavior, but doesn't address other aspects like error conditions (e.g., what happens if the macro doesn't exist), authentication needs, rate limits, or output format. The description is minimal and lacks critical operational 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, efficient sentence that directly states the tool's function without unnecessary words. It is front-loaded with the core action ('View'), making it easy to parse. Every word earns its place, achieving ideal conciseness.

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

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

Given the tool's simplicity (1 parameter, no output schema, no annotations), the description is incomplete. It doesn't explain what 'contents' entail (e.g., code, metadata), potential errors, or how this differs from sibling tools. For a tool with no annotations or output schema, more context is needed to guide effective 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?

The input schema has 100% description coverage, with the single parameter 'name' clearly documented as 'Macro name'. The description adds no additional parameter semantics beyond what the schema provides, such as format examples or constraints. This meets the baseline score when schema coverage is high.

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 with a specific verb ('View') and resource ('contents of a saved macro'), making it immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'list_macros' (which likely lists macro names rather than viewing contents) or 'run_macro' (which executes rather than inspects).

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 doesn't mention prerequisites (e.g., needing an existing macro), exclusions, or comparisons to siblings like 'list_macros' or 'run_macro', leaving the agent to infer usage context independently.

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. It states what information is retrieved but doesn't cover aspects like whether this is a read-only operation, potential performance impacts, error conditions, or response format. For a system info tool, this leaves significant gaps in understanding how it behaves.

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, efficient sentence that front-loads the purpose and lists specific information components. Every word contributes to understanding what the tool does without any wasted text 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?

Given the tool's simplicity (0 parameters, no output schema, no annotations), the description adequately covers what information is retrieved. However, without annotations or output schema, it lacks details on return format, potential errors, or operational constraints, making it minimally complete but with clear gaps for agent 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 tool has 0 parameters with 100% schema description coverage, so the schema fully documents the lack of inputs. The description appropriately doesn't discuss parameters, focusing instead on what information is retrieved, which adds value beyond the empty 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 verb 'Get' and the resource 'FluidNC system information', listing specific components like firmware version, CPU, memory, WiFi, and SD card status. It distinguishes from siblings by focusing on system-level data rather than configuration, macros, or machine control, though it doesn't explicitly differentiate from similar tools like get_machine_settings or get_machine_status.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, timing, or compare it to sibling tools like get_machine_settings or get_machine_status, leaving the agent to infer usage context based on the tool name alone.

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

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

With no annotations provided, the description carries full burden. It discloses the safety behavior (raising Z first) and execution flow, but doesn't mention potential risks (e.g., collisions if safeZ is too low), machine state requirements (e.g., must be unlocked), or what happens after completion. It adds some context but lacks comprehensive behavioral details.

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, efficient sentence that front-loads the core purpose and sequentially lists the key steps. Every word earns its place with no redundancy or fluff.

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

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

For a tool with 3 parameters, 100% schema coverage, and no output schema, the description is adequate but has gaps. It explains the safety sequence but doesn't cover error conditions, machine state dependencies, or what 'work coordinate zero' means contextually. It's minimally viable but could be more complete given the operational complexity.

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 fully documents all three parameters. The description doesn't add any parameter-specific meaning beyond what's in the schema (e.g., it doesn't explain why safeZ defaults to 10mm or typical feedRate values). Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the specific action ('Move to work coordinate zero') and details the sequence of operations (raises Z, moves XY, lowers Z). It distinguishes itself from siblings like 'set_zero' (which likely sets the zero point) and 'home_axes' (which homes to machine coordinates).

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

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

The description implies usage when needing to move to the work zero coordinate safely, but doesn't explicitly state when to use this versus alternatives like 'jog' for manual movement or 'set_zero' for defining the zero point. No exclusions or prerequisites are mentioned.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the homing action but lacks details on safety implications, whether it's destructive to current positions, required machine state, or potential errors. For a tool that likely involves physical movement, 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 extremely concise and front-loaded: the first sentence states the core action, and the second adds crucial detail about parameters. Every word earns its place with no redundancy or fluff.

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

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

Given no annotations and no output schema, the description is minimally complete for a simple tool with one optional parameter. However, it lacks details on behavioral aspects like safety, machine state requirements, or what happens after homing, which are important for a physical operation tool in this context.

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

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

The description adds meaningful context beyond the input schema: it explains that the 'axes' parameter is optional (defaults to all) and clarifies the purpose of specifying individual axes. With 100% schema description coverage, the baseline is 3, but the description enhances understanding of default behavior, warranting a higher score.

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: 'Run homing cycle' specifies the action, and 'Homes all axes by default, or specify individual axes' clarifies the resource and scope. It distinguishes from siblings like 'go_to_zero' or 'set_zero' by focusing on homing rather than positioning, though it doesn't explicitly name alternatives.

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

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

The description implies usage context by mentioning default behavior (homes all axes) and the option to specify individual axes, but it doesn't explicitly state when to use this tool versus alternatives like 'unlock_machine' or 'soft_reset' for machine preparation. No exclusions or prerequisites are mentioned.

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

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

With no annotations provided, the description carries full burden. It discloses the incremental mode behavior ('Uses incremental mode ($J=G91)'), which is valuable context beyond basic parameters. However, it doesn't mention safety considerations, machine state prerequisites, or what happens during execution (e.g., whether motion is immediate or queued).

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 concise sentences front-load the core functionality and technical detail with zero wasted words. Every sentence adds value: the first defines the action, and the second specifies the operational 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?

For a tool with 3 parameters, 100% schema coverage, and no output schema, the description is minimally adequate. It covers the purpose and mode but lacks details on error conditions, machine state requirements, or output expectations, which would be helpful given the tool's potential safety implications.

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 fully documents parameters. The description adds no additional parameter semantics beyond implying axis movement and incremental mode, which aligns with but doesn't exceed schema details. Baseline 3 is appropriate as the schema handles parameter documentation.

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 specific action ('jog'), target resource ('CNC machine'), and method ('along an axis by a specified distance at a given feed rate'), with technical detail ('Uses incremental mode ($J=G91)') that distinguishes it from other movement tools like 'go_to_zero' or 'home_axes'.

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 is provided on when to use this tool versus alternatives like 'go_to_zero' (absolute positioning) or 'home_axes' (homing operation). The description implies usage for incremental movement but doesn't specify scenarios 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action but doesn't describe what 'list' entails—e.g., format of output, pagination, sorting, or any side effects. This leaves gaps for an AI agent to understand how to interpret results.

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, clear sentence with no wasted words. It's front-loaded and efficiently conveys the core purpose, making it easy for an agent to parse quickly.

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

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

Given the tool's simplicity (0 params, no output schema, no annotations), the description is minimally adequate. It states what the tool does but lacks details on behavior or output, which could be improved for better agent understanding in this context of configuration management.

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 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add param info, which is appropriate, but it could hint at implicit filters or options. Baseline is 4 for zero params, as it avoids redundancy.

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 ('List') and resource ('all saved configuration backups'), making the purpose unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'list_macros' or 'list_sd_files' beyond the resource type, which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'restore_config' or 'backup_config', nor does it mention prerequisites or context for listing backups. It's a basic statement of function without 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 provided, the description carries the full burden of behavioral disclosure. It states what the tool does but lacks details on traits like whether it requires authentication, has rate limits, returns paginated results, or affects machine state. For a tool with zero annotation coverage, this is a significant gap in 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 a single, clear sentence with no wasted words. It front-loads the key information ('List all saved CNC macros') efficiently, making it easy to parse and understand quickly.

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

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

Given the tool's simplicity (0 parameters, no output schema) and lack of annotations, the description is minimally adequate. It states the purpose but doesn't cover behavioral aspects like return format or operational constraints. For a basic list tool, this is acceptable but leaves room for improvement in 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?

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately doesn't discuss parameters, focusing on the tool's purpose. This aligns with the baseline for zero parameters, though it doesn't add extra semantic value 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 action ('List') and resource ('all saved CNC macros'), making the purpose unambiguous. It distinguishes from siblings like 'get_macro' (which retrieves a specific macro) by implying a comprehensive listing. However, it doesn't explicitly contrast with other list tools like 'list_backups' or 'list_sd_files', keeping it from a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, such as needing the machine to be in a certain state, or compare it to other tools like 'get_macro' for specific macro retrieval. This lack of context leaves usage unclear.

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. It states the action but doesn't describe key traits like whether this is a read-only operation (implied by 'List'), potential errors (e.g., invalid path, SD card not present), rate limits, or the format of the output (e.g., list structure, file details). This leaves significant gaps for a tool interacting with 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 a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is front-loaded and earns its place by clearly conveying the core functionality, making it highly concise and well-structured.

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

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

Given the complexity of interacting with a CNC controller's SD card and the lack of annotations and output schema, the description is incomplete. It doesn't cover behavioral aspects like error handling, output format, or system dependencies, which are crucial for safe and effective use in this hardware context. The description alone is insufficient for a tool with potential operational impacts.

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 100% description coverage, with the 'path' parameter documented as 'Directory path on SD card (default: root)'. The description adds no additional meaning beyond this, as it doesn't explain path syntax, constraints, or examples. With high schema coverage, the baseline score of 3 is appropriate, as the schema handles the parameter documentation adequately.

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 ('List') and resource ('files and directories on the CNC controller's SD card'), providing a specific action and target. However, it doesn't explicitly differentiate from sibling tools like 'list_backups' or 'list_macros', which also list different resources, so it misses full sibling distinction.

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 is provided on when to use this tool versus alternatives. The description lacks context about prerequisites, such as whether the SD card must be mounted or accessible, and doesn't mention any exclusions or related tools like 'upload_to_sd' or 'delete_sd_file' for file management operations.

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 discloses key behavioral traits: the tool has a default dry-run mode for safety, requires explicit confirmation to apply changes, and restores from a backup file. However, it lacks details on potential side effects (e.g., machine downtime, error handling) or response format, which would be useful for a mutation tool.

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

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

The description is front-loaded with the core purpose in the first sentence, followed by critical usage details in the second. Every sentence earns its place by providing essential information without redundancy, making it highly efficient and easy to parse.

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

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

Given the tool's complexity (a mutation operation with safety features), no annotations, and no output schema, the description is mostly complete. It covers purpose, usage, and key parameters, but could improve by mentioning potential impacts (e.g., machine state changes) or error scenarios, which would enhance safety and predictability for the agent.

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 both parameters. The description adds value by explaining the semantics of 'confirm': it controls whether changes are applied (true) or it's a dry run (false), which clarifies the parameter's role beyond the schema's technical description. It doesn't add details for 'filename', but the schema covers it well.

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 ('Restore') and resource ('machine settings from a backup'), making the purpose specific and unambiguous. It distinguishes itself from sibling tools like 'backup_config' (which creates backups) and 'list_backups' (which lists them), establishing a unique role in the toolset.

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

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

The description explicitly states when to use this tool: 'Defaults to dry-run mode showing what would change. Requires confirm=true to actually apply.' This provides clear guidance on the default behavior and the condition needed for actual restoration, helping the agent decide based on the desired outcome (preview vs. apply).

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions sending G-code 'one line at a time' and the confirm requirement, which adds some context about execution flow and safety. However, it doesn't cover critical aspects like potential destructive effects (e.g., machine movement), authentication needs, rate limits, or error handling, leaving significant gaps for a tool that interacts with physical machinery.

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 that directly state the tool's function and key requirement. Every word earns its place, and it's front-loaded with the core action, making it efficient and easy to parse without any 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?

Given the complexity of interacting with a machine via G-code and the lack of annotations and output schema, the description is incomplete. It doesn't explain return values, error conditions, safety implications, or how the 'one line at a time' execution affects behavior. For a tool with potential physical consequences, more context is needed to ensure safe and correct 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?

Schema description coverage is 100%, with clear descriptions for both parameters ('gcode' as 'Multi-line G-code program' and 'confirm' as 'Must be true to execute'). The description adds minimal value beyond the schema by reinforcing the confirm requirement, but doesn't provide additional syntax, format details, or examples. This meets the baseline for high schema coverage.

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

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

The description clearly states the action ('Send a multi-line G-code program to the machine') and the resource ('G-code program'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'send_gcode' or 'run_macro', which might handle similar operations, leaving room for ambiguity in distinguishing exact use cases.

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 some context by stating 'Requires confirm=true', which implies a prerequisite for execution, but it doesn't offer explicit guidance on when to use this tool versus alternatives like 'send_gcode' or 'run_macro'. The usage is implied through the confirm requirement, but lacks clear when/when-not scenarios or named alternatives.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals the preview/confirmation workflow and parameter override capability, which are valuable behavioral traits. However, it doesn't address important aspects like whether this is a destructive operation, what permissions are needed, potential side effects on the machine, or error handling for invalid macros.

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) and front-loaded with the core purpose. Every sentence adds value: the first states what the tool does, the second explains the confirmation workflow and parameter behavior. There's zero wasted text 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 tool that executes potentially complex machine operations with no annotations and no output schema, the description is somewhat incomplete. It covers the basic workflow but doesn't address safety considerations, error conditions, or what the preview shows. Given the context of machine control tools and potential for destructive operations, more behavioral context would be helpful.

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 100% schema description coverage, the schema already documents all three parameters thoroughly. The description adds minimal value beyond the schema by mentioning that parameters can override defaults, but doesn't provide additional context about parameter format, validation, or examples. This meets the baseline for high schema coverage.

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

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

The description clearly states the action ('Execute a saved macro') and resource ('macro'), making the purpose immediately understandable. It distinguishes from siblings like 'save_macro' or 'delete_macro' by focusing on execution rather than creation or deletion. However, it doesn't explicitly differentiate from 'run_gcode_program' or 'run_sd_file' which are also execution 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?

The description provides clear context about the two-step process ('Shows preview first; set confirm=true to run'), which implicitly guides when to use this tool versus alternatives. However, it doesn't explicitly state when to choose this over other execution tools like 'run_gcode_program' or 'run_sd_file', nor does it mention any prerequisites like requiring a saved macro to exist.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the 'confirm=true' requirement, which is a critical safety or permission constraint, but does not address other potential behaviors such as whether this action is destructive (e.g., starts machine motion), requires specific machine states, or has side effects like pausing other operations. This leaves significant gaps for a tool that likely controls physical machinery.

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, efficient sentence that front-loads the core purpose and includes the essential constraint ('Requires confirm=true') without any wasted words. Every part of the sentence earns its place by providing necessary information.

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

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

Given the complexity of running G-code on a CNC machine (a potentially destructive action), the description is incomplete. With no annotations and no output schema, it lacks details on safety implications, machine state requirements, or return values. However, it does cover the basic purpose and a key parameter constraint, making it minimally adequate but with clear gaps for such a high-stakes 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 100%, so the schema already fully documents both parameters ('filepath' and 'confirm'). The description adds value by emphasizing that 'confirm=true' is required, but does not provide additional semantic context beyond what the schema states (e.g., why confirmation is needed or filepath format details). This meets the baseline for high schema coverage.

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

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

The description clearly states the specific action ('Run a G-code file') and resource ('from the CNC controller's SD card'), distinguishing it from siblings like 'run_gcode_program' (which likely runs from memory) or 'send_gcode' (which sends individual commands). It precisely identifies what the tool does without being vague or tautological.

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 by specifying that it runs from the SD card, implying usage when files are stored there rather than in memory. However, it does not explicitly state when not to use it (e.g., vs. 'run_gcode_program' for in-memory programs) or name alternatives, keeping it from a perfect score.

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 but only mentions parameter substitution syntax. It lacks critical behavioral details: whether this is a mutation (implied by 'Create or update'), permission requirements, side effects (e.g., overwriting existing macros), error handling, or response format. This is inadequate for a tool with potential destructive impact.

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, efficient sentence that front-loads the core purpose ('Create or update a macro') and adds a useful detail about parameter syntax. There's no wasted text, though it could be slightly more structured for clarity.

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

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

For a mutation tool with no annotations and no output schema, the description is incomplete. It fails to address key aspects: behavioral traits (e.g., idempotency, error conditions), output expectations, or usage context relative to siblings. The parameter syntax hint is helpful but insufficient for safe and effective 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?

Schema description coverage is 100%, so the schema fully documents all parameters. The description adds minimal value by explaining parameter substitution syntax ('{param_name}'), which relates to the 'parameters' field but doesn't elaborate beyond what the schema provides. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the action ('Create or update') and resource ('a macro'), distinguishing it from sibling tools like 'delete_macro' or 'run_macro'. However, it doesn't explicitly differentiate from 'get_macro' or explain the create vs update logic, keeping it from a perfect score.

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

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

No guidance is provided on when to use this tool versus alternatives like 'delete_macro' or 'run_macro'. The description mentions parameter substitution syntax but doesn't clarify use cases, prerequisites, or exclusions, leaving the agent without contextual direction.

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. It adds valuable context beyond basic functionality: it mentions safety level auto-classification and the requirement for 'confirm=true' on dangerous commands, which are critical behavioral traits for safe operation. However, it does not cover other aspects like error handling or response format.

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 two sentences with zero waste: the first sentence states the core purpose, and the second adds crucial safety guidance. It is appropriately sized and front-loaded, with every sentence earning its place by providing 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?

Given the complexity of sending commands to a CNC machine, no annotations, and no output schema, the description is fairly complete. It covers safety aspects and parameter usage, but it could benefit from mentioning potential outputs or error conditions. However, for a tool with 2 parameters and good schema coverage, it provides adequate context.

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 both parameters fully. The description adds some meaning by explaining the purpose of the 'confirm' parameter in relation to command safety, but it does not provide additional syntax or format details beyond what the schema provides. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the verb ('send') and resource ('single G-code or Grbl command to the CNC machine'), making the purpose specific. It distinguishes from siblings like 'run_gcode_program' (which likely runs multiple commands) by specifying 'single' command.

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 on when to use the 'confirm' parameter for DANGEROUS/CRITICAL commands, but it does not explicitly state when to use this tool versus alternatives like 'run_gcode_program' or other CNC control tools. The guidance is helpful but lacks sibling differentiation.

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. It describes what the tool does (sets coordinate zero) and the default behavior (all axes if none specified), but doesn't mention potential side effects, safety considerations, or what happens if the machine isn't in the right state. For a CNC/machine control tool with no annotations, this leaves important behavioral aspects uncovered.

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 perfectly concise with just two sentences that each earn their place. The first sentence states the core functionality with technical detail (G10 L20 P1), and the second sentence explains the default behavior. No wasted words, and the most important information is 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 this is a machine control tool with no annotations and no output schema, the description is adequate but has clear gaps. It explains what the tool does and parameter behavior, but doesn't address safety implications, error conditions, or what success/failure looks like. For a tool that modifies machine coordinates, more contextual information would be beneficial.

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 schema already documents the single 'axes' parameter completely. The description adds meaningful context by explaining the default behavior ('If no axes specified, sets all axes to zero'), which helps the agent understand the parameter's practical use beyond the schema's technical specification.

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 specific action ('Set the work coordinate zero'), specifies the resource ('for specified axes at the current position'), and distinguishes it from siblings by mentioning the G10 L20 P1 command. It explicitly differentiates from tools like 'go_to_zero' (which likely moves to zero) versus setting zero at current position.

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 about when to use it ('If no axes specified, sets all axes to zero'), which helps determine appropriate usage. However, it doesn't explicitly state when NOT to use it or mention specific alternatives among the sibling tools (like how it differs from 'home_axes' or 'go_to_zero').

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. It discloses key behavioral traits: it's an emergency action ('Emergency stop'), has immediate effects ('stops all motion and spindle immediately'), and requires confirmation ('Requires confirm=true'). It doesn't mention side effects like resetting other settings or recovery procedures, but covers the critical safety aspects.

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 front-loaded with the core purpose ('Emergency stop — soft reset the controller'), followed by critical details in two concise sentences. Every word earns its place, with no redundant or vague phrasing.

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

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

For a tool with no annotations, no output schema, and 1 parameter, the description is largely complete. It explains the emergency context, immediate effects, and confirmation requirement. It could mention post-reset state or recovery steps, but covers the essential safety and operational aspects well.

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 the 'confirm' parameter. The description adds value by explaining why the parameter exists ('Requires confirm=true to execute emergency stop'), providing context beyond the schema's technical description. With only 1 parameter, this is sufficient for a high score.

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 with specific verbs ('soft reset', 'stops all motion and spindle immediately') and identifies the resource ('controller'). It distinguishes from siblings like 'feed_hold' (temporary pause) or 'spindle_control' (manual control) by emphasizing the emergency nature and immediate stop.

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

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

The description explicitly states when to use this tool ('Emergency stop') and includes a prerequisite ('Requires confirm=true'). It implies when not to use it (non-emergency situations) by contrasting with siblings like 'feed_hold' for pauses or 'spindle_control' for normal operations.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the 'confirm' requirement for turning on, which is a critical safety behavior, but lacks details on other traits like potential risks (e.g., spindle damage if misused), response format, error conditions, or rate limits. For a tool that controls physical hardware with safety implications, 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 extremely concise and front-loaded, consisting of just two sentences that directly state the purpose and a key requirement. Every word earns its place with no redundancy or unnecessary details, making it highly efficient for an AI agent to parse.

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 of controlling physical spindle hardware with safety implications, no annotations, and no output schema, the description is incomplete. It lacks critical information such as response behavior, error handling, prerequisites (e.g., machine state), or warnings about misuse. For a tool in this context, more comprehensive guidance is needed.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal value beyond the schema by mentioning 'CW/CCW with speed' and the confirm requirement, but it doesn't provide additional semantics like speed ranges or action mappings beyond what's in the schema. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose: 'Control the spindle: turn on (CW/CCW with speed) or off.' This specifies the verb ('Control') and resource ('spindle') with specific actions. However, it doesn't explicitly differentiate from sibling tools like 'jog' or 'run_gcode_program' which might also involve machine control, so it doesn't reach the highest score.

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

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

The description provides some usage context with 'Turning on requires confirm=true,' which implies a safety requirement. However, it doesn't offer explicit guidance on when to use this tool versus alternatives (e.g., compared to 'send_gcode' for spindle control via G-code) or mention any prerequisites or exclusions, leaving usage somewhat implied rather than clearly 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions clearing alarm state and unlocking, which implies a state-changing operation, but lacks details on permissions, side effects, or error handling. The description adds basic context but is incomplete for a tool that likely requires caution.

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 front-loaded and concise, consisting of two clear sentences that directly state the action and usage condition without redundancy. Every word serves a purpose, making it easy to parse and understand quickly.

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

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

Given the tool's complexity (state-changing operation with no annotations or output schema), the description is minimally adequate. It covers the basic purpose and usage but lacks details on behavioral traits like safety implications or response format, leaving gaps for an AI agent to infer.

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 parameters with 100% coverage, so no parameter documentation is needed. The description adds value by explaining the tool's context ('after an alarm condition'), which compensates for the lack of parameters. No semantic gaps exist, but the description doesn't need to detail parameters.

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

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

The description clearly states the tool's purpose with a specific verb ('Clear alarm state and unlock') and resource ('the machine'), distinguishing it from siblings like 'soft_reset' or 'cycle_resume' by focusing on post-alarm recovery. It explicitly mentions the trigger condition ('after an alarm condition'), making the purpose unambiguous.

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

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

The description provides explicit usage guidance by stating 'Use after an alarm condition,' which clearly indicates when to invoke this tool versus alternatives. It implies this is not for general unlocking but specifically for clearing alarms, differentiating it from other control tools like 'home_axes' or 'go_to_zero'.

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 full burden for behavioral disclosure. While 'upload' implies a write operation, the description doesn't address important behavioral aspects like whether this overwrites existing files, what permissions are required, whether there are file size limits, or what happens on failure. This is a significant gap for a write operation 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, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded with the core functionality.

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 file upload tool with no annotations and no output schema, the description is insufficient. It doesn't address critical context like what happens on success/failure, whether files are overwritten, file size limitations, or expected response format. The combination of a write operation with minimal behavioral disclosure creates significant gaps.

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

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

Schema description coverage is 100%, so the schema already fully documents all three parameters (filename, content, path). The description doesn't add any additional parameter semantics beyond what's in the schema, such as file format restrictions, content encoding requirements, or path validation rules.

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

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

The description clearly states the action ('upload a file') and target resource ('to the CNC controller's SD card'), providing a specific verb+resource combination. However, it doesn't distinguish this tool from potential sibling operations like 'run_sd_file' or 'delete_sd_file' beyond the basic upload action.

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 is provided about when to use this tool versus alternatives. The description doesn't mention prerequisites, when this operation is appropriate, or what other tools might be used for related SD card operations (like listing or deleting files).

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