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

No annotations are provided, so the description carries the full disclosure burden. For a pure arithmetic operation the absence of side effects is self-evident, but the description says nothing about return format, precision, or numeric limits, so it adds little behavioral 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?

Two short sentences with zero waste; the core operation is front-loaded before the alternative-usage note.

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 trivial two-argument pure function with a fully described schema, the description is nearly sufficient. The only gap is that no output schema exists and the description never states what is returned.

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% and both parameters are documented as 'the first/second addend', so the schema does the heavy lifting. The description adds no syntax, format, or constraint detail beyond what the schema already states.

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

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

States a specific verb and resource with exact arity: 'Adds two numbers.' An agent can immediately tell this is a binary addition operation, not a list/aggregate or chained computation, and the description pre-empts confusion with the batch_calc sibling.

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 routes multi-step or chained work to batch_calc, which is a concrete when-to-use-else rule. However, it does not address the closely related 'sum' sibling (aggregate over a list), leaving a real ambiguity unresolved.

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 burden; it usefully discloses that the return is in radians, which is the key behavioral fact for a trig function. It omits the domain restriction [-1, 1] and what happens for out-of-range input, leaving a real but modest gap for a pure math function with no side effects.

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

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

Two short sentences, zero waste: the core behavior plus its unit is front-loaded, and the batch_calc pointer follows. Nothing is repeated from the schema.

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, side-effect-free math function with no output schema, stating the result unit and the batch alternative is nearly sufficient. The one missing element is the accepted input range, which an agent could otherwise stumble on.

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% and there is a single parameter already documented as 'The number to find the arccosine of'; the description adds no syntax, range, or format detail beyond that. Baseline 3 applies since the schema does the heavy lifting and the description does not compensate for the missing domain constraint.

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

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

States a specific verb (calculates) and resource (arccosine of a number), and disambiguates the result unit with '(in radians)' — meaningful given siblings like degreesToRadians and radiansToDegrees. The function name plus unit makes it distinguishable from arcsin/cos/tan without opening the schema.

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

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

Explicitly routes multi-step or multi-operation work to batch_calc, which is a clear alternative-selection rule. It does not state exclusions or prerequisites (e.g., input must be in [-1, 1]), so it stops short of full when/when-not guidance.

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

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

No annotations are provided, so the description carries the full burden. It discloses the output unit (radians), which is genuinely useful for a math op, but it omits the critical domain constraint that the input must lie in [-1, 1] and what happens outside that range. For a pure, stateless function this is adequate but not rich.

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

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

Two short sentences, zero filler, with the primary purpose front-loaded and the batching hint second. Nothing is wasted.

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 one-parameter stateless math function with no output schema and full schema coverage, the description covers purpose, unit, and the batching escape hatch. The only real gap is the missing input-domain constraint, which an agent genuinely needs to avoid a NaN or 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 description coverage is 100% for the single 'number' parameter, so the schema already documents it fully; baseline is 3. The description adds only the radians unit of the result, which is not parameter syntax and doesn't meaningfully extend the schema.

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

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

States a specific operation (arcsine) on a specific input (a number) and pins the unit (radians), which distinguishes it from degreesToRadians and radiansToDegrees siblings. An agent can select it without opening the schema.

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

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

Explicitly routes multi-step work to batch_calc, which is a clear alternative-selection rule. It does not, however, say anything about when this single-operation form is preferred or note the sibling sin/arccos relationship, so the routing is partial rather than complete.

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, so the description carries full burden. It discloses that the result is in radians, which is useful for interpretation. However, it doesn't mention potential domain restrictions (e.g., arctangent accepts all real numbers), precision, or return format beyond the unit.

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-loaded with the core function and then the alternative. 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?

For a simple single-parameter math function with full schema coverage and no output schema, the description provides what is needed: the operation, unit, and routing to batch_calc. Nothing critical 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 the parameter is fully documented in the schema. The description adds no additional parameter semantics beyond what the schema provides.

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

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

