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

Annotations already indicate readOnly, idempotent, non-destructive behavior. The description adds value by detailing the return structure and giving a concrete example, which enhances transparency 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?

The description is extremely concise: two sentences plus an example and a cross-tool reference. It front-loads the purpose and contains no extraneous 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 simple computational tool with 2 inputs and 4 outputs, the description covers all aspects: purpose, inputs, output structure, example, and a hint for post-processing. It feels complete without needing additional 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 coverage is 100%, so the schema already documents both parameters. The description mentions the default for impedance_ohm, but this adds little beyond the schema. The example helps illustrate usage but does not significantly deepen parameter understanding.

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 designs T-pad and Pi-pad resistive attenuators, specifying inputs (attenuation, impedance) and output structure. It distinguishes from sibling tools (e.g., embedcalc_eseries_nearest) by its unique purpose.

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 when to use the tool (designing attenuators) and even suggests a related tool for snapping values. However, it does not explicitly state when not to use it or list alternatives.

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

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

Annotations indicate read-only and idempotent. Description adds detailed behavioral traits: loop resistance calculation (2× length), temperature compensation, verdict thresholds. Exceeds 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?

Concise, front-loaded with purpose, then args, returns, and example. Every sentence is informative with no wasted words.

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

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

Given output schema exists but not shown, description fully covers return structure. For a single-purpose calculator, all necessary context is provided.

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 covers 100% of parameters with descriptions. Description adds meaning beyond schema by clarifying length_m is one-way and loop is 2×, and gives example values. Adds context without 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?

Clearly states it computes AWG wire properties and round-trip voltage drop, with specific outputs listed. Distinguishes from siblings by naming the exact resource and computation.

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

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

Provides example usage and clearly describes inputs/outputs, but does not explicitly state when to use this tool versus related tools like embedcalc_pcb_trace_width. However, the specificity makes context clear.

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

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

Annotations already declare readOnly, idempotent, and non-destructive behavior. The description adds valuable context about the return structure (dec, hex, bin, etc.) and provides an example, which enhances transparency 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?

The description is very concise: 5 lines plus args, front-loaded with the core purpose. Every sentence adds necessary information 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, the description, schema, annotations, and output schema together provide complete context. The example and return field list ensure an agent can 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?

Schema coverage is 100% with parameter descriptions. The description adds value by providing an example ('0x8001') and noting the default for macro_name, going 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 it decomposes a 32-bit register value into set bits and generates a C macro, with explicit verb and resource. This distinguishes it from sibling tools like resistor_code or uart_baud.

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 an example but does not explicitly state when to use this tool versus alternatives. The purpose is implied but lacks direct guidance on context 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?

Beyond annotations (readOnly, idempotent, non-destructive), the description discloses the search algorithm, tie-breaking rules, register encoding (BRP/TS 1-based, subtraction already applied), and null handling for no exact divisor. No contradiction with 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?

Well-structured with purpose first, then algorithm, arguments, return type, examples, and warning. Slightly long (~150 words) but justified by complexity; only minor redundancy in register encoding explanation.

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?

Comprehensive for a multi-controller timing calculator: covers algorithm, tie-breaking, register format, null returns, and example usage. Output schema exists, so return fields are not required in description. No gaps for 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 coverage is 100% but description adds value: explains clock_hz per controller type (APB1 vs kernel vs Fosc), bitrate up to 1 Mbps for classic CAN, and sample_point_percent with CiA 301 recommendation (87.5). Examples illustrate realistic parameter values.

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 'Compute exact CAN bit timing' and specifies three target controllers (STM32 bxCAN, FDCAN, MCP2515), distinguishing it from sibling calculation tools like embedcalc_spi_timing or embedcalc_uart_baud.

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

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

Explicitly describes when to use (exact timing from clock, bitrate, sample point), what the algorithm does (searches all combinations, ties broken by TQ then BRP), and what null returns mean (change clock/bitrate). Warns 'Do not guess CAN timing registers — call this tool.'

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

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

