FreeDailyPro Tools

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered without the description. The phrase 'Flesch-Kincaid style metrics' adds a little context about what the computation produces, but 'style' is hedged and nothing is said about language assumptions (Flesch-Kincaid is English-oriented), text length limits, or whether multiple indices are returned.

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

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

A single front-loaded phrase with zero filler, which is the right shape for a simple one-input utility. It is arguably under-specified rather than over-long, so the size itself is not the problem.

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 parameter, full annotation coverage and no output schema, the description is close to sufficient but leaves the return shape entirely unstated — an agent cannot tell whether to expect a single grade level, a set of index scores, or per-sentence breakdown. For a tool with no output schema, one clause on the returned metrics would have closed the 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 0% and the description never mentions the single required 'text' parameter, so nothing is added beyond the schema's bare string type. Meaningful gaps remain undocumented: minimum/typical input length, whether HTML/markdown should be stripped, and language constraints for a metric that is language-specific.

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

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

Names the resource (reading level / readability) and the specific metric family (Flesch-Kincaid style), so an agent can tell it apart from near neighbours like word_count or check_grammar. It stops short of explicitly disambiguating from those siblings, which is what a 5 would require.

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

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

There is no when-to-use, when-not-to-use, or alternative routing guidance. The agent must infer on its own whether this is for scoring a document, gating content, or comparing drafts, and whether check_grammar or word_count is the better fit for a given request.

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, non-destructive, closed-world behavior, so safety is covered. The one piece of added context is 'fixed offset', implying arithmetic rather than IANA timezone/DST lookup — useful, but it does not say what the return value looks like or how invalid offsets are handled.

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?

It is a single front-loaded sentence with zero waste, but it is too terse for a tool with two undocumented required parameters. Conciseness here shades into under-specification rather than efficient structure.

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

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

With no output schema and zero parameter descriptions, the description is the only source of contract detail and it omits offset syntax, sign convention, and return format. For a small utility that may be tolerable, but it is not complete enough to call correctly without trial and 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 0% for two required parameters, so the description must compensate and largely does not. 'UTC' and 'fixed offset' hint at the semantics of utcIso and offset, but the accepted offset format ('+05:30' vs '330' vs '-8') and the ISO timestamp shape are entirely undocumented.

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

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

The description names a specific verb+resource: applying a fixed offset to a UTC time, which is more precise than a generic 'timezone converter'. It does not distinguish itself from the very similar sibling convert_timestamp, which likely overlaps.

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 when-to-use guidance, no exclusion of alternatives such as convert_timestamp, and no mention of prerequisites (e.g., that the input must be UTC, or that DST rules are not consulted). The agent must infer routing from the name alone.

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

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

Annotations already declare readOnly, idempotent and non-destructive, so the safety profile is covered. The description adds the useful default behavior (half the original size), but says nothing about whether compression is lossy, output format, or how the result is returned.

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

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

A single well-front-loaded sentence with no waste; the example and default are packed into a short parenthetical rather than padding the 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?

For a two-parameter tool with no output schema, the description covers the size target and default but omits the required input encoding and the shape of the returned (presumably base64) compressed file. Adequate but with clear gaps.

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

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

Schema description coverage is 0%, so the description carries the burden. It does meaningfully document targetFileSize (example '2MB', default rule), but leaves fileBase64 unexplained — an agent must guess that it is the base64-encoded source audio and that it is required.

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 ('Compress audio') plus the objective (target file size), which clearly separates it from audio_convert or audio_normalize. It stops short of explicitly naming which sibling to use instead when the goal is format change rather than size reduction.

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 only implied: an agent can infer it applies when a smaller audio file is wanted, and the default ('half the original') hints at the no-parameter case. There is no explicit when-not guidance nor a pointer to alternatives such as audio_convert for format changes.

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/idempotentHint/destructiveHint=false, so safety is covered. The description adds no behavioral context beyond the format list — no size limits, no output encoding, no quality or lossy/lossless caveats for a transform 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?

A single efficient sentence with the verb and resource front-loaded. It's terse to the point of under-specification rather than padded, so it earns its space but could say more.

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

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

With no output schema, two required parameters at 0% schema coverage, and no explanation of the base64 input or the return value, an agent cannot confidently construct a correct call from this description alone.

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

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

Schema coverage is 0%, so the description should carry the load. It lists the formats, but those are already the enum values, and it says nothing about fileBase64 — whether it's base64-encoded audio bytes, acceptable size limits, or how the converted result is returned.

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 (convert) and resource (audio) with the target format set, so the core action is unambiguous. It doesn't distinguish itself from siblings like audio_compress or video_extract_audio, so it falls 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?

No indication of when to reach for this versus audio_compress (size reduction) or video_extract_audio, nor any prerequisites. The agent is left to infer all routing from the name alone.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds the algorithmic method (FFT spectral subtraction), which is useful context, but does not disclose supported audio formats, output format, or how results are returned. With annotations carrying the safety burden, this is adequate but limited.

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

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

A single, front-loaded sentence that states the action and the method with zero wasted words. It is appropriately sized for the tool's simplicity.

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 audio tool with no output schema and 0% schema description coverage, the description is incomplete. It omits supported input formats, the meaning and effect of 'strengthDb', and what the tool returns, all of which an agent needs to invoke it 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 0%, so the description must compensate for undocumented parameters. It mentions neither 'fileBase64' nor 'strengthDb', leaving both parameters entirely unexplained in prose. This is a significant gap for a tool where 'strengthDb' is non-obvious (units, range, effect).

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 ('Reduce background noise in audio') and adds the technical method ('FFT-based spectral subtraction'). This clearly distinguishes it from sibling tools like audio_normalize (volume) and audio_remove_silence (silence removal).

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

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

There is no guidance on when to use this tool versus alternatives such as audio_normalize, audio_remove_silence, or audio_compress. The purpose implies a use case, but no explicit conditions, exclusions, or sibling comparisons are provided.

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, and openWorldHint=false, so the safety profile is covered. The description adds nothing beyond that: it doesn't disclose supported audio formats, whether inputs must share sample rate/format, merge ordering, size/limit constraints, or what the result looks like. With one param and no output schema, that omission is a real 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?

A single front-loaded sentence with zero waste — appropriate for a simple one-parameter tool. It is arguably too terse for the tool's behavioral surface, but as conciseness it is efficient.

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

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

This is a low-complexity tool, but with no output schema the description should state what is returned (merged file, base64 payload, download reference) and what output format to expect. Neither is present, and format/ordering constraints on the inputs are also missing, so an agent cannot fully predict the call's outcome.

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 0% schema description coverage, so the description must compensate. 'Multiple audio files' usefully confirms the array holds audio content and implies at least two entries, but it adds no detail on encoding expectations, ordering semantics, per-item size limits, or whether formats may be mixed.

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: 'Merge multiple audio files into one.' That is unambiguous and distinguishes it from the audio_* siblings (convert, trim, compress), which transform rather than combine. It doesn't explicitly name an alternative, but the domain-specific name already separates it from the pdf_merge/pptx_merge/video_merge cousins.

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 gives no when-to-use context, no prerequisites, and no pointer to alternatives such as audio_convert (for format unification before merging) or audio_normalize (for loudness consistency). An agent must infer everything from the tool name alone.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful context that normalization follows EBU R128, but it does not describe the return format, input handling, or processing 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?

The description is a single front-loaded sentence with no wasted words. It communicates the core action and the relevant standard efficiently.

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

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