States a specific verb (Calculates) and resource (arctangent), and specifies the unit (in radians), which distinguishes it from sibling trigonometric 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?

Names the alternative (batch_calc) for several operations or chained steps, giving clear context. No explicit when-not-to-use beyond that, but sufficient for a single-purpose tool.

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

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

No annotations are provided, so the description carries the full burden. It excels here: it describes sequential execution, failure propagation ('skipped only if a step it depends on failed; unrelated steps still run'), forward-only references, and the exact return structure. It does not cover authentication, rate limits, or resource constraints, but for a pure calculation tool these are likely irrelevant.

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 tight and front-loaded: first sentence states capability, then execution order, then step format, then chaining syntax, then return format. Every sentence earns its place, and no information is repeated unnecessarily.

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 a batch execution tool with chaining, the absence of an output schema, and no annotations, the description provides exactly what an agent needs: operation list, step structure, reference syntax, execution order, failure semantics, and return shape. It is complete enough to invoke correctly 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 description coverage is 100%, so the schema already documents the single 'steps' parameter and its nested structure with enums. The description adds the crucial reference syntax ('{"$step": <index>}') and chaining rules beyond the schema, but does not provide operation-specific parameter details. Given the high schema coverage, a baseline 3 is appropriate.

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

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

The description states a specific verb+resource ('Executes multiple calculation steps in one call') and immediately positions itself against its many siblings by being a batch orchestrator, not a single operation. An agent can clearly distinguish this from add, subtract, 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 implicitly and explicitly guides when to use: 'Executes multiple calculation steps in one call and returns all results at once' makes batch use the clear condition, and the chaining mechanism defines exactly when references are appropriate. The sibling tools are single operations, so the batch tool's niche is obvious.

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 behavioral burden. It discloses the supported width domain and operation set, which is useful, but says nothing about edge behavior such as out-of-range shift counts, negative operands, or overflow beyond the declared width.

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 tightly written sentences: the capability and domain come first, the sibling routing second. No filler, nothing to trim.

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 pure-computation tool with full schema coverage, complete enums, and no output schema to explain, the description covers the essential call contract. Only edge-case semantics are missing, which is a minor gap for a low-risk stateless function.

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% and both enums (operation, bitWidth) are documented in the schema, so the schema already carries the parameter detail. The description adds the width set and operation list, but mostly restates what the schema covers, so baseline 3 applies.

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

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

States a specific verb (performs bitwise operations) and enumerates the exact operation set and supported widths, which lets an agent distinguish it from arithmetic siblings like multiply or modulo without opening the schema.

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

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

Explicitly routes multi-step or chained work to batch_calc, giving a clear alternative and the condition that selects it. It does not cover when to prefer an arithmetic sibling for single operations, but the primary routing decision is stated.

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

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

No annotations are provided, so the description carries the burden. It fully defines the transform (round upward to the nearest integer), which is the essential behavior for a pure function, but says nothing about return type, handling of negatives (e.g. -1.2 -> -1), or edge cases such as NaN/infinity.

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

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

Two short sentences, front-loaded with the core operation and followed by the routing hint. Every sentence earns its place with zero filler.

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

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

For a single-argument pure math function with no output schema, the description plus schema cover everything needed to invoke it correctly. Only edge-case semantics (negative numbers, non-finite input) are absent.

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% and the single parameter is documented as 'The number to round up'. The description adds no syntax or format detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and operation ('Rounds a number up to the nearest integer') that clearly separates it from siblings like floor and round. An agent can select it without inspecting any schema.

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

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

Explicitly routes multi-step or chained work to batch_calc, naming the alternative and the condition that selects it. It does not, however, contrast with round or floor, which is the main remaining differentiation question for a math tool.

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

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

No annotations are provided, so the description carries the behavioral burden. It confirms the operation and unit, but does not disclose edge-case behavior (e.g., NaN, infinity, precision) or error handling, which is minimally adequate for a standard trig function but not rich.

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

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