Discloses that the generated code embeds a check value for verification, and that it returns a structured object with check_hex, config, and c_code. Annotations (readOnlyHint, idempotentHint, destructiveHint) are consistent and not contradicted.

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

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

Well-structured with clear sections: main purpose, usage, args, returns, examples. Every sentence adds value; no 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 the tool's complexity (7 params, custom vs preset logic) and that an output schema exists, the description covers all necessary details: behavior, parameters, return format, and examples.

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?

While schema already covers 100% of parameters, the description adds meaningful context: explains the Rocksoft model, shows examples like poly_hex '0x1021', and clarifies that preset overrides all other args.

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

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

The description clearly states it generates a complete C implementation for CRC-8/16/32, including the standard check value. It uses specific verbs and resources, and distinguishes from other sibling embedcalc tools.

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

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

Explicitly tells when to use a preset vs custom parameters, provides examples like 'MODBUS RTU CRC in C' mapping to 'CRC-16/MODBUS', and warns not to estimate CRCs but to call this tool.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds value by explaining the formula, output structure, and consequences of incorrect input (frequency pulling). No contradiction with annotations.

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

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

The description is concise: two sentences plus an example and warning. It is front-loaded with the formula and purpose, with no redundant information.

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

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

Given the tool's simplicity, the description covers input, formula, output structure, example, and a warning. An output schema exists (not shown) but the description already indicates the return value format. Complete for the 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?

Input schema coverage is 100% with descriptions for both parameters. The description adds context with example values (e.g., 18 pF, stray typ. 3-5) and explains the formula, enhancing understanding 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 it computes external load capacitors for a crystal using a specific formula. The verb 'compute' and resource 'external load capacitors' are specific. It distinguishes itself from sibling calculators (e.g., other embedcalc tools) by focusing on crystal load capacitance.

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 an example and warns about frequency pulling from wrong values, implying use when designing crystal oscillator circuits. However, it does not explicitly state when not to use or name alternative tools, though no siblings overlap functionally.

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 aligns with annotations (readOnlyHint, idempotentHint, destructiveHint) by presenting the tool as a calculation function with no side effects. It adds behavioral context: returns structured output, operates in CCM, and requires specific inputs. No contradictions.

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

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

The description is concise, with a clear purpose statement, a parameter list, output format, and an example. Every sentence adds value. Slightly more structured formatting could improve readability, but it is effective.

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 (7 parameters, multiple topologies) and the presence of output schema, the description covers purpose, all parameters, outputs, and an example. It is sufficiently complete for an agent to use correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by listing arguments compactly with defaults, explaining ripple_current_pct as a percentage of Iout, and providing a concrete example that clarifies units and expected values. This enriches the schema information.

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

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

The description clearly states it calculates duty cycle, minimum inductance, capacitance, input current, and peak switch current for buck, boost, or inverting buck-boost converters. It specifies the operating mode (CCM) and distinguishes it from other embedcalc tools that handle different domains like resistors or wire.

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 does not explicitly state when to use this tool versus alternatives, nor does it provide exclusion criteria (e.g., for DCM). However, it gives a concrete example and references a sibling tool (embedcalc_eseries_nearest) for rounding, implying a workflow. This is adequate but not explicit.

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

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

Annotations already indicate read-only and idempotent. The description adds that odd nibble counts get a leading zero, and the return includes null for mid-big when <4 bytes, which is useful behavioral detail 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?

The description is three sentences: purpose, argument details, example and use case. Every sentence adds value, no 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?

The tool is simple with one parameter and structured output. The description covers input format, output fields (including null case), and a real-world usage scenario. Output schema exists but description complements it 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?

The schema already describes the 'hex' parameter. The description adds examples ('0x12345678' or 'DEADBEEF') and clarifies handling of odd nibble counts, providing meaningful extra context.

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

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