There is no output schema, so the description should clarify what the tool returns, but it does not. It also omits input format expectations and any processing constraints, leaving meaningful gaps for an audio transformation tool.

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

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

Schema description coverage is 0%, and the single required parameter fileBase64 is not explained in the description. The description does not clarify accepted audio formats, size limits, or how the base64 string should be supplied.

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: 'Normalize audio loudness.' It also adds the EBU R128 broadcast standard, making the purpose concrete, but it does not explicitly distinguish this from sibling audio tools such as audio_compress.

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 is used when audio loudness needs normalizing, but it gives no explicit when-to-use guidance, no exclusions, and no comparison to sibling tools like audio_compress or audio_denoise.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description usefully discloses the time-stretch behavior (pitch changes, duration preserved), which is the non-obvious trait, but says nothing about output format, size limits, or acceptable input ranges.

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

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

A single short sentence with the key constraint front-loaded and no filler. Efficient, though its brevity is partly the cause of the missing parameter detail.

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 audio transformation with no output schema and 0% schema coverage, the description leaves critical gaps: how semitones are interpreted, what form the audio file must take, and what the tool returns. An agent could not reliably call this without guessing.

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

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

Schema coverage is 0%, so both parameters are bare in the schema and the description must compensate — and it does not. The word 'semitones' never appears in the description, so the unit, sign convention (positive = up), and sensible bounds are entirely undocumented, as is the required base64 encoding of fileBase64.

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 ('Shift') and resource ('audio pitch') plus the key behavioral qualifier 'without altering speed', which implicitly separates it from the sibling audio_speed. It does not name that sibling explicitly, so differentiation is inferential rather than stated.

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

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

No explicit when-to-use or when-not-to-use guidance, and no alternative tool is named. The 'without altering speed' clause implies a contrast with audio_speed, but the agent must make that inference itself.

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, idempotentHint, non-destructive, and closed-world, so the safety profile is fully covered. The description adds nothing beyond the name: nothing about what happens to the gaps (removed vs. shortened with crossfade), whether the audio is returned as base64, or output format/quality. With annotations doing the heavy lifting, this is a low-value restatement.

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

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

A single front-loaded sentence with no filler or redundancy. It is efficient, though the brevity is partly under-specification rather than discipline.

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 3-parameter media-processing tool with no output schema, no annotations about output, and no parameter documentation, this description is too thin. It leaves the two tuning parameters and the shape of the result entirely unexplained.

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

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

Schema description coverage is 0%, so the description carries full burden, yet it never mentions thresholdDb (-30 dB default) or minDurationSeconds (0.3s minimum) — the two parameters that actually control behavior. An agent cannot tell what these mean or how to tune them without reading raw property names.

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+resource ('Remove silence') and clarifies the scope ('throughout an audio file'), which usefully separates it from edge-trimming siblings like audio_trim. It does not name any sibling explicitly, so the differentiation is inferred rather than stated.

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

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

There is no when-to-use guidance, no prerequisites, and no reference to alternatives such as audio_trim or audio_normalize. An agent must infer the choice from the tool name alone.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds the genuinely useful behavioral fact that pitch is preserved and the speed range. It does not say whether a new audio artifact is returned, what format it is in, or whether the source is modified, which matters for a transform 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?

A single sentence with zero waste; the pitch-preservation guarantee and the numeric range are both front-loaded where an agent will read them.

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 2-parameter, non-destructive utility with no output schema, the essentials are present and the safety profile is delegated to annotations. The missing piece is input expectations for fileBase64, which is a notable gap for a media transform tool but not a disqualifying 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 0%, so the description carries the full burden. It restates the speed range that the schema's min/max already enforce, and says nothing at all about fileBase64 — no supported audio formats, no encoding/size expectations — leaving half the required parameters undocumented in both places.

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

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

States a specific verb and resource ('Change audio playback speed') plus the key qualifier 'without altering pitch', which is exactly what separates it from the sibling audio_pitch. It stops short of naming audio_pitch or audio_convert explicitly, so sibling differentiation is implied rather than stated.

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 0.5–2.0 range gives a usable operating constraint, and the purpose clearly implies when to reach for it. But there is no explicit guidance on when to use this versus audio_pitch or audio_convert, and no prerequisite or input-format 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered structurally. The description adds only the notion of trimming to a time range and does not explain what is returned, whether the output is base64 audio, or how invalid ranges are handled.

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

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

The description is a single front-loaded sentence with no wasted words. Its brevity is efficient, though it is arguably too sparse for a three-parameter media transformation 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?

Given 3 required parameters, 0% schema description coverage, and no output schema, the description should explain input format and return behavior. It only states the broad operation, leaving key invocation details to inference.

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

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

Schema description coverage is 0%, so the description must compensate for all three required parameters. It implies startSeconds and endSeconds via 'time range' but never explains fileBase64, units, inclusive/exclusive boundaries, or supported audio formats.

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 and resource: 'Trim audio.' It also states the core scope, 'to a time range.' However, it does not distinguish this tool from nearby siblings such as video_trim or audio_remove_silence, so an agent must infer when this is the right 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?

There is no guidance on when to use this tool versus alternatives like audio_remove_silence, audio_convert, or video_trim. It also omits prerequisites such as whether the input must be a supported audio format or whether start/end must be within the file duration.

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, idempotentHint, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered elsewhere. The description adds nothing beyond that — no note on what happens with invalid Base64 input, whether output is a raw string, or any size/character-encoding limits.

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

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

A single short, front-loaded clause with zero filler — the action is stated immediately. It is efficient but borders on under-specification rather than genuine tightness.

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 (2 required params, no nesting, no output schema) and rich annotations reduce the burden, but the description still leaves the input/output contract unclear: what 'text' means in each direction and what a failed decode returns. For a converter whose whole job is transforming strings, that contract should be stated.

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

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

Schema description coverage is 0%, so the description must carry the parameter burden, and it does not. 'Encode or decode' merely echoes the action enum already present in the schema, and the required 'text' parameter is never explained (input string? already-encoded string when decoding?).

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

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

The description names a specific resource (Base64) and both supported operations (encode or decode), so an agent knows exactly what the tool does. It does not, however, differentiate itself from closely related siblings such as url_encode_decode or binary_ascii, which an agent could plausibly confuse it with.

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

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

There is no when-to-use guidance and no mention of alternatives, despite a crowded sibling set containing url_encode_decode, binary_ascii, html_entities, and decode_jwt. The agent must infer the selection criteria entirely from the tool name.

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

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

Annotations already establish readOnly, idempotent, non-destructive, closed-world behavior, so the safety profile is covered. The description adds nothing beyond that — no mention of output shape (single string vs. separated tokens), how the separator arg changes results, or error behavior on invalid input.

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

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

Three words with zero filler, so it is concise and front-loaded. But the brevity is achieved through under-specification rather than economy, which hurts more than it helps.

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 converter with a required enum action, an undocumented separator, and no output schema, the agent cannot tell what comes back or how the modes differ. The definition is far too thin for a 3-parameter tool with four conversion modes.

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

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

Schema description coverage is 0% for all three parameters, so the description carries the full burden and fails. It never mentions the action enum (including the non-obvious toHex/fromHex modes) or the purpose of the optional separator parameter (max length 3).

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?

"Binary ascii converter" essentially restates the tool name and title rather than stating a verb+resource with scope. It also misleads by omitting that the tool converts to/from hex as well as binary, so an agent scanning descriptions would not know the full capability.

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

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