Two sentences, front-loaded with the core operation and followed by a routing note for the sibling tool. Every sentence earns its place with no 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 low complexity, complete schema coverage for the single parameter, and the absence of an output schema, the description is complete enough. It covers the operation, unit, and the relevant alternative for batch operations.

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%, and the parameter schema already documents that the number is in radians. The description repeats the unit but adds no additional syntax, range, or format guidance beyond what the schema provides, so the baseline of 3 applies.

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

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

The description states a specific mathematical operation (cosine) and the required input unit (radians). It clearly identifies the resource as cosine, distinguishing it from sibling trig functions by name and 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?

It explicitly tells the agent to use batch_calc for several operations or chained steps in one call, giving a clear alternative-selection condition. For a single cosine calculation, the purpose already implies this is the correct tool.

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

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

No annotations are provided, so the description carries the full behavioral burden. It states what the tool computes but does not disclose whether the operations are pure, side-effect-free, idempotent, or performance characteristics. However, for a pure calculator, the absence of destructive behavior is implied, and the main behavioral context is the routing to batch_calc.

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

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

Two sentences, no waste. The first sentence front-loads the core purpose; the second provides the key alternative. Both sentences earn their place.

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

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

For a stateless, pure computation tool with no output schema and full schema coverage, the description is adequate but lacks details about return format (e.g., hex vs. base64) and edge cases (e.g., invalid input handling). These are minor but would improve completeness.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description lists operation categories but adds no 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 states specific verbs and resources: 'Computes cryptographic hashes (MD5, SHA1, SHA256), CRC checksums (CRC32, CRC16), and modular arithmetic (mod_pow, mod_inverse, gcd)'. It also explicitly distinguishes this tool from the sibling batch_calc by naming it.

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 this tool versus batch_calc: 'For several operations or chained steps in one call, use batch_calc.' It does not discuss the other siblings (e.g., modulo, add), but those are for basic arithmetic and not directly overlapping with cryptographic 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 disclosure burden. It communicates the transformations available but says nothing about return values, error behavior on invalid input (e.g. malformed Base64 or hex), or that the operation is a stateless pure transformation; the low-risk nature of a codec keeps this at minimum-viable rather than poor.

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

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

Two sentences, zero filler: the capability statement comes first and the sibling routing hint second. Nothing is repeated from the schema and every clause earns its place.

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

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

For a four-parameter pure codec with a fully documented schema, the description covers what it does and when to switch to batch_calc. The one gap is that, with no output schema, it never states that the result is a string or how errors surface.

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 all four parameters are already documented, and the enum lists on action and format are self-explanatory. The description adds the format vocabulary but does not clarify the text/hex `format` semantics or the `urlSafe` padding behavior beyond what the schema states, so it stays at the baseline.

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

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

States a specific verb pair (encodes/decodes) and the exact resource (data) plus the supported codec families: Base64, Hex, ASCII/UTF-8, and URL. This clearly separates it from the arithmetic and bit-manipulation siblings, and it names batch_calc as the composite alternative.

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

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

It gives an explicit routing rule — use batch_calc when you need several operations or chained steps in one call — which is real when-to-use guidance. It does not, however, say anything about which action to pick for a given direction of conversion or any input constraints.

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 burden. It implies a stateless pure computation with no side effects, but does not state the return form (radians) or how invalid input is handled. For a trivial single-value conversion the gap is minor, but it is unstated.

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

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

Two short sentences with zero waste; the core operation is front-loaded and the routing hint follows. Nothing needs trimming.

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

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

For a one-parameter pure math tool with a fully documented schema and no output schema, the description is essentially sufficient—purpose plus sibling routing is all that is required. Only a note on the returned unit/precision would make it airtight.

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% ('The number in degrees to convert to radians'), so the single parameter is fully documented in structured data. The description adds no format, range, or type detail beyond that, so baseline 3 applies.

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

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