The description clearly states the tool converts a hex byte sequence into all endianness orderings, listing specific outputs (big, little, mid-little, mid-big) and giving an example. This distinguishes it from sibling calculators.

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 ends with 'Useful for Modbus register order and mixed-endian protocol debugging', providing clear usage context. No explicit when-not-to-use, but the tool's purpose is specific enough among siblings.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds further detail: 'Returns (structured): { standard, error_percent, series }' and an example showing output. No contradictions. The description provides all necessary behavioral context 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?

The description is succinct: three sentences covering purpose, arguments, return structure, example, and usage note. Front-loaded with the core action. No unnecessary words.

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

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

Given the simplicity of the tool (2 parameters, output schema exists), the description is complete. It explains what the tool does, when to use it, how parameters map, what output looks like, and includes a practical example. Nothing is missing.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value beyond schema: 'value (any unit — ohms, farads, henries)' clarifies unit flexibility, and 'series ('E24' default; E96 for 1% resistors)' explains the enum meaning. This extra context helps the agent use parameters correctly.

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 function: 'Snap a computed resistor/capacitor/inductor value to the nearest purchasable E-series standard value.' This is a specific verb-resource pair and distinguishes the tool from sibling tools like embedcalc_find_component or embedcalc_resistor_code.

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 includes explicit guidance: 'LLMs frequently pick non-existent standard values — always snap computed values with this tool before choosing a part.' This tells the agent when to use the tool (after computation, before part selection) and implies not to use it when already having a standard value. While it does not list alternatives, the context is clear.

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

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

Discloses internet requirement, intentional omission of pricing, and dependent parameter meanings. Aligns with annotations (readOnlyHint, etc.) without contradiction.

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

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

Well-structured with Args, Returns, and Examples sections. Front-loaded with purpose, no redundant sentences.

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 all essential aspects: purpose, parameters with examples, output format, and behavioral notes. Annotations and schema complement 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?

Adds significant meaning beyond 100% schema coverage, especially for the 'value' parameter and filter parameters with type-specific explanations and examples.

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 function: finding real, in-stock components via parametric search and returning MPNs and buy links. It specifies component types and distinguishes itself from sibling calculation 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?

Provides clear usage context with examples and notes on intended use (e.g., no pricing). Lacks explicit when-not-to-use or alternatives, but sibling tools are all different calculation utilities.

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 indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description reinforces this by describing a pure computation and adds context about the estimate nature and verification recommendation, which is valuable beyond structured fields.

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

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

The description is well-structured with clear sections for Args, Returns, and an Example. It is reasonably concise, though slightly verbose in listing Args compared to schema. Every sentence adds value.

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

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

Given the complexity of I2C timing calculations and the presence of an output schema, the description fully explains inputs, outputs, and an example. It is complete for an agent to correctly invoke the tool and understand its results.

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 baseline is 3. The description rephrases parameters and adds an example with typical values, providing slight additional value over the schema. It does not introduce entirely new semantics.

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

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

The description clearly states it computes I2C pull-up resistor range, SCL timing budget, and STM32 TIMINGR register estimate. The verb 'Compute' and specific resources ('Rp min/max', 'SCL high/low', 'TIMINGR') make the purpose unambiguous. Among sibling calculators, this is distinct as the only I2C timing tool.

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 an example, lists arguments, and notes that the TIMINGR value is an estimate requiring production verification. However, it does not explicitly state when not to use this tool or compare to other calculators, which is acceptable for a specialized calculator.

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 provide readOnlyHint, idempotentHint, and destructiveHint. The description adds value by explaining the formula and the structured return format, which is beyond what annotations convey. It does not contradict annotations.

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

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

The description is concise with three sentences plus an example, front-loaded with purpose and formula. Every sentence adds value without unnecessary verbosity.

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 has few parameters, an output schema, and comprehensive annotations, the description covers all essential aspects: input purpose, formula, default, example output. No gaps remain.

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

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