No guidance on when to use this versus siblings like base64, text_emoji_unicode, html_entities, or text_ascii_art. The agent must infer the use case entirely from the name.

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 annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, so the safety profile is covered. However, the description adds no behavioral context such as PDF limitations, OCR refusal behavior, or what the conversion returns.

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 four-word description is short but severely under-specified rather than concise. It is front-loaded with a restatement of the name and offers no actionable detail.

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 a 9-parameter conversion tool with no output schema and incomplete schema descriptions, the description is completely inadequate. It does not explain input modes, PDF restrictions, CSV output shape, or categorization 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?

With 9 parameters and only 56% schema description coverage, the description must compensate for undocumented parameters. It provides no parameter semantics at all, leaving options like year, dateOrder, flipSigns, and numberFormat unexplained.

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

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

The description merely restates the tool name and title as 'Bank statement to CSV'. It does not specify what conversion entails, what formats are accepted, or how this differs from the many sibling business document 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?

There is no guidance on when to use this tool, what inputs are appropriate, or what alternatives exist among the sibling tools.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds nothing beyond that—no statement of what the tool returns (rendered document? plain text? downloadable asset?) or any constraints on the generated draft.

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?

It is short, but shortness here is under-specification rather than concision—a four-word fragment that conveys no actionable information. There is no front-loaded verb or scope statement.

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 five required untitled parameters, no output schema, and no description of the return value, the definition is not complete enough for an agent to call the tool correctly. Nothing indicates what the draft contains, what format it takes, or how the inputs are rendered.

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?

All five parameters (seller, buyer, item, price, date) are required with 0% schema description coverage, and the description supplies none of the missing meaning. Critical ambiguity is left unaddressed—e.g. 'price' is typed string with no currency/format hint, and 'date' is an unconstrained string with no expected format.

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 is essentially the tool name restated with no verb: 'Bill of sale draft' names the artifact but never says what the tool does with it (generate? fill a template? return text, PDF, or a file?). It gives no basis to distinguish it from siblings like business_lease_draft or business_promissory_note_draft.

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

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

There is no guidance on when to use this tool, when not to, or which sibling draft tool to prefer. An agent facing business_lease_draft, business_nda_draft, and business_poa_draft gets nothing to route on beyond the name itself.

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, and destructiveHint=false, so the safety profile is covered. However, the description adds nothing about redaction behavior: what is redacted by default, what 'labels' produces, or what happens with the 11 optional flags. With zero annotation gaps on safety, the missing behavioral content still leaves the tool opaque.

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 three-word description is not concise in a useful sense; it is under-specified. There is no front-loaded statement of what the tool does or what the key parameters mean, so nothing in the text earns its place beyond a title.

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

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

For a 12-parameter redaction tool with no output schema and no parameter documentation, the description is completely inadequate. An agent has no information about defaults, output format, or how the redaction options interact.

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

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

There are 12 parameters with 0% schema description coverage, and the description explains none of them. It does not clarify whether 'names' is a list of names to redact, whether 'custom' is a custom regex, what 'labels' toggles, or what the remove* booleans default to, leaving the agent unable to populate the schema 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 'Blind CV redactor' is a noun phrase that essentially restates the tool name and title ('Business Blind Cv'). It does not state a verb, what input it acts on, or that it returns an anonymized version of the supplied text.

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

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

There is no guidance on when to use this tool, no preconditions, and no reference to any sibling such as business_resume_outline. An agent has to infer the entire usage context from the name alone.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds nothing beyond that, such as whether it only computes break-even units or also supports target profit, startup costs, or expected units.

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 only two words, which is concise but severely under-specified for a six-parameter calculation tool. It is front-loaded in the sense of being short, but the brevity comes at the cost of usefulness.

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 six parameters, no output schema, and no parameter descriptions, the definition is far too thin for an agent to understand what the tool returns or how the optional fields affect the calculation. The description does not fill any of the necessary context.

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

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

The schema has six parameters with 0% description coverage, including non-obvious optional fields like startupCost, targetProfit, and expectedUnits. The description provides no meaning for any parameter, so it does not compensate for the schema gap.

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

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

The description 'Break even calculator' essentially restates the tool name and title without adding a specific verb or resource scope. It signals the domain but does not distinguish this from related financial calculators like business_profit_margin or business_product_margin.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. The agent must infer usage entirely from the name and schema.

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, and openWorldHint=false, so the safety profile is covered elsewhere. The description contributes nothing about what is actually returned (template text? a list of names?) or any other behavioral trait, adding no value beyond the 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?

Extremely short, but this is under-specification rather than conciseness. The two-word phrase earns little and front-loads no actionable 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?

Even for a simple one-enum-parameter tool, the description omits what the tool produces and how it differs from the numerous draft-oriented siblings. With no output schema, the description should at least indicate the return artifact, which it does not.

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

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

Schema description coverage is 0%, so the description should compensate but does not. The single "type" enum is self-evident, but the description never explains what selecting a type does or what the resulting artifact looks like.

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 is a bare noun phrase, "Contract templates", that essentially restates the tool name/title without a verb. It identifies the resource domain but leaves ambiguous whether the tool lists, retrieves, or generates templates, so an agent cannot confidently distinguish it from siblings like business_nda_draft or business_bill_of_sale_draft.

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

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

There is no guidance on when to use this tool versus the many sibling draft tools (business_nda_draft, business_offer_letter_draft, etc.). The agent must infer the selection criteria entirely from the name and enum values.

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, idempotentHint, non-destructive and closed-world, so the safety profile is covered by structured data. The description adds nothing further — no mention that a 422 is returned when contact lacks email/phone/LinkedIn, no note on the default 'Hiring Manager' or the docx option, all of which live only in the schema.

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

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

Three words is not concision but under-specification; there is no front-loaded statement of purpose, inputs, or output, so the brevity costs the agent information rather than saving it.

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?

This is an 11-parameter generator with no output schema, yet the description says nothing about what is returned (text plus sections, optionally result.docx), what validation can fail, or how the inputs shape the letter. The schema carries most of the burden, leaving the definition inadequate for a tool of 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 description coverage is 73%, below the high-coverage threshold, and the description contributes zero parameter meaning. Several properties (name, role, company) are undocumented in both places, and nothing explains the interaction between the required fields and the generated letter structure.

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?

"Cover letter maker" restates the tool name with no added specificity: no verb beyond an implied 'generate', no statement of what a cover letter output contains or how it differs from siblings like business_resume_outline or business_offer_letter_draft.

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

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

There is no guidance on when to use this tool versus the many adjacent document-generation siblings, and no prerequisites (required contact info, what inputs produce a usable letter) are mentioned anywhere in the description.

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, idempotentHint and non-destructive, so the safety profile is covered, but the description adds nothing beyond them — no mention that it returns a generated receipt document, that includeDocx yields a Word file, or that validation failures produce a 422. For a 17-parameter document generator with no output schema, this is a total 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?

It is a single short, front-loaded phrase with no filler, so it isn't bloated — but the brevity comes from omission rather than economy. There is no structure to speak of.

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 17 parameters, conditional requirements (amount for cash, propertyDescription for noncash), no output schema, and a legally sensitive output, the description supplies none of the context an agent needs. Everything must be reconstructed from the schema alone.

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 per-parameter text is unusually rich (EIN format, cash vs. noncash semantics, goods-and-services deduction math), so the schema carries semantics entirely. The description adds no parameter information; 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?