States a specific verb and resource ('Converts degrees to radians'), which cleanly distinguishes it from its sibling radiansToDegrees and the other arithmetic tools. An agent can identify the operation without opening the schema.

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

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

Explicitly routes multi-step or chained work to batch_calc, naming both the alternative and the condition that selects it. That is exactly the routing guidance an agent needs in a large math-tool family.

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 behavioral burden. It states the operand order but says nothing about division-by-zero handling, error behavior, precision, or return format for a pure-computation tool. Minimal disclosure beyond the operation itself.

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, zero filler, with the core operation front-loaded and the cross-tool routing placed second. Every sentence earns its place.

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

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

For a two-parameter, fully documented arithmetic tool with no annotations and no output schema, the description is nearly sufficient to invoke correctly. The main remaining gap is undeclared division-by-zero behavior, which for a division tool is a foreseeable failure mode.

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% and both parameters are already documented as numerator and denominator. The description's 'first number by the second' mirrors rather than extends that, so the baseline 3 applies.

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

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

The description gives a specific verb and resource ('Divides the first number by the second') and even clarifies operand ordering, which is more than a tautology of the title. It routes to a sibling (batch_calc) for multi-step work. Sibling differentiation is otherwise only implicit in the operation name, so it stops short of a 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?

It explicitly names the alternative (batch_calc) and the condition that selects it ('several operations or chained steps in one call'). That is clear when-to-use-alternative guidance. It omits any when-not or edge-case guidance (e.g., division by zero), keeping it out of the top band.

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 disclosure burden. It communicates that the tool accepts hex values, numbers, and byte streams, which is useful input-handling behavior, but says nothing about width auto-detection, error cases, or what the transformed output looks like.

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

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

Two sentences, zero filler, and the core operation is front-loaded ahead of the batch_calc routing note. Nothing is wasted.

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, deterministic two-parameter transform with full schema coverage, the description covers the essential purpose and one routing rule. It is nearly complete, with only the return format and width defaulting behavior left implicit.

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 both parameters (value, widthBytes) are fully documented in the schema. The description only loosely parallels the value parameter's accepted types and adds no syntax or format detail beyond what the schema already gives, so the baseline of 3 applies.

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

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

States a specific verb (Swaps) and resource (endianness) with the mapping (Big-Endian <-> Little-Endian) and the accepted input forms, so the operation is unambiguous. It does not, however, differentiate itself from other conversion siblings like ieee754_convert or int_convert that also transform value representations.

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

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

Gives one explicit routing rule: for several operations or chained steps in a single call, use batch_calc. That is a clear condition paired with an alternative, but there is no guidance on when to prefer this over the other conversion tools, so no true exclusions are stated.

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

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

No annotations exist, so the description carries the full burden. For a pure, side-effect-free math function this is mostly self-evident, but it says nothing about edge behavior such as negatives (floor(-1.5) = -2) or non-numeric input handling.

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, the core operation front-loaded, with the batch hint as a trailing clause. 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?

A one-parameter pure function with a fully described schema needs little more than this. The only gap is behavioral edge cases, which are minor for a deterministic rounding primitive.

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% and the single parameter ('The number to round down') is fully documented in the schema. The description adds no syntax or format detail beyond that, so baseline 3 applies.

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

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

States a specific verb ('rounds down') and resource ('a number') with the resulting type made explicit ('to the nearest integer'). That is enough to separate it from ceiling and round, though it never names those siblings as contrast.

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

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

Explicitly routes multi-step work to batch_calc, which is a real alternative-selection cue. It stops short of saying when to pick this over ceiling/round for single values, but 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?

No annotations are provided, so the description carries the full burden. It implies a pure conversion with no side effects and mentions the decomposition output (Sign/Exponent/Mantissa), but never states that it is a read-only/non-mutating operation, nor how the result is formatted or whether hex input must match the requested precision.

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

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

Two sentences, zero filler, with the core operation front-loaded and the routing hint placed second. Every clause earns its place.

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

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