Schema coverage is 100%, and the description adds meaningful context: the formula relating parameters and an example. The default for channels is also mentioned, which the schema also specifies, but the description provides practical interpretation.

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 calculates I2S bit clock from audio format, including the formula and an example. It uniquely identifies the tool among siblings, which are all different calculator 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 context for when to use the tool (to calculate BCLK from audio format) but does not explicitly state when not to use it or name alternatives. However, given the sibling tools are all distinct calculators, the usage context is clear.

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 mark the tool as read-only and idempotent. The description adds behavioral details: the return structure includes sign, exponent, fraction, hex, bin, decimal string (with NaN/Infinity), and classification. It also warns about non-exact representation with an example (0.1 double). No contradiction with annotations.

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

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

The description is extremely concise: two short paragraphs plus a third for the return structure and examples. It front-loads the core purpose, then covers parameters, then output. No redundant sentences; every sentence adds 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 presence of an output schema (context 'Has output schema: true'), the description does not need to fully explain return values but still lists the key fields. It covers parameter constraints (exactly one input) and provides examples, making the tool fully usable without external documentation.

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

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

Schema coverage is 100% with descriptions for all four parameters. The description adds value by explaining the mutual exclusivity constraint ('Provide exactly one of decimal/hex/bin') and giving format examples (e.g., '0x3F800000'). This aids correct invocation beyond 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?

The description clearly states 'Encode/decode IEEE 754 single (32-bit) or double (64-bit) precision: decimal <-> hex <-> binary' with a specific verb ('encode/decode') and resource ('IEEE 754 single/double precision'). It distinguishes from sibling tools like 'embedcalc_number_base_convert' by focusing on IEEE 754 representation.

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

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

The description explicitly says 'Provide exactly one of: decimal (number), hex (string like '0x3F800000'), bin (bit string)' and advises 'Do not eyeball float bit patterns — call this tool', indicating appropriate use cases. However, it does not explicitly state when not to use it versus alternative embedcalc 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?

Annotations already declare read-only, idempotent, non-destructive behavior. The description adds the computational formula and return structure, providing useful behavioral context 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?

Two concise sentences plus an example. No redundant information. Front-loaded with the core formula.

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 full schema coverage, output schema description, and annotations, the description is complete. It includes the formula, parameter list, return structure, and an example.

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

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

Input schema covers all parameters with descriptions (100% coverage). The description further explains each parameter's role and provides a default for tj_max_c, adding 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?

Description clearly states it computes junction temperature and maximum dissipable power using a standard thermal formula. It uniquely identifies the tool among siblings as the only thermal calculation tool.

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 by the formula and examples, but there is no explicit guidance on when to use this tool over alternatives or when not to use it. Given siblings are unrelated, implied usage is acceptable.

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 indicate read-only, idempotent, non-destructive behavior. Description adds the specific output fields (bit_time_us, break_time_us, frame_time_us) and the calculation formula, enhancing transparency 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?

Four sentences efficiently cover purpose, formula, arguments, return structure, and an example. No unnecessary text; every sentence adds value.

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

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

Given the simple two-parameter calculator, the description fully explains inputs, outputs, formula, and example. Output schema existence is reported, but description already covers return fields. No 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 covers both parameters with descriptions. Description adds typical values (9600/19200 baud, 1-8 bytes) and an example, providing useful context 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 it calculates LIN bus timing parameters (bit time, break duration, frame time) and provides the formula. It is distinct from sibling tools which cover other protocols like CAN, I2C, SPI, etc.

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

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

The description implies usage for LIN bus timing calculations, with typical baud rates and data bytes given. It does not explicitly exclude other contexts but the sibling diversity provides clear separation.

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 indicate read-only, idempotent, non-destructive behavior. The description complements this by detailing the formula, default values, return structure, and an example. No contradictions.

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?