"Donation receipt maker from freedailypro" only restates the tool name plus a vendor tag; it never says it generates an IRS-compliant donation receipt from the supplied fields. Nothing distinguishes it from the many other document-generating siblings (business_receipt, business_bill_of_sale_draft) or indicates the output format.

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

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

There is no guidance on when to use this tool, what prerequisites exist (EIN, date of gift), or which sibling to pick instead. The phrase "from freedailypro" is a brand note, not usage 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?

Annotations already cover the safety profile (readOnlyHint=true, idempotentHint=true, destructiveHint=false, openWorldHint=false), so the bar is lower, but the description adds nothing beyond them – no indication of what output the draft takes, whether legal requirements vary by jurisdiction, or how the 'days' parameter influences the notice. The only value is that the name implies a generation operation, consistent with 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 three words long, but this is under-specification rather than conciseness – there is no front-loaded purpose statement, no scope, and nothing for the agent to act on beyond the name.

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

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

For a tool with 5 required, entirely undocumented parameters and no output schema, the description should explain at minimum what a draft is (text? file?) and what the inputs mean. It is completely inadequate for that 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?

All 5 parameters (landlord, tenant, address, date, days) are required and schema description coverage is 0%, so the description carries the full burden. It mentions no parameters and gives no hint about date format, what 'days' means (notice period?), or how the fields are used in the draft.

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 "Eviction notice draft" merely restates the tool name and title as a noun phrase, with no verb explaining what the tool actually does (generate? generate from a template? return a PDF?). An agent can guess it produces an eviction notice, but cannot distinguish its behavior from siblings like business_lease_draft or business_nda_draft beyond the document type.

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

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

There is no guidance at all on when to use this tool, when not to, prerequisites (e.g., jurisdiction, notice period rules), or which sibling to pick for related documents. Usage is only implied by the tool name.

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 fully declare the safety profile (readOnlyHint, idempotentHint, destructiveHint=false, openWorldHint=false), so the bar is low. Even so, the description adds nothing beyond the name — it doesn't mention that the tool is a pure computation over caller-supplied data with no side effects, nor how category merging affects the totals.

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 words is not conciseness — it's under-specification. There is no front-loaded statement of purpose or scope, and nothing in the description earns or lacks a place because nothing was written.

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

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

For a tool taking a nested array of expense records with aggregation semantics and no output schema, the description should at least state that it computes totals and what triggers the byMonth breakdown. All of that is left to the schema, leaving an agent with no narrative confirmation of what the call produces.

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 items, the date-triggered byMonth totals, negative-amount refunds, and mergeCategories semantics. The description adds no parameter meaning of its own; 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?

"Expense tracker" restates the tool name rather than stating a specific verb and resource. It doesn't say the tool totals a list of expenses, nor does it distinguish it from close siblings like business_receipt or business_invoice_totals.

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 when-to-use, when-not-to-use, or alternative-tool guidance is given. The only hints about behavior (date-triggered monthly totals, negative amounts as refunds, category merging) live entirely in the schema, not the description.

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, and openWorldHint=false, so the safety profile is fully covered by structured data. The description adds nothing beyond that – no information about what the tool returns, whether the region changes available content, or what the "hub" actually contains. No contradiction with annotations, but zero added value.

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

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

Three words is concise but the opposite of informative – this is under-specification rather than efficiency. There is no front-loaded statement of action or scope because there is no substantive content at all.

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

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

With no output schema, the description is the only place an agent could learn what forms are produced, in what format, or how region affects output, and it provides none of that. For a hub-style tool with a selector parameter, this leaves the agent unable to predict the response.

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

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

Schema description coverage is 0% and the description never mentions the single `region` parameter. The enum values (US, IN, UK, other) are somewhat self-explanatory, but the description offers no explanation of what region selects or how it changes results, so it fails to compensate for the coverage gap.

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

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

"Government forms hub" essentially restates the tool name (business_government_forms) as a label rather than stating what the tool does. There is no verb and no indication of what action the agent is performing, so an agent cannot tell from the description what this produces versus a document-drafting sibling like business_nda_draft.

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

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

There is no when-to-use guidance, no exclusions, and no reference to any alternative among the 25 sibling tools. The agent is left to guess entirely from the name whether this lists forms, generates them, or fetches templates.

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, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds nothing beyond that: it does not say whether a document is produced, whether the worksheet is stored or ephemeral, how required vs optional fields are handled, or what the result looks like. No contradiction with the read-only annotations, just silence.

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?

Brevity here is under-specification rather than conciseness: three words carry no actionable information and nothing is front-loaded beyond a restatement of the name.

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

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

A tool with 5 parameters, 4 of them required, zero schema descriptions, and no output schema needs a real description to be callable correctly. This one provides nothing about inputs, output artifact, or expected context, leaving the agent to guess.

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

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

Schema description coverage is 0% (properties carry only types and minLength), so the description must compensate and does not. It never mentions title, inventor, problem, solution, or date, nor the formatting or length expected for each field.

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 is a three-word noun phrase, "Invention disclosure worksheet", that essentially restates the tool name and title. It never states a verb (generate? draft? validate?) or what the agent gets back, so the purpose can only be guessed by analogy with siblings like business_nda_draft.

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

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

There is no guidance on when to use this tool, no prerequisites, and no mention of alternative or related tools among the 25 business_* siblings. The agent has to infer everything from the name alone.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered. However, the description adds nothing at all — notably it fails to disclose that supplying businessName and clientName triggers generation of a rendered document and that includeDocx produces a Word file, which is behavior an agent cannot infer from the annotations.

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

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

Two words are not concise — they are under-specified. There is no front-loaded statement of the operation, the inputs, or the output shape.

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 12-parameter tool with an optional document/Word-file generation side effect and no output schema, a two-word description leaves the agent without any of the context needed to call it 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 75% and the schema itself documents most fields richly, so the baseline would be near 3. The description supplies zero parameter meaning, leaving the surprising conditional relationship between businessName/clientName/includeDocx and document output entirely to the schema's prose.

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?

'Invoice totals' merely restates the tool name; it does not say it computes invoice totals from a list of line items, nor does it distinguish the tool from siblings like business_receipt or calculate_sales_tax.

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

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

There is no guidance on when to use this tool, no alternatives named, and no mention of the preconditions (minItems:1 lines array) that define the 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?

The description adds no unique behavioral information beyond repeating the title and function. All behavioral constraints (read-only, idempotent) are already present in 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 optimally concise, using a short, direct phrase that identifies the tool's function without 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?

Given that the schema description coverage is 0% and the tool requires 6 distinct input parameters, the description is critically incomplete. It offers no context on what the parameters mean or what the output artifact represents.

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

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

With 0% schema coverage, the description must define the semantics of the 6 required parameters (landlord, tenant, address, etc.). The description provides no semantic meaning or context for these critical inputs.

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

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

The description clearly states the action (draft) and the resource type (Lease agreement). This is effective for identification.

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

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

The description provides no guidance on when to use this tool versus other sibling tools in the business document library. It lacks contextual boundaries or prerequisites.

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

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

Annotations already declare a safe, read-only, idempotent, closed-world computation, so the safety profile is covered. The description adds nothing on top: it does not disclose that compare requires a cost, that feePct is required unless compare is supplied, that preset marketplace rates carry verification dates, or what the response shape is.

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

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

Three words plus a noun phrase — there is no bloat or burying of key information. The brevity is a symptom of under-specification rather than tight editing, but the dimension rewards zero waste and the phrase is front-loaded.

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

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

For a 17-parameter tool with conditional requirements (feePct required unless compare; compare requires cost) and no output schema, the description covers none of it. An agent calling with only the required price could hit a validation failure it had no way to anticipate from 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?