For a two-param pure converter with no output schema, the description covers the input/output domain well by naming the decomposed fields. Missing only the return structure and any precision-related caveats, which is a modest gap in an otherwise complete definition.

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 both 'value' (with format examples) and the 'precision' enum are already fully documented in the schema. The description adds no format or defaulting detail beyond what the schema provides, so the baseline of 3 applies.

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

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

States specific verbs (converts, decomposes) plus the exact resource pair (Float/Double numbers vs IEEE 754 binary/hex layout) and even enumerates the resulting components (Sign, Exponent, Mantissa). This distinguishes it from the arithmetic siblings and from converters like int_convert or endian_swap.

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 routes multi-step or chained work to batch_calc, which is a real alternative with a stated selecting condition. It does not, however, say when-not to use this tool versus int_convert or bitwise for adjacent numeric-representation tasks.

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 behavioral burden. It discloses the conversion dimensions available (hex/dec/bin/oct, 8/16/32/64-bit, signed/unsigned, endianness, ASCII), which is genuinely useful context, but says nothing about error handling, precedence when both value and values are supplied, or result 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 tightly packed sentences with the capability list front-loaded and the routing hint second. No filler or redundancy.

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

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

For a stateless conversion tool with 100% schema coverage and no output schema, the mode coverage is decent, but the return value shape and the batch-vs-single precedence are left unaddressed. Adequate but with clear gaps.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema with example formats. The description adds no syntax or format guidance beyond that, making the baseline 3 appropriate.

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

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

Specific verb (converts) plus resource (integer(s)) and a concrete list of output bases and bit widths. It also names the sibling batch_calc and the condition that selects it, so an agent can separate the two without opening schemas. Only reason it isn't a 5 is that it doesn't clarify which of the near-neighbor codec tools (data_codec, ieee754_convert) it supersedes.

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 says to use batch_calc 'for several operations or chained steps in one call', which routes the agent away from int_convert for multi-step work. No explicit when-not for its own single/batch params, but the alternative condition 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?

No annotations are provided, so the description carries the full burden, but for a single-argument pure computation the safety surface is minimal. It does not say what happens with an empty array, non-numeric coercion, or the return shape, which are the only behaviors worth disclosing here.

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

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

Two sentences, no filler, and the core operation is front-loaded ahead of the alternative-tool pointer. Every clause earns its place.

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

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

For a one-parameter pure math tool with no output schema and no annotations, the description supplies everything needed to invoke it correctly and to route multi-step work elsewhere. Only edge-case behavior for degenerate inputs is left unstated.

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 a single 'numbers' array parameter that the schema documents as 'Array of numbers to find the maximum of'. The description's phrasing matches the schema exactly and adds no format or constraint detail, so the baseline 3 applies.

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

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

States a specific verb (Finds) and resource (maximum value from a list of numbers), which is immediately distinguishable from the min, mean, and median siblings. It also names the sibling it is not (batch_calc), so an agent can route without opening a schema.

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

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

Gives an explicit alternative and the condition that selects it: multiple operations or chained steps should go to batch_calc. It stops short of stating when this tool is the wrong choice for a single-value case, but the routing guidance is concrete rather than implied.

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

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

No annotations are provided, so the description carries the full behavioral burden for a pure computation. It discloses nothing about return precision, rounding, error behavior on non-numeric input, or edge cases beyond what the schema's minItems already enforces; for a stateless math function the risk surface is small, so this is only a moderate 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?

Two short sentences, the core behavior front-loaded, and the alternative-tool hint placed second. No filler or restated boilerplate.

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-argument pure computation with a fully documented schema and no output schema, the definition covers what an agent needs to invoke it. The remaining omission is edge-case behavior and return precision, which is minor here.

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?

Only one parameter, and schema description coverage is 100%, so the schema already documents 'numbers' as 'Array of numbers to find the mean of'. The description adds no format, range, or count constraints beyond that, which is the expected baseline when the schema does the work.

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

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