Extremely concise: 4 sentences plus an example, with no fluff. The most critical information (purpose, formula, modes, defaults, return, example) is front-loaded 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 output schema exists (though not shown in input), the description adequately covers inputs, modes, and return format. Minor lack of edge case handling (e.g., providing both inputs) but acceptable for a simple calculator.

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

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

Schema coverage is 100%, but the description adds value by clarifying the mutual exclusivity of target_vout and r2_ohm, summarizing defaults, and specifying the return object structure. This goes beyond the schema's property descriptions.

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?

Clearly states it computes R2 from target Vout or Vout from R1/R2 for the LM317 regulator. Provides the formula and explicit verb+resource, distinguishing itself from numerous sibling embedcalc_ 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?

Explains the two modes of operation and the constraint to provide exactly one of target_vout or r2_ohm. Mentions a follow-up tool (embedcalc_eseries_nearest) for rounding, guiding the agent on next steps. Lacks explicit when-not-to-use, but context is sufficient.

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 and idempotentHint, so the description adds value by providing the exact formula, valid range, and output structure. This gives agents deeper understanding of the computation, surpassing what annotations convey.

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: formula, validity conditions, parameter list, return format, and an example, all in a few lines. Every sentence adds value; no redundancy. It is front-loaded with the most critical 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 straightforward nature of a microstrip impedance calculator, the description covers all necessary aspects: formula, valid range, parameter details, output format, and a concrete example. The presence of annotations and output schema further reduces the burden on the description, making it highly 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?

Input schema covers all parameters with descriptions, but the description adds physical context: units (mm), typical values for trace_thickness_mm (1oz = 0.035 mm) and er (FR-4 ≈ 4.2-4.6), and the formula linkage. Since schema coverage is 100%, baseline is 3; the description meaningfully enhances parameter understanding, earning a 4.

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

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

The description clearly states it computes surface microstrip characteristic impedance using the IPC-2141 formula. It distinguishes itself from sibling calculators (e.g., pcb_trace_width) by specifying the specific calculation and providing the formula. The verb 'impedance' and resource 'microstrip' are explicit.

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 includes validity constraints (0.1 < w/h < 2.0, εr < 15), which implicitly guide when to use the tool. However, it does not explicitly compare with siblings or state when not to use it, missing some guidance for an agent to choose among similar calculators.

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 adds significant behavioral details beyond what annotations provide. It explains the spec formula (11 bits/char), the two regimes (fixed above 19200 baud, computed below), and gives example outputs. Annotations already indicate read-only and idempotent, and the description reinforces this with clear, non-mutating behavior.

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

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

The description is very concise, covering the purpose, spec details, parameters, return structure, and an example in just three sentences. It is front-loaded with the main action and well-organized for quick comprehension.

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

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

Given that the tool has only one parameter, a simple output schema, and annotations fully declaring its nature, the description is complete. It includes the return structure and an example, ensuring the agent has all necessary information to invoke the tool correctly.

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

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

The input schema already describes the 'baud' parameter as integer bit/s. The description adds meaning by defining what baud is used for (timing calculation), explaining the spec relationship, and giving example conversions (e.g., 9600 baud yields specific microsecond values). This context enhances the schema's information.

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 that the tool calculates Modbus RTU inter-character (t1.5) and inter-frame (t3.5) silence times, with specific reference to the spec (11 bits/char) and baud rate regimes. It distinguishes itself clearly from sibling calculator tools by specifying the exact protocol and timing parameters.

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: it is for Modbus RTU timing calculations. Although it does not explicitly state when NOT to use this tool or compare with other sibling calculators, the naming and specifics make it obvious when to apply it. No exclusion conditions are given, but it is sufficiently clear for intent.

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 details the mathematical formulas used (e.g., f=1/(0.693·(Ra+2Rb)·C)) and the output structure for both modes. Annotations already indicate idempotent, readOnly, non-destructive behavior, so the description adds transparency about the calculations and return values.

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 very concise, using just three sentences plus an example. It front-loads the purpose and formulas, then details args and returns, and ends with an illustrative example. No unnecessary text, every sentence adds value.

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

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