Schema description coverage is 76%, comfortably in the high band, so the schema already carries most parameter meaning (cost's profit object, compare's 2-4 marketplace strings, default values for returnPct/shippingCost/feeOnShipping). The description contributes no parameter guidance at all, which is acceptable only because 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?

"Marketplace fee calculator" restates the tool name (business_marketplace_fee) and title almost verbatim, adding no verb/resource specificity. It also fails to distinguish this tool from siblings such as business_product_margin, business_profit_margin and business_break_even, which plausibly overlap in subject matter.

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 gives no when-to-use guidance, no mention of the two distinct modes (a single fee via feePct vs. a multi-marketplace comparison via compare), and no pointer to the neighbouring margin/profit calculators. Nothing steers the agent between this tool and its 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, and destructiveHint=false, so the safety profile is covered. The description adds nothing about what a "draft" output is, whether it is returned as text or a file, or what the tool does with the parties' names.

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 words with no structure or front-loaded detail; this is under-specification rather than conciseness. Nothing in the text earns its place because nothing informative is present.

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 four-parameter document-generation tool with zero schema coverage and no output schema requires the description to explain inputs and the nature of the returned draft. None of that is present.

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

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

Schema description coverage is 0% across four parameters, so the description must compensate and it does not: disclosingParty, receivingParty, purpose, and termYears are never explained (e.g., expected formats, whether termYears defaults to perpetual).

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?

"NDA draft" essentially restates the tool name and title, giving no verb and no scope. It signals only that the tool relates to non-disclosure agreements, leaving whether it generates, validates, or stores a draft entirely to inference.

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

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

There is no guidance on when to use this tool, no preconditions, and no mention of alternatives among the many sibling draft tools (lease, offer letter, promissory note, etc.).

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 cover the safety profile (readOnly, idempotent, closed-world, non-destructive), so the bar is lower, but the description adds nothing at all. It never mentions that the tool generates letter content, that includeDocx produces a Word file in result.docx, that past dates or low salary yield warnings/422s, or that defaults are filled in when fields are omitted.

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 words is not conciseness but under-specification; there is no front-loaded statement of what the tool produces. Every necessary sentence is missing rather than every unnecessary sentence removed.

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 26-parameter tool with a nested contingencies object, five enums, internship/permanent branching, and no output schema, the description leaves out what the caller gets back (letter body, warnings, optional docx) and how the many optional fields change the output. The schema covers parameters, but the tool's core behavior and return shape are undocumented.

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 81% and the property descriptions are unusually rich (salary formats, 422 conditions, internship vs permanent branches, defaults), so the baseline of 3 applies. The description itself contributes zero parameter meaning, leaving the schema to carry the whole load.

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?

"Employment offer letter draft" only restates the tool name and title, adding no verb or scope beyond what the identifier already says. It does not distinguish this from near siblings such as business_cover_letter, business_nda_draft, or business_contract_pack, nor does it say whether it generates text, a file, or a structured object.

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

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

There is no when-to-use, when-not-to-use, or alternative-tool guidance of any kind. An agent must infer from the name alone that this is the letter-generation tool and not, say, a document analysis or storage 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 declare readOnly, idempotent, non-destructive, closed-world, so the safety profile is covered. But the description adds no behavioral context beyond that: it doesn't say how taxes/deductions (fedPct, statePct, ssPct, medPct) are applied, whether gross is computed from rate×hours, or what the caller receives back given there is no output schema.

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?

It is short, but shortness here is under-specification rather than conciseness. There is no front-loaded statement of purpose or scope that an agent could act on.

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 21-parameter document-generation tool with 5% schema coverage and no output schema gets a three-word description that explains none of its inputs or its return value. This is far below what an agent needs to call it 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 only 5% across 21 parameters, so the description carries nearly the full burden and delivers nothing. Optional fields like bonus, other, health, retire, ytdGross, otMultiplier, employerAddress, and employeeId are completely undocumented in both places.

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

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

"Pay stub generator" restates the tool name and title without a specific verb, output format, or distinguishing scope. It does not say whether it produces a PDF, HTML, structured JSON, or plain text, which is the key ambiguity for a generator 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?

No when-to-use guidance, no prerequisites, and no mention of alternatives among the many sibling business_* document tools. An agent has no basis for choosing this over, say, business_invoice_totals except the name.

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, and openWorldHint=false, so the safety profile is covered. However, the description adds nothing about what 'draft' actually does—whether it returns template text, renders a document, requires legal review, or has side effects—so it contributes no 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 only three words, but it is under-specified rather than concise. It lacks front-loaded actionable information and does not earn its place by conveying anything beyond the title.

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

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

For a tool with three required parameters, no output schema, and no parameter descriptions, the definition leaves out purpose, usage guidance, parameter meaning, and return behavior. An agent would have to guess how to invoke it 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 0%, and the description does not explain any of the three required parameters: principal, agent, or powers. It provides no meaning, format expectations, or legal-role clarifications that would help an agent populate these fields 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 repeats the tool name almost verbatim ('Power of attorney draft') and contains no verb indicating whether it generates, validates, retrieves, or formats a document. It identifies the resource but not the action, leaving the agent to infer the operation from the tool name alone.

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

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

There is no guidance on when to use this tool, when not to use it, or which sibling business_*_draft tool is the right alternative. The agent receives no context about prerequisites, expected inputs, or distinguishing use cases.

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, idempotentHint and destructiveHint=false, so the safety profile is covered. The description adds nothing beyond that—no statement of the formula used, whether the result is a percentage or absolute amount, or how cost/price units are treated.

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?

Short and front-loaded, but it is under-specification rather than conciseness—the single phrase earns no place beyond echoing the name.

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

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

No output schema exists, yet the description says nothing about the return value (margin percent vs. markup vs. absolute profit). For a two-required-parameter computation tool, this leaves the agent unable to predict the result or verify the 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 0%, so the description carries the full burden and fails: it never mentions cost or price, their units/currency, or that both are required. Parameter names are suggestive but insufficient for a financial calculation where units matter.

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?

"Product margin calculator" essentially restates the tool name and title without a specific verb or scope. It gives no basis for distinguishing this from the sibling business_profit_margin, which an agent would need to choose correctly.

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 when-to-use guidance, no preconditions, and no mention of the near-identical sibling business_profit_margin. The agent must infer the use case entirely from the name.

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 annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. However, the description adds no behavioral context about how the calculation works, which parameter combinations are valid, whether inputs are mutually exclusive, or what the tool returns.

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 only three words, which is concise but severely under-specified rather than efficiently structured. It does not front-load any useful invocation or scoping 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 tool with seven undocumented optional parameters and no output schema, the description is completely inadequate. It does not explain valid input combinations, the calculation logic, expected outputs, or how to choose between this and closely related sibling tools.

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 has seven parameters with 0% description coverage, including ambiguous fields like profit, marginPct, markupPct, and acquisition. The description provides no information about what these parameters mean or how they relate, so it completely fails to compensate for the missing 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 'Profit margin calculator' essentially restates the tool name business_profit_margin and adds no distinguishing scope. It does not differentiate this from the very similar sibling business_product_margin or clarify what kind of profit-margin calculation it performs.

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

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

There is no guidance on when to use this tool, when not to use it, or which alternative sibling tools such as business_product_margin or business_break_even should be preferred. The agent is left to infer usage entirely from the name.

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, and openWorldHint=false, so the safety profile is covered. The description adds nothing beyond that – it does not say what the generated draft contains, whether jurisdiction/interest rate/terms are fixed, or what the caller receives back. With annotations carrying the burden, this is a low-value addition.

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

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