States a specific verb ('Calculates') and resource ('arithmetic mean of a list of numbers'), which is unambiguous. It does not distinguish itself from the closest siblings, median and mode, which an agent might reasonably confuse it with, so it stops short of a 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?

Explicitly routes multi-step or chained computation to batch_calc, giving a clear alternative for one scenario. It offers no guidance on when mean is the right choice versus median/mode, and the batch_calc note is peripheral to the primary use case.

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 disclosure burden; it says nothing about behavior for an empty array, even-length input (averaging the two middle values), or non-numeric entries. For a deterministic pure-math function the risk is low, but the caller is left to infer edge-case handling.

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

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

Two tight sentences: the core operation first, then the routing hint. No filler, no repetition of the tool name, and the most important information leads.

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 one simple parameter, no output schema, and no annotations, the definition gives an agent enough to invoke correctly. The only omission is edge-case return behavior, which is minor for this tool class.

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% and the single parameter is fully documented as "Array of numbers to find the median of," including minItems=1. The description adds no format or constraint detail beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb and resource ("Calculates the median of a list of numbers"), which cleanly separates it from sibling statistics tools such as mean, mode, min, and max without needing to open any schema.

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

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

Names an explicit alternative and the condition that selects it: chained or multi-step operations should go to batch_calc. It does not, however, cover when to prefer median over mean/mode for a given problem, so it falls short of full when/when-not guidance.

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

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

No annotations are provided, so the description carries the full burden. It correctly implies a pure, side-effect-free computation, but does not disclose edge-case behavior (empty array, NaN, tie handling) that an agent might need to reason about.

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

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

Two sentences, front-loaded with the core purpose and followed immediately by the routing hint. No filler or repetition.

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 scalar reducer with a fully documented schema and an obvious return value, the description covers what an agent needs. The lack of edge-case notes is a minor gap rather than a blocking one.

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% and the single parameter is documented in the schema itself. The description adds no syntax or format detail beyond what the schema provides, so the baseline of 3 applies.

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

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

States a specific verb and resource ('Finds the minimum value from a list of numbers'), which is unambiguous and self-differentiating from the sibling 'max'. An agent can select this tool without reading the schema.

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

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

Names the alternative (batch_calc) and the condition that selects it ('several operations or chained steps in one call'), which is genuine routing guidance. It stops short of stating when-not to use min, but for a single-value reducer that is largely self-evident.

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 behavioral burden, and it says nothing about how ties (multiple equally common values) are handled, what happens with an empty array, or what the return value looks like. For a statistics operation where multimodal input is common, this is a meaningful 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?

Two short sentences with zero waste: the purpose leads, and the batch_calc alternative follows. Nothing is padded or restated from the tool name.

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

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

The tool is simple with one well-documented parameter and no output schema, so little is required. However, with no annotations and no explanation of tie-breaking or the return shape, an agent cannot fully predict the result of an ambiguous call.

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% and the single 'numbers' parameter is fully documented in the schema itself, so the description adds no parameter detail. Baseline 3 applies; no format, ordering, or type constraints are added beyond the schema.

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

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

States a specific verb and resource: 'Finds the most common number in a list of numbers.' This clearly distinguishes it from statistical siblings like mean, median, min, and max, so an agent can select it without inspecting the schema.

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

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

Explicitly routes multi-operation or chained work to batch_calc, which is genuine alternative guidance. It does not state when this tool is inappropriate (e.g. multimodal or empty input), so it falls short of full when/when-not coverage.

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

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

With no annotations, the description carries the full behavioral burden. It states the return value, but does not mention edge cases such as division by zero, negative operands, or floating-point behavior, which are relevant for a modulo operation.

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

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

Two short sentences, front-loaded with the core purpose and followed by a clear alternative-tool hint. Every sentence earns its place with no redundant or vague wording.

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 two-parameter math function with full schema coverage, the description is nearly complete: it states the operation's return and when to use the batch alternative. It omits edge-case behavior, but otherwise gives enough context to call 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%, so the input schema already fully documents 'numerator' and 'denominator.' The description adds no further parameter meaning beyond what the schema provides, making 3 the appropriate baseline.

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

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