Despite the tool's simplicity, the description covers the full scope: formulas for both modes, parameter descriptions, return value structure, and an example. With 100% schema coverage, an existing output schema (implied by the description), and clear annotations, the description is complete and leaves no ambiguity.

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 already describes each parameter (e.g., 'Ra in ohms', 'Rb in ohms (astable only)'). The description reinforces this and adds context: it explains that rb_ohm is optional for monostable, gives units like 'e.g. 10e-6' for c_farad, and provides a concrete example. This enhances understanding 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 identifies the tool as an NE555 timer calculator. It specifies astable and monostable modes with formulas. The sibling tools include other embedcalc calculators, but this one is distinctly for NE555 timing, making selection 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 example usage and parameter requirements but does not explicitly state when to use this tool versus alternatives. However, the context of sibling names and the specific IC mention make the intended use obvious. A more explicit guideline could improve clarity.

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 annotations (readOnlyHint, idempotentHint), description adds key behavioral details: 32-bit two's complement, wrap handling, signed reading, and full return structure.

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 with clear structure, but could be slightly more streamlined. No superfluous 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 single-parameter tool with output schema, description covers input format, behavior, and output fields completely.

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

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

Schema coverage is 100% but description adds examples and specific prefix formats, enhancing clarity beyond the schema 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?

Clearly states it converts numbers between decimal/hex/binary/octal with 32-bit two's complement semantics. Distinguished from specialized siblings like embedcalc_ieee754_convert.

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

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

Provides clear context on when to use: for base conversions. No explicit alternatives, but siblings are distinct enough that confusion is unlikely.

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 safe, read-only, idempotent behavior. The description adds value by explaining the non-linear nature of the calculation, the structured return format, and the formula parameters, enhancing transparency 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?

Extremely concise: includes formula, args, returns, and an example in a few sentences. No redundant information.

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

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

Given 4 parameters, high schema coverage, and output schema present, the description is complete. It covers purpose, formula, parameter details, example, and a caution about non-linearity.

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 covers 100% of parameters, but the description adds meaning by explaining the layer types, default values, and the physical meaning of copper_oz. The example clarifies parameter effects.

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?

Clearly states it calculates minimum trace width for current per IPC-2221. Includes the governing formula and distinguishes itself from sibling calculators (e.g., microstrip impedance, resistor code) by its specific purpose.

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

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

Provides explicit usage: 'Do not guess trace widths'. Gives an example and notes that internal layers need ~2x width. While it doesn't explicitly list when not to use, the sibling list implies alternatives, and the context is clear.

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 indicate read-only, idempotent, non-destructive behavior. The description adds valuable detail: the return structure with quantization error, clamping, and two's complement representations. It also warns against manual rounding, disclosing important 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 concise and well-structured: intro, parameter list, return format, examples. Every sentence serves a purpose without redundancy, fitting the tool's complexity.

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 a comprehensive output schema and clear examples, the description fully equips an agent to understand inputs, outputs, and constraints. It covers conversion direction, format rules, and important notes like quantization error.

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

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

Schema coverage is 100% with descriptions. The description adds value by stating the constraint m+n+1 <= 32 and reinforcing the exclusive choice between value and raw_int, which goes beyond the schema's individual min/max constraints.

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

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

The description clearly states 'Convert between float and signed Qm.n fixed point', specifying the verb, resource, and format. It distinguishes itself from sibling tools like IEEE754 converter by focusing on Q-format, 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 clear context on the conversion direction and requirement to provide exactly one of value or raw_int. Examples further clarify usage. However, it does not explicitly address when to use this tool versus alternatives (e.g., for other fixed-point or floating-point conversions), though the name and title already imply its niche.

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 indicate readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the tool is safe and idempotent. The description adds behavioral details beyond annotations: it explains that register_name is sanitized to [A-Z0-9_], that total width must fit in 32 bits, and that the return value includes structured fields with computed shifts and masks. These additions are valuable and do not contradict annotations.

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

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

