Optimizers MCP

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 bar is met. The description adds genuinely useful context beyond them: it clarifies this is a transformation rather than a validator, and warns that output 'may normalize formatting, so inspect output before production use' – mutation-adjacent behavior the annotations do not convey.

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

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

Four sentences, front-loaded with the core action and capped by a concrete constraint. The second sentence partially restates the first ('Use to compact small JSON, JSONL or CSV samples'), but the remainder earns its place with sibling routing and the output warning.

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 responsibly summarizes the return ('an optimized dataset representation'), and annotations carry the safety profile. Combined with the normalization caveat and sibling routing, an agent has what it needs, though it does not describe error behavior on invalid input.

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

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

Schema description coverage is 100%, so both parameters (input length limit, format enum) are already fully documented in the schema. The description's 'max 4096 input characters' merely repeats the schema constraint and adds no format-selection nuance, so baseline 3 applies.

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

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

States a specific verb and resource ('Clean or minify JSON/JSONL/CSV data') with an explicit boundary ('Transformation tool, not a boolean validator') and names the sibling it is not (is-json-safe). An agent can distinguish it from both the validity-check family and the other minify siblings without opening a schema.

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

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

Gives clear when-to-use ('compact small JSON, JSONL or CSV samples') and an explicit alternative for one case ('For ordinary JSON validity checks, use is-json-safe'). It does not address routing against the other minify siblings (is-minify-js/css, is-prompt-minify), though those cover different formats, so the gap is minor.

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, and the description does not contradict them. It adds real behavioral context beyond the annotations: the output should be reviewed before production because the rewrite can affect consent behavior and analytics tracking. It does not discuss rate limits or error modes.

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 core statement is front-loaded and clear, but the review-before-production warning is repeated twice ('review output before production' and 'check consent behavior and analytics tracking before deployment') with no added information the second time. Four short sentences where three would suffice.

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 correctly covers the return value ('Returns a rewritten Google Analytics snippet') and sets deployment expectations. The only meaningful gap is that it says nothing about failure behavior for invalid or non-GA snippet input.

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

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

There is a single parameter with 100% schema description coverage ('Existing HTML snippet containing the Google Analytics tag to optimize'), so the schema already carries the semantics. The description adds no syntax, format, or size-limit detail beyond it, making the baseline 3 appropriate.

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

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

The description gives a concrete verb and resource: 'Rewrite existing Google Analytics tag snippet.' It also preempts confusion from the 'is-*' sibling naming family by stating 'Transformation tool, not a boolean validator.' It stops short of naming a specific sibling alternative, so it lands at 4 rather than 5.

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

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

'Use when transforming an already supplied Google Analytics tag snippet' states the trigger condition clearly, and the exclusions ('does not configure GA4 accounts, install tracking or verify consent') sharpen the boundary. No named alternative tool is offered, so it is clear context without full routing 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, so safety is covered; the description goes further and discloses the implementation risk an agent would otherwise not know: output comes from a heuristic, not a standards-compliant parser, so regression-testing is advised. It also states the return shape (minified HTML text), which matters because no output schema exists.

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 short sentences that are front-loaded with purpose and each carry distinct content (scope, caution, alternatives, caveat). Slightly redundant, since the 'review results before production' and 'regression-test output' warnings say nearly the same thing twice.

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

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

For a single-parameter, no-output-schema transformer, the definition covers purpose, routing to siblings, the nature of the returned value, and the fidelity caveat. Nothing an agent needs in order to call it correctly is missing.

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

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

There is one parameter with 100% schema description coverage, including the 4096-character maxLength, so the schema carries the semantics. The description adds no format or encoding detail beyond what the schema already says. Baseline 3 applies when the schema does the heavy lifting.

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

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

States a specific verb+resource ('Conservative HTML minification') and immediately frames the operation as a text transformation, explicitly contrasting with the boolean-validator siblings ('not a boolean validator'). Combined with naming is-minify-css/is-minify-js, an agent can place this precisely in the tool family without opening any schema.

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

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

Gives an explicit use condition ('reduce whitespace in a controlled HTML fragment before delivery') plus a caution to review before production, and routes to the correct alternatives for other languages. Both when-to-use and when-to-use-something-else are stated.

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

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

Annotations already declare readOnly/idempotent/non-destructive, but the description adds real operational caveats: output should be reviewed before production, the tool is not a full CSS parser, and results should be visually regression-tested. That is material guidance an agent would not get from the structured fields. It stops short of saying exactly which constructs are or are not touched (comments, calc(), strings), which keeps it from a 5.

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

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

Four short sentences, front-loaded with the core purpose and the review warning before the alternatives. Each sentence carries distinct information (scope, alternative, tool type, return/caveat), though the warning and return sentence could be merged without loss.

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

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