Three words that are not front-loaded because there is nothing to front-load; this is under-specification, not conciseness. Every useful detail is absent rather than trimmed.

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

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

For a tool with four required parameters, no output schema, and zero schema descriptions, the definition leaves the agent unable to predict the produced document or the expected input formats. Annotations cover safety but nothing about behavior or output.

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

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

Schema description coverage is 0% with four required parameters, so the description must compensate and does not. 'amount' and 'due' are bare strings with only minLength 1 – the description gives no currency assumption, date format, or whether lender/borrower are names or entities, all of which an agent must guess.

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 'Promissory note draft' merely restates the tool name and title with no verb, no statement of what is produced, and no scope. It does not distinguish this from the many other '*_draft' siblings such as business_nda_draft, business_lease_draft, or business_offer_letter_draft beyond the noun in the name.

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

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

There is no guidance on when to use this versus the other draft-generating siblings, and no stated prerequisites. An agent must infer usage entirely from the tool name.

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, and openWorldHint=false, covering the safety profile. The description adds no behavioral context beyond the title, such as how the proposal is generated or what data is required.

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 only two words, so it is concise, but it is under-specified rather than optimally structured. It does not front-load useful constraints or help an agent decide how to invoke the 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?

This is a complex tool with 12 parameters (6 required), no output schema, and very low schema coverage. A two-word description is wholly inadequate for an agent to understand what inputs are needed or what the tool produces.

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 very low at 17%: only scope and prices have descriptions in the schema. With 12 parameters and 6 required, the description supplies no additional meaning, format hints, or required-field guidance.

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?

"Proposal builder" is essentially a restatement of the tool name and title, not a specific verb+resource statement. It does not clarify what the tool returns or how it differs from sibling document tools like contract_pack or offer_letter_draft.

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

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

The description provides no when-to-use guidance, prerequisites, or alternatives. An agent has to infer everything from the tool name alone.

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

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

Annotations already declare this as readOnly, idempotent, non-destructive, and closed-world, but the description adds no behavioral context such as what is computed, constraints on inputs, or what kind of receipt is produced. It does not contradict the annotations, but it contributes essentially nothing beyond 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 two-word description is concise but under-specified to the point of being unhelpful. Brevity here reflects missing information rather than disciplined structure.

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 four parameters, no output schema, and only safety-related annotations, the description is far too thin to explain what the tool does or how to call it correctly. It leaves both parameter meaning and expected result behavior unexplained.

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

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

Schema description coverage is 0% across four parameters, including required merchant and lines. The description says nothing about merchant, lines, date, or taxPct semantics, so it fails to compensate for the undocumented 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?

"Receipt maker" essentially restates the tool name and title without adding a specific verb, scope, output format, or distinguishing details from sibling business tools. It is a tautological description rather than a meaningful purpose statement.

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

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

The description provides no guidance on when to use this tool, when not to use it, or which sibling tool is the relevant alternative. An agent must infer usage entirely from the name.

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 and openWorldHint=false, so the safety profile is covered by structured data and the description is not obliged to repeat it. However, the description adds nothing beyond that — not what the tool emits (form text? filled document?), nor what it does with the two required inputs. A single clause on output would have earned more.

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

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

Three words is not conciseness, it is under-specification — there is no front-loaded verb-plus-object-plus-scope statement. Nothing in the fragment is wasted, but nothing earns its place either.

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 7 undocumented parameters, no output schema, and a generation-style tool whose output format is entirely unknown, this description leaves an agent unable to call the tool correctly. It should state what document is produced and what each input field means.

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

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

Schema description coverage is 0% across 7 parameters (property, landlord, rent, deposit, fee, moveIn, pets), and the description explains none of them. It does not clarify formats for rent/deposit/fee strings or the moveIn date. This is a significant gap the description fully fails to compensate for.

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?

"Rental application maker" restates the tool name and annotation title almost verbatim, adding only the word "maker." An agent can infer it produces a rental application document, but nothing distinguishes it from siblings like business_lease_draft or business_eviction_notice_draft beyond the noun.

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 gives no when-to-use guidance, no prerequisites, and names no alternative. There is nothing telling an agent when to pick this over business_lease_draft or business_contract_pack.

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, non-destructive, closed-world behavior, so the safety profile is covered. The description adds nothing beyond the name: it does not say whether the tool returns a numeric match score, matched/missing keyword lists, or both, nor how pairs of words are handled. The only behavioral hint (keyword frequency of repeated words and two-word phrases) lives in the schema, not the description.

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?

It is short and front-loaded, but in a way that reads as under-specification rather than economy — a six-word noun phrase for a three-parameter tool. Nothing is wasted, but very little is delivered either.

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

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

There is no output schema, so the description bears the burden of explaining the return value, and it does not: an agent cannot tell whether it receives a percentage, a keyword table, or a gap analysis. For a matching/analysis tool with an unspecified result shape, that is a material 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% — resume, jobPost and maxKeywords each carry clear descriptions including lengths, default 40 and the 1-100 range. The description adds no parameter meaning beyond 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 fragment 'Resume and job post keyword match' identifies the two resources and the general operation, but omits a verb and never says what a 'match' produces (a score, a keyword overlap list, missing keywords). An agent can guess the domain but not the output, and nothing distinguishes it from siblings like keyword_density or text_similarity.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives. With sibling tools such as keyword_density, text_similarity, business_resume_outline and business_blind_cv in the same family, the agent is left to infer which one fits a resume-vs-posting task.

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 and openWorldHint=false, so the safety profile is covered. The description adds nothing on top of that: it does not say that missing summary/skills/achievements get auto-drafted prompts, nor that the response contains a structured outline (and optionally a DOCX).

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?

It is short, but shortness here reflects under-specification rather than economy — a four-word fragment with no front-loaded verb, scope, or output statement. Nothing in it earns its place beyond what the tool name already conveys.

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?

This is an 8-parameter generative tool with no output schema, so the description must explain what comes back (an outline object, plus result.docx when includeDocx is true) and how defaults behave (summaryIsDraft flagging, placeholder prompts for missing achievements). None of that is present.

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

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

Schema description coverage is 75% and the schema itself documents name, title, contact, summary, years, achievements and includeDocx in detail. With coverage just under the 80% baseline, the description is expected to compensate but contributes zero parameter meaning; "builder" explains none of the 8 inputs.

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?

"Resume outline builder" merely restates the tool name in slightly different words; it never states what action is performed (generate? validate? format?) or what the output artifact is. It also fails to distinguish this from close siblings such as business_blind_cv or business_cover_letter, which an agent could easily confuse with 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?

There is no when-to-use guidance, no prerequisites, and no mention of the alternative resume-related siblings (business_blind_cv, business_cover_letter). An agent must guess from the name alone whether this is the right tool for a resume task.

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 and openWorldHint=false, so the safety profile is covered structurally. The description adds nothing beyond that: no statement that the result is a pure arithmetic estimate, no mention of currency or units, and no indication of what the returned value looks like or whether rounding applies.

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

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

Three words is concise in the trivial sense, but the rubric penalizes under-specification. There is no front-loaded scope, units, or formula, so brevity here is a deficit rather than an efficiency.

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 3-parameter calculation tool with no parameter descriptions, no output schema, and a required-parameter structure that hides the formula, the description is wholly inadequate. An agent could call it with the right types but cannot know what the numbers mean or how to interpret the result.

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

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