The description states a specific verb and resource: 'Returns the remainder of a division.' It clearly identifies modulo behavior and distinguishes it from the sibling 'division' tool, which returns a quotient.

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

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

It explicitly routes multi-step or chained calculations to 'batch_calc,' implying this tool is for single modulo operations. It does not enumerate exclusions for every sibling, but the context is clear for a simple arithmetic function.

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 behavioral burden. It states the operation clearly, but it does not explicitly confirm purity/no side effects, numeric precision behavior, or the return shape. For a simple arithmetic tool the behavioral surface is small, but the description adds no explicit behavioral context beyond the operation name.

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

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

Two short sentences with zero waste. The core operation is front-loaded, followed immediately by the routing alternative.

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

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

For a two-parameter pure-arithmetic tool with 100% schema description coverage, the description covers purpose and the key routing decision. Although there is no output schema, the return value (the product) is self-evident from the operation, so nothing an agent needs in order to call it correctly is missing.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds no parameter-level meaning beyond what the schema provides, which is acceptable at the baseline of 3 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?

States a specific verb and resource ('Multiplies two numbers') and explicitly names the sibling tool to use for a different scope. An agent can distinguish this from add, subtract, division, and the other arithmetic siblings without opening any schema.

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

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

Provides explicit routing guidance: use this for multiplying two numbers, but use batch_calc for several operations or chained steps in one call. The alternative and the condition that selects it are both stated.

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

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

No annotations are provided, so the description carries the full burden. For a pure, side-effect-free math conversion there is little behavior to disclose, and the description adds the batch routing hint, but it says nothing about return format or handling of extreme/large values. Adequate but minimal.

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, purpose front-loaded and the alternative routing second. Zero filler; every sentence earns its place.

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

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

For a single-parameter pure conversion with no output schema and no side effects, the description plus schema is essentially complete. Only a note on return representation would add anything, which is minor for such a trivial function.

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 a single documented parameter, so the schema already explains the input fully. The description adds no format, range, or unit nuance beyond what the schema states, which is the expected baseline.

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

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

States a specific verb and resource ('Converts radians to degrees'), which is unambiguous against the many arithmetic siblings. It does not explicitly contrast with the closest sibling, degreesToRadians, but the direction of conversion is inherent in the name and description.

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?

Names the alternative batch_calc and the condition that selects it ('several operations or chained steps in one call'). It lacks when-not guidance for the inverse operation, but the routing advice to the batch sibling is concrete and actionable.

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 disclosure burden. 'Nearest integer' does convey rounding direction, but tie-breaking (e.g. 0.5, negative halfway values) and behavior on non-finite input are unstated - meaningful for a rounding function.

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, purpose front-loaded, and the second sentence earns its place by routing to batch_calc. No filler.

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

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

For a trivial one-parameter pure function with no output schema and no dangerous side effects, the definition is nearly sufficient. The only real omission is tie-breaking/edge-case semantics, which an agent might need for exact behavior.

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

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

There is a single parameter with 100% schema description coverage ('The number to round'), so the schema already does the work. The description adds no format, range, or type constraints beyond it, which is the expected baseline here.

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

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

States a specific verb and resource ('Rounds a number to the nearest integer'), which is unambiguous on its own. It does not differentiate against the closest siblings (floor, ceiling, int_convert), which also take a number and return an integer, so an agent must infer the 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?

It gives one explicit routing rule - use batch_calc for multiple or chained operations - which is genuinely useful. However, it says nothing about when to prefer round over floor/ceiling/int_convert, the ambiguity an agent is most likely to face in this sibling set.

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, but this is a stateless pure math function with no auth, mutation, or side-effect concerns to disclose. The description adds the radians convention but no behavioral context beyond that.

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

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

Two short sentences with no filler; the core purpose is front-loaded and the batch_calc pointer comes second. Every clause earns its place.

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

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