The description is reasonably concise, with a clear structure: one-sentence summary, then Args, Returns, and Example. It is front-loaded with the main purpose. Every sentence adds value. However, the 'Returns' section could be slightly more compact, but overall it is efficient and well-organized.

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 (2 required parameters, output schema exists), the description covers all aspects: purpose, parameters with constraints, return structure, an example, and a usage directive. The output schema provides return value details, so the description does not need to repeat them. The description is complete for an AI agent to select and invoke the tool correctly.

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

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

Schema description coverage is 100%, but the description adds substantial meaning: it explains what register_name is (e.g., 'CTRL') and its sanitization rule, and it describes the fields array format with an example, clarifying that fields are ordered from LSB upward and that total width must be <= 32 bits. The example further illustrates the mapping. This goes well beyond the schema's basic descriptions.

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: 'Generate C shift/mask #defines and a bit-field typedef struct for a hardware register from an LSB-first field list.' It uses a specific verb ('Generate'), identifies the resource ('C shift/mask #defines and a bit-field typedef struct'), and distinguishes from siblings like embedcalc_bitfield_macro and embedcalc_struct_layout by specifying the input format and output structure.

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

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

The description provides clear context: it tells the agent to use this tool when needing to generate C definitions from an LSB-first field list, includes an example, and explicitly says 'Do not compute shifts/masks by hand — call this tool.' However, it does not explicitly state when NOT to use this tool or mention alternatives, though the sibling list implies differentiation. The usage guidance is strong but lacks explicit exclusions.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds detail on input formats (color names, SMD code variations) and output structure, providing good behavioral context 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?

The description is concise, well-structured with an Args section and examples. Every sentence adds information 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 presence of an output schema and full parameter documentation, the description is complete, covering both through-hole and SMD decoding with examples. No 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 coverage is 100%, but the description adds value by explaining each parameter's format, listing valid color names and SMD code patterns, and providing examples.

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 'decode' and the resource 'through-hole resistor color code or SMD resistor marking', and distinguishes itself from sibling tools which are all different calculators.

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 clearly indicates when to use the tool (to decode resistor codes), but does not explicitly mention when not to use it or provide alternatives; however, siblings are distinct so usage context is clear.

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 adds behavioral context beyond the annotations: it discloses that the result is rounded up to a power of two and provides a computed example. The annotations already indicate idempotent, read-only, non-destructive behavior, so the description complements them well without contradiction.

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 4 sentences, beginning with the core purpose, followed by parameters and an example. It is front-loaded and every sentence contributes meaning. No wasted words.

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

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

The description explains the computation, input parameters, and output structure. The output schema exists and covers return fields, so the description is complete for a calculator tool with this 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 coverage is 100%, so the baseline is 3. The description repeats parameter explanations but adds a concrete example demonstrating usage, which provides slight added value.

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

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

The description uses a specific verb ('Size') and resource ('ring buffer / DMA buffer'), and clearly distinguishes from sibling calculators by stating the computation formula. It is unambiguous and directly states the tool's function.

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

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

The description implies the tool should be used for sizing buffers from data rate and latency, and the sibling tools are all different calculators, so there is no confusion. However, it does not explicitly state when not to use it or mention alternatives, which prevents a 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 confirm readOnly, idempotent, non-destructive behavior. The description adds behavioral context: the rule-of-thumb formula, capping at 1200m, default bias resistor computation, and explicit return structure. This goes beyond the annotations without contradicting them.

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 plus an example, all front-loaded with key information. Every sentence adds value: formula, constraints, parameter details, and a practical illustration. No redundant 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 output schema exists, the description covers all necessary context: input parameters, default behavior, output fields, and an example. It is sufficient for an agent to use the tool correctly.

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

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