For a single-param tool with no output schema, the description covers purpose, alternatives, output type ("compacted CSS source text"), and the key caveat that a full parser is not used. The one gap is not knowing what transformations are applied, which matters for an agent deciding whether the output is safe to ship.

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

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

Schema coverage is 100% and the single `code` parameter is fully documented in the schema, including its 4096-character limit, so the baseline of 3 applies. The description adds no syntax or format detail about the input beyond what the schema already provides.

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

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

States a specific verb+resource ("Conservative CSS minification") with scope qualifiers (small snippets, basic whitespace cleanup) that separate it from the is-minify-js and is-html-minify siblings. The added clarification that this is a transformation tool rather than a boolean validator further distinguishes it from the is-*-safe 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?

Explicitly names when to use it (small CSS snippets where basic whitespace cleanup suffices), when not to (complex stylesheets — use a CSS-aware build tool), and the sibling alternative for a different language (is-minify-js). Nothing is left to inference.

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

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

Annotations already declare readOnly/idempotent/non-destructive, and the description adds genuinely new behavioral context: it is not a parser, not AST-aware, is conservative, that behavior should be regression-tested, and that it returns source text rather than a boolean. The 'not a boolean validator' note corrects an expectation created by the is-* naming family.

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?

Front-loaded with the core verb and the key caveat, and nearly every sentence carries distinct information. Slightly redundant in stacking three separate negations ('Not a parser', 'not AST-aware', 'not a boolean validator'), but each targets a different misconception.

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?

Although there is no output schema, the description states the return value explicitly ('Returns compacted JavaScript source text'), and it covers input scope, limitations, and safety expectations. An agent has everything needed to call and interpret 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?

Only one parameter and schema coverage is 100%, so the schema fully documents 'code' including the 4096-char limit. The description only loosely constrains input ('small JavaScript snippets') and adds no format or syntax guidance beyond the schema, matching the baseline-3 expectation.

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+resource (Conservative JS minification / compacted JavaScript source text) and immediately distinguishes itself from the is-minify-css sibling and from real parser-based minifiers. The phrase 'Transformation tool, not a boolean validator' also disambiguates it from the many is-*-safe predicate siblings.

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?

Explicit when-to-use ('small JavaScript snippets where basic whitespace cleanup suffices'), explicit when-not ('for safe production bundling use a real JavaScript parser/minifier'), and names the alternative for CSS (is-minify-css). Nothing is left to inference.

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

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

Annotations already declare safe read-only, non-destructive behavior, and the description adds critical context: semantic equivalence is not guaranteed, phrasing or meaning may change, and results should be compared on representative tasks. This goes well beyond the structured 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 purpose is front-loaded, but the meaning-change warning is repeated in three separate sentences ('semantic equivalence not guaranteed', 'Do not assume... preserves all nuances', 'may change phrasing or meaning'), which makes the description less tight than it could be.

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?

Complete for a one-parameter transformation tool with rich annotations and no output schema: it covers purpose, usage context, safety caveats, return behavior, and corrects the potentially misleading 'is-' name. Nothing essential is missing.

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

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

The schema fully documents the single 'text' parameter with its max length. The description adds no format, syntax, or constraint details beyond what the schema already provides, so it sits at the baseline for high schema coverage.

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

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

States a specific verb ('Compress') and resource ('prompt whitespace and filler'), and explicitly clarifies it is a transformation tool rather than a boolean validator, which distinguishes it from the many is-* sibling tools. The return type ('compacted prompt text') is also 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?

Provides clear context: use before passing text to a model when token budget matters, and warns against assuming semantic preservation. It does not name specific alternative tools, but the usage scenario is well defined.

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

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

Annotations already declare readOnly, idempotent, and non-destructive, but the description adds genuinely non-redundant context: it clarifies that despite the 'is-' prefix this is a transformation, not a boolean validator, and that output is de-ANSI'd text rather than parsed log entries. That guards against a real mis-use the annotations alone would not prevent.

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 short sentences, front-loaded with the action, then usage, then the exclusion, then the output contract. Every sentence carries distinct information with no repetition of the title.

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

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

For a single-parameter pure transformation with no output schema, the description covers action, usage, boundary against a sibling, nature of the operation, and shape of the result. An agent has everything 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 description coverage is 100%, so the single 'text' parameter is already documented in the schema, and the baseline is 3. The description adds no syntax or format detail (e.g., the 4096 max length) beyond what the schema provides, only a boundary statement about not parsing entries.

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+resource ('Strip ANSI escape sequences') and explicitly disambiguates from a sibling ('For structured datasets, use is-dataset-minify instead'). The agent can distinguish this from the many is-* validator siblings without opening any schema.

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

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

Gives an explicit use case ('turning colorized terminal logs into clean text for indexing or display') and names the alternative tool with the condition that selects it. Nothing about when to reach for this vs. alternatives is left to inference.

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