For a one-parameter pure function with a self-evident numeric return there is little an agent could be missing. No output schema exists, but the result is unambiguous, so the brief description suffices.

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 single parameter is fully documented as radians in the schema. The description's 'in radians' restates schema content rather than adding format or range detail, so baseline 3 applies.

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

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

States a specific verb ('Calculates') and resource ('sine of a number in radians'), which is unambiguous against siblings like cos, tan, and arcsin. It also names the sibling batch_calc for a related need.

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 routes multi-operation or chained work to batch_calc, giving a concrete alternative with a selecting condition. It does not state the inverse condition (use this for a single operation), but that is clearly implied.

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

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

With no annotations, the description carries the full burden. The operand order ('second from first') is the key behavioral disclosure for a non-commutative operation and is stated explicitly. However, it says nothing about output type, precision, or edge cases like overflow, so the coverage is partial.

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

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

Two short sentences, zero waste, with the core operation front-loaded and the sibling routing second. Well-structured for a minimal tool.

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

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

For a two-param arithmetic tool with no output schema, the description covers the operation, operand order, and sibling alternative. Missing only trivial details like return format, which is predictable for arithmetic.

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 defines minuend and subtrahend. The description reinforces the operand order in prose, which is the only semantic nuance for this tool, adding marginal value on top of a complete 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 states a specific verb and the exact operand relationship: 'Subtracts the second number from the first.' This distinguishes it from siblings like add and multiply without ambiguity.

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

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

It names the alternative (batch_calc) and the condition (several operations or chained steps in one call), which gives clear routing guidance. It doesn't state when subtraction itself is the wrong choice, but that's inherent to the operation.

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 disclosure burden. It is a pure, side-effect-free arithmetic operation, so there is little destructive behavior to disclose, but the description says nothing about edge cases (empty arrays, overflow, precision) or the return shape. Adequate but thin for a no-annotation tool.

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

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

Two short sentences with zero waste. The core purpose is front-loaded and the alternative routing follows immediately.

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 arithmetic tool with a fully documented schema and no output schema, the description supplies everything needed to select and invoke it. Minor gap: no mention of return value behavior, though that is largely self-evident for a sum.

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% and there is only one parameter ('numbers'), which the schema already documents as an array of numbers with minItems 1. The description adds no syntax or format detail beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

States a specific verb ('adds') and resource ('numbers'), and clarifies the scope is 'any number of numbers'. It distinguishes itself from the sibling add (binary) and batch_calc (multi-op) via an explicit routing sentence.

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 names batch_calc as the alternative when several operations or chained steps are needed. It gives clear context for the alternative but does not state when this tool should be avoided in any other sense.

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 burden, but for a pure stateless trig computation there is little behavior to disclose. It conveys the unit convention (radians) but says nothing about the return value's nature (a unitless ratio, unbounded) or undefined cases. Adequate but thin for an annotation-free tool.

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

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

Two short sentences, each earning its place: the operation first, the alternative second. No filler, no redundancy with the title or schema.

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 one-parameter, 100%-documented math function with no output schema, the definition supplies purpose and an alternative route, which is sufficient to invoke it correctly. A brief note on the return value (unitless ratio) would have closed the remaining gap.

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

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

Schema description coverage is 100% and the single parameter ('The number in radians to find the tangent of') already documents both meaning and unit. The description's mention of radians matches rather than extends the schema, so the baseline 3 is appropriate.

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

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

States a specific verb and resource ('Calculates the tangent of a number') and pins the unit ('in radians'), which cleanly separates it from siblings like sin, cos, arctan, and degreesToRadians. An agent can identify the operation without opening the schema.

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

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

Explicitly names the alternative path for multi-step work ('For several operations or chained steps in one call, use batch_calc'), giving a clear routing rule. It stops short of a full when/when-not treatment (e.g., no note that input must be radians rather than degrees, despite degreesToRadians being a sibling).

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