Schema description coverage is 0% across three parameters, and the description supplies no compensating meaning. Critically, it never explains how base, weightKg and ratePerKg combine into the estimate (e.g. base + weightKg * ratePerKg), which is precisely the information an agent cannot infer from names and types 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?

"Shipping cost estimator" just rephrases the tool name (business_shipping_estimate) without adding detail. It tells the agent nothing about what kind of shipment, carrier, region, or cost model is involved, and nothing distinguishes it from the many other numeric business calculators in the sibling list.

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

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

There is no statement of when to use this instead of alternatives. The sibling set contains overlapping calculators (business_break_even, business_marketplace_fee, business_profit_margin), and the description offers zero routing guidance between them.

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, idempotentHint and openWorldHint=false, so the safety profile is covered elsewhere. The description adds nothing beyond the name: it does not say whether output is a list, how many names are returned, whether results are deterministic given seeds, or how the limit interacts with generation.

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

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

Three words is not conciseness here but under-specification; there is no front-loaded intent statement, no scope, and nothing for the agent to anchor on beyond the title repeated in the name.

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

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

There is no output schema, so the description carried the burden of explaining the return shape but says nothing about it. For a two-parameter generator with a required 'seeds' array and a numeric 'limit', the definition omits everything an agent needs to call it 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 0%: neither 'seeds' (a required array of strings) nor 'limit' (a number with minimum 0) is documented anywhere. The description could have explained that seeds drive generation and that limit caps the number of names, but mentions neither.

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?

'Startup name generator' names a recognizable resource (startup names) and implies the action (generate), so an agent can guess the intent. However, it is a bare noun phrase with no verb, no scope, and no attempt to distinguish it from the many document/calculator siblings in the business_* family.

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 when-to-use, when-not-to-use, or prerequisite information is given. The description does not mention that it requires seeds, nor how it relates to alternatives, leaving selection entirely to the tool name.

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, idempotentHint, destructiveHint=false and openWorldHint=false, so safety and determinism are covered. The description adds the useful detail that results are expressed in years/months/days, but says nothing about default end date, accepted date formats, or timezone 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?

A single em-dash-joined line with the output units front-loaded after the resource name. No waste, though the compression is partly what leaves the parameter gaps.

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 tool with no output schema and zero schema descriptions, the description should at minimum pin down the optional endDate default and the date string format. Neither appears, so an agent could easily call it with an unsupported format or a missing-but-expected end date.

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

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

Schema description coverage is 0% for both parameters, so the description must carry the semantics and does not: it never says endDate is optional, what happens if it is omitted, what string format dates take, or whether order matters. 'Between dates' only hints that two inputs are involved.

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?

'Age calculator' plus 'years/months/days between dates' specifies both the operation and the unit granularity of the result, so an agent knows this computes a duration rather than a single number. It stops short of distinguishing itself from date-range siblings such as converters_job_experience or converters_countdown.

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

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

There is no statement of when to pick this over the many other calendar/date calculators in the sibling list, and no guidance on when endDate should be supplied versus omitted (presumably today). Usage must be inferred entirely from the one-line description.

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, idempotentHint, non-destructive, and closed-world, so the safety profile is covered. The description adds nothing further—no mention of the formula used, output format (numeric BMI vs category label), or unit 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?

It is short, but the brevity comes from under-specification rather than efficiency; there is no front-loaded actionable content.

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 3-parameter, 0%-coverage tool with no output schema and no annotations explaining units, the description is far too thin—an agent cannot reliably choose the unit or know what comes back.

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

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

Schema description coverage is 0%, so the description must carry the parameter meaning—but it does not. It never explains that `height` and `weight` must be interpreted according to the `unit` enum (metric vs imperial), which is the single most error-prone input decision for this tool.

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?

"Bmi calculator" merely restates the tool name and title, adding no verb or scope beyond what the identifier already conveys. It is a tautology rather than a specification of what is computed or returned.

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

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

No guidance on when to use this versus siblings such as calculate_bmr, calculate_ideal_weight, or estimate_body_fat. The agent must infer the distinction from names alone.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds useful method context by naming Mifflin-St Jeor and TDEE, but it does not explain how the optional activity parameter affects output or what the calculation returns.

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 short and front-loaded, with no wasted clauses. But its brevity comes at the cost of under-specification for a five-parameter calculator, so it is concise without being appropriately sized for 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 five parameters, 0% schema description coverage, an optional activity enum, and no output schema, the description needs to carry more explanatory burden. It names the formula but leaves required inputs, optional activity behavior, and return semantics unexplained.

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

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

Schema description coverage is 0% and there are five parameters, yet the description explains none of them. It does not clarify weightKg, heightCm, ageYears, sex, or the optional activity enum, so parameter semantics must be inferred entirely from field names and enums.

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 identifies BMR/calorie calculation and names the Mifflin-St Jeor formula plus TDEE, which is more specific than the tool name alone. However, it does not explicitly state the verb or clarify whether it returns BMR only or also TDEE, and it does not distinguish itself from sibling converters_tdee.

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 when-to-use guidance is provided. The mention of TDEE could overlap with the sibling converters_tdee, but the description never says when to use this tool instead of that one, nor does it explain required inputs or prerequisites.

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, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds nothing beyond that — no mention of rounding, whether the result is a single future value, how frequency affects the calculation, or whether startDate changes amounts.

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?

It is short, but this is under-specification rather than conciseness: a single noun phrase with no front-loaded action statement or constraints. Nothing is wasted because nothing is said.

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 5-parameter tool with no output schema and 20% schema coverage, the description leaves critical gaps: the shape of the return value, the default compounding frequency, and the unit of annualRatePercent. An agent cannot confidently construct a correct call from this.

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

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

Schema description coverage is only 20% — only startDate is documented, while principal, annualRatePercent, years, and frequency are bare. The word "compound" hints that frequency matters, but the description never states a default frequency, the valid range semantics, or what the returned number represents.

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?

"Compound interest calculator" merely restates the tool name and title; it names no verb, no output, and no scope. It gives an agent nothing to distinguish it from the many financial siblings such as calculate_simple_interest or calculate_loan.

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

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

There is no when-to-use, when-not-to-use, or alternative routing guidance at all, despite a crowded sibling set where calculate_simple_interest is the obvious near-miss. The agent must infer the distinction entirely from the tool name.

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, idempotentHint, and destructiveHint=false, so the safety profile is covered elsewhere. The description contributes nothing additional — no statement of what is computed, what happens with partial inputs, or what is returned, which is what would earn credit 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?

It is only two words, so there is no waste, but this is under-specification rather than conciseness. Nothing is front-loaded because there is nothing substantive to front-load.

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

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

For a tool with three interdependent numeric parameters, no output schema, and zero schema documentation, the description must carry the interpretive burden and carries none of it. An agent could not reliably call this tool correctly from the provided information.

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

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

Schema description coverage is 0% for three numeric parameters, and the description supplies no meaning at all. Critically, it never explains the relationship between originalPrice, salePrice, and discountPercent — an agent has no way to know whether to supply two of them to derive the third, or whether discountPercent overrides salePrice.

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?

"Discount calculator" restates the tool name almost verbatim and adds no verb or scope beyond what the name already conveys. An agent cannot tell from this text how it differs from the dozens of sibling calculate_* tools other than by the word "discount".

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

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