Input schema has 100% coverage, but the description adds meaning: it explains the rule of thumb linking baud rate to cable length, states that bias_ohm defaults to computed maximum, and provides an example. This enriches the schema 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 it calculates RS-485 cable length limit and fail-safe bias resistors. It uses specific verb 'calculates' and resource 'RS-485 bus', distinguishing it from sibling tools which cover different domains like CAN, I2C, or wire sizing.

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 by the tool name and domain-specific description, but there is no explicit guidance on when to use this tool versus alternatives. Sibling tools are listed but not compared, so the agent must infer the appropriate 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?

Annotations (readOnlyHint=true, idempotentHint=true, destructiveHint=false) are consistent. Description adds concrete behavior: computes three specific timing values, non-destructive, and returns structured data. Example solidifies understanding.

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 plus an example. Every element is essential: what it does, arguments, default, return format, and a concrete example. No wasted words.

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

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

Given the tool has an output schema (context signal), the description adequately covers inputs, outputs, and usage. For a simple calculator tool, this is complete and self-contained.

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

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

Input schema covers both parameters with descriptions (100% coverage). Description goes beyond by showing a real example (10 MHz, 8 bits yields specific results), which clarifies the meaning and expected outputs.

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?

Clear verb (calculate) and resource (SPI timing) in title and description. Distinguishes from sibling timing tools by specifying 'SPI' and listing exact computed outputs (bit period, frame time, throughput).

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

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

No explicit when-to-use or alternatives guidance. While the tool is self-explanatory for SPI timing, it doesn't mention not to use it for other protocols or compare to siblings like 'embedcalc_i2c_timing'.

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 annotations (readOnlyHint, destructiveHint, idempotentHint), the description explains the computational behavior: it applies 32-bit MCU model rules, returns structured output with offsets, padding, and nesting relative offsets. No contradictions.

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 appropriately sized: two paragraphs front-loading the core purpose and behavior, followed by clear arg/return details. Every sentence adds value.

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

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

Given the complexity of the tool, the description covers input format, supported features, output structure, and a usage warning. The output schema exists, which is not strictly needed but complements the description.

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 'code' has 100% schema coverage, but the description adds meaning by specifying acceptable formats (member declarations or full struct), providing examples, and listing supported constructs (nested, arrays, pointers, bit-fields).

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

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

The description clearly states it computes memory layout of C struct/union, including member offsets, padding, bit-field packing, total size, and alignment. It specifies the target model (ARM Cortex-M style), distinguishing it from all sibling tools which are other calculator types.

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 context on when to use (when accurate memory layout is needed) and includes a warning against guessing sizes. It does not explicitly list alternatives, but no sibling tool serves the same purpose, so exclusion is unnecessary.

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 indicate read-only, idempotent, non-destructive behavior. The description adds computational specifics (e.g., returns mantissa, fraction, hex value, actual baud, error, frame bits, char time) and a practical example. No contradictions.

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

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

The description is well-structured with clear sections (args, returns, rule, example). It is somewhat lengthy but each part adds value. Slightly more concise could be achieved, but overall effective.

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 has an output schema (implied), the description covers all necessary aspects: what it calculates, parameter details, return fields, and a guiding example. It is fully sufficient for an agent to select and invoke correctly.

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

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

Input schema has 100% parameter description coverage. The description adds value beyond schema by giving an example and explaining the meaning of parameters in context (e.g., oversampling, parity). It does not repeat schema verbatim but clarifies 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 clearly states it computes the BRR register, actual baud rate, error percentage, frame size, and character time for STM32 USART. It specifies the resource (BRR register) and distinguishes from sibling embedcalc tools which cover different calculations.

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

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

Provides a rule of thumb for acceptable error and an example usage. However, it does not explicitly state when not to use it or mention alternatives. The context makes it clear it's for STM32 USART baud calculation, but could be slightly more explicit.

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