There is no when-to-use guidance, no prerequisites, and no reference to alternatives — even though the sibling list contains closely related tools like calculate_sales_tax, percentage, and calculate_tip that an agent must choose between. The intended usage is only implied by the tool name.

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, idempotentHint, non-destructive, and closed-world, so the safety profile is covered elsewhere. The description adds nothing beyond that — no note on what the scale option changes, how percent vs 4.0 results differ, or whether unweighted/weighted output is returned.

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

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

Three words are technically short, but this is under-specification rather than conciseness — there is no front-loaded purpose statement or any substantive content to structure.

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 two parameters including a nested course object, an enum whose meaning drives the interpretation of 'grade', and no output schema, the definition is far too thin. An agent knows nothing about the result format (numeric GPA vs percentage) or weighting 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?

Schema description coverage is 0%, so the description must carry the burden for the 'courses' array (objects with grade/credits) and the 'scale' enum, yet it explains neither. In particular, an agent cannot tell from the description whether 'grade' is a letter, a number on a 4.0 scale, or a percentage depending on 'scale'.

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 is 'Gpa calculator', which essentially restates the tool name and title. It implies a grade-point-average computation but names no verb, no input concept, and does nothing to distinguish it from sibling calculate_* / converters_college_cost 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?

There is no when-to-use guidance, no mention of alternatives, and no exclusions. With dozens of calculate_* and converters_* siblings, an agent gets no signal about when this tool beats converters_college_cost or converters_student_loan.

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, idempotentHint, non-destructive, and closed-world, so the safety profile is covered. The description adds nothing beyond that — not the output units (kg vs lb), not which ideal-weight formula is applied, and not that results may differ across formulas.

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?

It is short, but brevity here is under-specification rather than conciseness — the single phrase carries no front-loaded actionable information beyond the name.

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

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

With no output schema and two required inputs, the description should at minimum state the returned unit and the calculation basis; neither appears. For a simple calculator this leaves real ambiguity about what the agent will receive.

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

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

Schema description coverage is 0%, so the description must compensate and does not: heightCm units (cm vs m), valid range, and the effect of the sex enum are left entirely undocumented. The parameter names are only mildly self-describing.

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?

"Ideal weight calculator" merely restates the tool name and title; it adds no verb specification, no formula basis (Devine, Robinson, Miller?), and no scope. It does not distinguish this from closely-named siblings such as calculate_bmi or estimate_body_fat.

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

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

There is no indication of when to use this tool versus the many weight/body-metric siblings, nor any prerequisites or exclusions. An agent must guess from the name alone.

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

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

Annotations already establish that this is a read-only, idempotent, non-destructive calculation. The description adds that firstPaymentDate only labels the schedule and does not change amounts, and that short-month date handling applies, but it does not describe the full output shape or previewMonths 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 definition is a single, front-loaded sentence that identifies the calculation type before explaining the optional date behavior. It is efficient, though the dash construction packs multiple ideas into one long clause.

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

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

For a five-parameter calculator with no output schema, the description is adequate but incomplete. It covers the special date parameter, but leaves previewMonths and the main calculation parameters unexplained and does not fully describe the return values.

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

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

Schema description coverage is only 20%, with only firstPaymentDate documented. The description repeats that date's role but adds no meaning for principal, annualRatePercent, years, or previewMonths, so it fails to compensate for the low schema coverage.

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

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

The description states a specific resource and calculation type: "Loan calculator — EMI / amortizing loan." This distinguishes it from generic interest calculators, though it does not explicitly differentiate from the sibling converters_amortization 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?

It gives no guidance on when to choose this tool versus alternatives such as converters_amortization, calculate_simple_interest, or converters_student_loan. The optional firstPaymentDate behavior is explained, but that is parameter behavior rather than tool-selection 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?

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The one piece of genuine added context is naming the Naegele rule, which tells the agent the computation basis, but nothing is said about the output form or how referenceDate alters the result.

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

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

A single front-loaded fragment with zero padding. It is terse to the point of being a label rather than a sentence, but nothing in it 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 two-parameter tool with no output schema and no schema descriptions, the description leaves the agent guessing at input format (ISO date? string?), the role of referenceDate, and whether the result is a date or a gestational age. The annotations carry safety only, not semantics.

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

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

Schema description coverage is 0%, so the description is the only place parameter meaning could come from, and it supplies none: neither the required lastMenstrualPeriod nor the optional referenceDate is explained, and no date format is given. The mention of 'Naegele rule' only weakly implies that a last menstrual period is the anchor input.

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

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

Names a specific calculation (pregnancy due date) with the underlying method (Naegele rule), which is enough to distinguish it from the many other calculate_* siblings. It falls short of 5 because it never explicitly contrasts itself with neighbours like calculate_age, relying on the topic noun to do the separating.

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

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

There is no statement of when to use this versus other calculators, no prerequisites, and no guidance on what the caller must supply. An agent must infer everything from the tool name and schema.

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 crucial functional constraints that are not entirely obvious from the annotations or schema. Specifically, stating 'local rates excluded' and detailing that it uses 'US state base-rate lookup' provides key operational context beyond the safety hints.

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

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

The description is a concise, well-structured single sentence that immediately identifies the tool's function, scope, and primary modes of operation.

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 sales tax laws, defining the scope (state base rate only) and the operational boundaries (add/extract) makes this definition highly functional. It is complete enough for the agent to proceed with calling the tool given the detailed input schema.

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

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

The description provides valuable context for the tool's output logic, particularly regarding the `zip` parameter. It explains that the rate is not always deterministic (e.g., 0% for DE, NH, OR) and addresses potential failure modes, adding meaning beyond the schema's structural definition.

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 is a 'Sales tax calculator' performing 'add or extract tax.' It successfully defines the scope by explicitly noting that 'local rates [are] excluded,' which aids in differentiating it from a comprehensive tax calculation engine.

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

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

The description offers minimal guidance on when this tool should be preferred over alternatives. It does not advise the user on scenarios that would require a different sibling tool (e.g., a full tax converter vs. a base rate lookup).

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, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered structurally. The description adds nothing beyond that — no formula semantics, no note that returns are a total amount, no note about the startDate/maturityDate labeling 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?

Three words with no wasted text, but this is under-specification rather than conciseness. There is no front-loaded verb, scope, or outcome to anchor the agent.

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 four-parameter tool with no output schema and thin schema coverage needs the description to carry unit conventions and the meaning of the result. It supplies none of that, so an agent cannot reliably invoke it without inferring from parameter names alone.

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

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

Schema description coverage is only 25%, so the description is obliged to compensate and does not. It says nothing about principal, annualRatePercent (percent vs. decimal), or years, leaving the agent to guess units for three required parameters.

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

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

"Simple interest calculator" restates the tool name and annotations title almost verbatim; it names a resource but no verb or scope. It gives no basis for distinguishing this from the very similar sibling calculate_compound_interest.

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

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

There is no guidance on when to use this versus calculate_compound_interest or calculate_loan, no prerequisites, and no exclusions. The sibling list contains at least two plausible alternatives an agent cannot discriminate between.

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/non-destructive/closed-world, so mutation safety is covered. The description adds nothing beyond them on the things that actually matter for a financial calculator: contribution timing (annuity-due vs ordinary), whether annualRatePercent is compounded monthly, rounding/precision of the result, or whether the rate is nominal or effective. No output schema exists, so the description should have covered the return shape and does not.

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 line is short and front-loaded, but it is under-specified rather than concise: it is essentially a title restatement plus an acronym gloss, with no sentence that carries operational content. Brevity here costs more than it saves.

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