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

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses that the tool reports CA information and can also run adb push when adbPush=true, which modifies the device, while noting this does not apply to TV builds. It clearly separates read-only reporting from the installation side effect.

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

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

The description is concise despite its length, organized with numbered trust paths and a clear pointer to an alternative tool. Every sentence adds meaningful information, and the structure makes it easy to parse key usage conditions.

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

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

Given the tool's moderate complexity (one optional parameter, no output schema, no annotations), the description is comprehensive. It covers the tool's output, platform-specific behavior, trust model distinction, and parameter usage, leaving no critical gaps for an agent 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?

The single parameter adbPush is fully described in the schema (100% coverage), but the tool description adds contextual meaning by linking it to the device CA install trust path and explicitly excluding TV builds. This goes beyond the schema, aiding correct parameter selection.

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

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

The description clearly states the tool's purpose: to report the CA in use, including directory, source, fingerprint, and presence/match of cert.pem/key.pem, along with per-platform instructions. It distinguishes itself from the sibling proxy_health by pointing to proxy_health.caStatus for validation-only checks, making the unique value explicit.

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

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

The description explicitly explains when to use this tool versus an alternative: 'Use proxy_health.caStatus for the same validity checks without the instructions.' It also provides detailed context for two trust paths and clarifies that adbPush applies only to phones/browsers, not TV/debug builds, preventing misuse.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It discloses the destructive behavior ('remove... all rules if no id is given'), which is important. However, it doesn't disclose whether this is reversible, whether bulk clearing affects shared state, or what happens if an id doesn't exist. The core mutation behavior is adequately disclosed.

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 that fully communicates both usage modes. Zero wasted words. Every element earns its place. Ideal conciseness for a simple 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 simple tool: 1 optional parameter, no output schema, no nested objects. The description covers the two modes adequately. However, for a destructive operation with no annotations, it could note whether the operation returns confirmation, affects persistent state, or has cascade effects on transforms referencing removed mock rules. Given the low complexity, the description is mostly sufficient but leaves some behavioral gaps.

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

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

Schema coverage is 100% and there is only 1 parameter (id), already documented with 'Rule id to remove. Omit to clear all rules.' The description adds the alternative behavior (omit = clear all), which is valuable context beyond the schema. Baseline 3 is appropriate for full coverage with a single well-documented parameter.

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 what the tool does: 'Remove one mock rule by id, or all rules if no id is given.' It uses a specific verb (remove/clear) with a specific resource (mock rules). Distinguishes from siblings like proxy_clear_transforms by naming mock rules specifically. Could mention it's a destruction-like operation but the core purpose is clear.

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 explains the two modes of use (by id vs. clear all), which is useful guidance. However, it doesn't explicitly state when to use this tool vs alternatives like proxy_clear_transforms or proxy_update_transform, nor does it warn about destructive effects of omitting the id. The dual-mode behavior is implied but the consequences aren't spelled out.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. 'Remove' implies a destructive action, and the dual mode (single vs all) is disclosed. However, it does not reveal side effects — e.g., whether clearing all rules has irreversible consequences, whether a non-existent id errors or silently succeeds, or any confirmation/undo behavior. For a destructive operation this is a moderate gap.

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

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

The description is a single concise sentence that packs both purpose and the two usage modes with zero wasted words. It is perfectly front-loaded: verb first, resource second, scope condition immediately after. Nothing extraneous.

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

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

For a single-parameter tool with no output schema, the description is reasonably complete: it explains purpose, the two modes, and the conditional semantics of the parameter. Given the tool's low complexity, this is largely adequate. A small gap: no guidance on behavior for invalid/nonexistent ids and no explicit callout that this is a destructive operation, but the 'Remove' verb already conveys that.

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

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

Schema description coverage is 100% — the single 'id' parameter is documented ('Rule id to remove. Omit to clear all.'). The description's phrase 'by id, or all rules if no id is given' reinforces the parameter's conditional semantics and explicitly covers the omit-to-clear-all usage. This adds modest value beyond the schema's own description but does not go deeper (e.g., id format, validation behavior).

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

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

The description clearly states the verb ('Remove') and resource (request transform rule) with scope distinction: 'by id, or all rules if no id is given'. It distinguishes from siblings like proxy_update_request_transform (which modifies instead of removes) and proxy_clear_transforms (which clears a different resource type — transforms vs request transforms). The title adds redundant information but the description carries clear intent.

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 clarifies the two usage modes (single rule by id vs all rules when id omitted), which is useful guidance. However, it does not explicitly state when to prefer this over proxy_clear_transforms or when not to use it (e.g., if rules need to be preserved). The context around when 'clear all' is risky vs selective removal is implied rather than explicit.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description indicates a destructive/removal action ('remove', 'clear all'), but it doesn't state whether removal is reversible, whether 'clear all' is destructive without confirmation, whether saved transform rules are affected, or whether the operation persists across restarts. For a destructive operation with zero annotation coverage, this is a meaningful gap.

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

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

One sentence, zero waste. It communicates the primary action and the id-optional behavior efficiently. There is nothing extraneous to trim.

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

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

For a simple single-parameter, no-output-schema tool, the description is largely adequate. However, given the destructive 'clear all' behavior and a large sibling family (including proxy_clear_request_transforms and proxy_clear_mocks), the lack of guidance about what 'transforms' encompasses as a category, and the absence of any note about persistence or reversibility, leaves the description slightly under-complete for a destructive tool with no annotations.

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

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

Schema description coverage is 100%, so the schema already documents the single 'id' parameter well ('Transform rule id to remove. Omit to clear all.'). The description reiterates this but adds no additional semantic value beyond the schema—it restates the same mode logic without adding format, validation, or example details. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description uses a specific verb ('remove') with a clear resource ('transform rule'), and explicitly states the two modes: remove one by id, or clear all if no id given. This is clear, though it doesn't explicitly distinguish from sibling tools like proxy_clear_request_transforms, which is a separate resource.

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

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

The description clearly states when to remove one vs all rules (by whether an id is given). However, it doesn't explicitly direct the user to a specific sibling tool for the alternative case, nor does it explain when NOT to use this tool in favor of proxy_clear_request_transforms, proxy_update_transform, or proxy_clear_mocks. The mode distinction is helpful but exclusions are absent.

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

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

With no annotations, the description carries full burden. It thoroughly discloses the tool's behavior: 'Always returns' a specific list of fields, and conditionally returns additional fields 'While the proxy is stopped.' This transparently explains the state-dependent behavior and that it is a read-only diagnostic.

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

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

The description is concise and front-loaded with 'Full preflight/diagnostics.' It efficiently lists the return fields and conditional behavior in two sentences without unnecessary fluff, earning every sentence's place.

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

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

Despite having no output schema, the description thoroughly enumerates all return values and their conditional presence. It also includes usage guidance, making it a complete and self-contained description for a simple, parameterless 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?

The tool has zero parameters and schema coverage is trivially 100%. Baseline for zero parameters is 4. The description adds meaning by explaining what the tool returns rather than parameters, which is appropriate since there are none to document.

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

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

The description clearly states the tool's purpose: 'Full preflight/diagnostics' for proxy health. It distinguishes itself from siblings by emphasizing this is the initial check to run, and the title 'Check proxy health and diagnostics (preflight)' reinforces the specific verb and resource.

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

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

The description explicitly says 'Use this first — it tells you everything needed to get running without shelling out.' This provides a clear when-to-use directive, positioning it as the preflight step before starting the proxy. It does not name alternatives or explicitly say when not to use, but the guidance is strong.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description only states that the tool lists 'active in-memory mock rules' but does not disclose what exactly is returned (format, structure), whether the list reflects only unexpired or all rules, or any side effects. While it's likely a read-only operation, the lack of explicit non-mutating behavior disclosure is a gap, especially with zero annotation coverage.

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

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

The description is a single, clear sentence with zero waste. It's appropriately sized for a zero-parameter list tool. Slightly more context on the return value could have been included, but the description is efficiently compact for what it needs to communicate.

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

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

For a zero-parameter, no-output-schema tool, the description is reasonably complete but could be richer. It doesn't describe what the returned mock rules list looks like (fields, format) or how it relates to the mock lifecycle siblings like proxy_mock_response and proxy_clear_mocks. Given the tool's simplicity and no schema/output schema to lean on, a bit more behavioral context would improve completeness.

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

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

This tool has 0 parameters, so there are no parameter semantics to convey. Per the guidelines, 0 params earns a baseline of 4. The description doesn't need to add anything about parameters since there are none to explain.

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 'View the active in-memory mock rules' clearly uses a specific verb (view/list) and resource (active in-memory mock rules). It distinguishes from siblings like proxy_list_transforms and proxy_list_traffic since it specifies 'mock rules' specifically. The title 'List active mock rules' reinforces the purpose without being a pure tautology since it adds 'in-memory' context.

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

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

The description implies the tool is for viewing mock rules that are in-memory (as opposed to persisted or transforms), which gives some usage context. However, there is no explicit when-to-use guidance, no exclusions, and no mention that it pairs with proxy_add_mock / proxy_clear_mocks for managing the mock rules lifecycle. The purpose is clear but the guidance is only implicit.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. The description only states it views the rules, with no mention of what 'active' means, whether results are sorted, whether it's a read-only safe operation, or what the output format is. With zero annotation coverage, this is a minimal disclosure.

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 concise sentence ('View the active request transform rules') with zero waste. However, it arguably lacks enough substance to be 'front-loaded' with meaningful content, making it minimal rather than rich.

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 read-only listing tool with no parameters, no annotations, and no output schema, the description is thin. It would benefit from stating that this is a safe read operation (especially given no annotations exist), clarifying the distinction from 'active' vs 'saved' transforms, and noting read-only characteristics given other sibling tools like proxy_update_request_transform and proxy_save_transforms exist.

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

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

The tool has 0 parameters and 100% schema coverage (trivially, since properties is empty). Per the rubric, 0 params = baseline 4. The description appropriately doesn't need to document parameters that don't exist.

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 title 'List active request-modification rules' is specific (verb='list', resource='request-modification rules'), and the description 'View the active request transform rules' confirms the purpose. However, the description itself is somewhat generic and doesn't differentiate from sibling tools like proxy_list_transforms or proxy_list_mocks, though the title provides clearer differentiation.

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 tool vs alternatives. Given sibling tools like proxy_list_transforms, proxy_list_mocks, and proxy_list_traffic, it would be valuable to clarify when request transforms are relevant (e.g., for HTTP request interception vs response mocking). The description does not address any usage exclusions 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?

With no annotations provided, the description carries the full behavioral burden, and it performs well. It discloses the transformOutcome values and patchesApplied count available, explicitly states sensitive headers are redacted by default and how to opt into raw values, and explains body preview options. This is substantial behavioral detail that significantly aids agent decision-making. Notably, it doesn't flag any destructive or side-effect behavior, which is important for a read/list operation.

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

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

The description is a tight, information-dense paragraph with zero redundancy. Every sentence adds value: purpose, output traits, redaction behavior, three boolean flag explanations, and export capability. It front-loads the purpose and progressively adds options. No wasted words.

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

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

For a read-only listing tool with 100% schema coverage and no output schema required, the description is thorough. It covers the key behavioral concerns (redaction, preview options, export formats), explains output fields (transformOutcome, patchesApplied), and provides the use case. It's complete enough for an agent to confidently select and invoke this 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 coverage is 100%, so the baseline is 3, and the description adds meaningful value beyond the schema. It clarifies the export parameter's JSON/HAR format rationale (Charles log-export replacement) and explains what includeSensitiveHeaders does in prose (explaining redaction default). The description reinforces parameter purpose and adds context about what each inclusion flag reveals. It loses one point because it doesn't fully clarify the 'filter' parameter semantics beyond what the schema already states.

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

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

The description states a clear purpose: inspect captured traffic to confirm a rule matched the intended request. It specifies the tool operates on 'captured traffic' and its sibling context (proxy_list_* tools) distinguishes it from mocks/transforms listing tools. It doesn't explicitly name siblings as alternatives but the context makes differentiation reasonably clear. A specific verb+resource with clear purpose, though it could explicitly distinguish from proxy_list_transforms.

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

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

The description implicitly conveys usage context (confirm a rule matched) and explains when to use flags like includeSensitiveHeaders, includeRequestBodyPreviews, and export for JSON/HAR. It doesn't explicitly say when NOT to use this vs alternatives, but the sibling tool names and context strongly imply the alternatives. The export functionality positions it as a replacement for Charles log-export workflow, giving additional context. Could be improved with explicit exclusions but is adequate.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description only says 'View' which implies a read-only operation, but doesn't describe the return format, whether the output is structured or free-form, pagination, or any side effects. For a read-only tool with no annotation fallback, this is thin.

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 concise sentence that states the purpose clearly with zero filler words. Every word earns its place.

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

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

For a zero-parameter read-only tool, the description is functionally adequate for invoking the tool. However, with no output schema and no annotation coverage, it lacks behavioral context entirely. The agent cannot know what the response will contain, which matters given the many sibling tools that might produce similar-looking 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?

The tool has 0 parameters with 100% schema coverage (empty schema properties). Since there are no parameters to document, the description doesn't need to add parameter semantics. Baseline of 4 for a 0-parameter tool is appropriate.

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

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

The description 'View the active intercept-and-transform rules' states a clear verb (View) and specific resource (active intercept-and-transform rules). It distinguishes from siblings like proxy_list_request_transforms and proxy_list_mocks by specifying 'intercept-and-transform rules'. Could be slightly clearer about what distinguishes 'transform rules' from request transforms, but the purpose is clear.

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 tool vs alternatives. With 18 siblings including proxy_list_request_transforms, proxy_list_mocks, and proxy_list_traffic, the description does not help an agent choose between listing transforms versus request transforms versus mocks. No when/when-not guidance or exclusions 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?

No annotations are provided, so the description carries full burden. It discloses the 'requires proxy to be running' prerequisite and mentions 'idempotent upsert' semantics, which is useful. However, it doesn't disclose failure behavior (e.g., what happens with invalid JSON), whether existing rules are replaced or merged, or any error conditions beyond proxy not running.

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 compact sentences that convey the purpose, the pairing with the save counterpart, and the key behavioral note (idempotent upsert, requires running proxy). The parameter-relevant detail is appropriately pushed into the schema. No wasted words.

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

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

For a single-parameter tool with full schema coverage and no output schema, the description covers the essentials: what it does, what it needs, and the operational prerequisite. The 'idempotent upsert' phrasing is a bit terse and could benefit from explaining what upsert means in this context (merge vs replace semantics). But given the simplicity of the tool, this is reasonably complete.

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

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

Schema description coverage is 100%, so the schema documents the 'path' parameter well. The description adds valuable context beyond the schema: it explains the default value behavior ('transforms.json in project root'), the allowed-directories constraint, and how to extend the allowed paths with --allowed-dir. This compensates beyond what the schema alone 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?

The description clearly states the action ('Load transform rules') with a specific resource ('from a JSON file') and references the sibling tool proxy_save_transforms as the counterpart. However, it doesn't strongly differentiate itself from proxy_update_transform or other transform-related siblings in terms of what makes this distinct.

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 mentions 'previously saved with proxy_save_transforms' implying the pairing relationship, and notes 'requires proxy to be running' as a prerequisite. However, it doesn't explicitly state when NOT to use this versus alternatives like proxy_update_transform, leaving the agent to infer when bulk-loading is appropriate.

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

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

With no annotations provided, the description carries the full burden and does an excellent job. It discloses key behaviors: default glob/substring matching against full URL, regex option, mutual exclusivity of body/bodyFile, delayMs processing time, bandwidthKbps streaming, and bodyFile directory restrictions. This goes well beyond a basic description and gives the agent critical operational context.

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

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

The description is two sentences, front-loaded with the core purpose, and every clause earns its place. It efficiently packs matching logic, body options, and simulation parameters without redundancy or fluff.

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

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

For a tool with 9 parameters, complex interactions (body/bodyFile exclusivity, regex vs glob, delay/bandwidth), and no output schema, the description provides enough context for an agent to use it correctly. It covers the main behavioral aspects and edge constraints, making it a complete standalone reference.

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

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

Schema description coverage is 100%, so the baseline is 3. However, the description adds meaningful cross-parameter guidance (e.g., 'Provide either body or bodyFile, not both'), clarifies the matching default and regex flag, and explains the semantics of delayMs and bandwidthKbps in a way not fully captured by each parameter's individual description.

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

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

The description clearly states the verb 'Add' and the resource 'in-memory mock rule', and specifies matching on HTTP method + URL pattern. It distinguishes from proxy_stop/health/list tools, though it does not explicitly differentiate from the transform-based mock tools (e.g., proxy_mock_transform), so sibling differentiation is not fully explicit.

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

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

The description explains how the tool works (matching, body options, slow-server simulation) but does not provide explicit guidance on when to use this tool versus alternatives like proxy_mock_transform or proxy_request_transform. Usage is implied through the functional details, but no when-not or alternative suggestions are given.

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

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

No annotations are provided, so the description carries the full burden. It describes the transformation behavior (patches, macros, wildcards) and the flow. However, it doesn't disclose side effects: whether this persists across sessions, whether it only applies to matching requests, whether it modifies backend behavior or just the observed response, or what happens to non-JSON responses. The in-place nature is mentioned but operational side effects are not covered.

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 well-structured sentence explaining the end-to-end mechanism, followed by a helpful syntax hint sentence. It's front-loaded with the core purpose. Reasonably efficient, though it could be tightened—the detail about macros and where-clauses is valuable enough to justify the second sentence.

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

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

Given no output schema (so return format is undefined) and no annotation, the description covers the mechanism well: how patches are applied, what the matching semantics are, and the macro syntax. It could mention edge cases (non-JSON responses, matched-URL specificity), but for an intercept-transform tool with 4 params fully described in schema, this is reasonably complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds useful semantic detail about the patch format (path wildcards, where, macros) which complements the schema nicely. However, it doesn't add anything beyond what the schema parameter descriptions already specify, so it stays at the baseline 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?

The description clearly states the action: intercept a request, forward to backend, parse JSON, apply in-place patches, return modified response. It distinguishes itself from mock tools (mocking responses) and other transform tools by specifying the in-place intercept-and-transform flow. However, it doesn't explicitly differentiate from the sibling proxy_transform tools (proxy_mock_transform vs proxy_transform vs proxy_update_transform), so it loses one point on sibling differentiation.

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

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

The description includes usage details on how to use path wildcards (`[]`), `where` for conditional matching, and time macros. It explains the execution pipeline (intercept, forward, parse, patch, return). It doesn't explicitly state when NOT to use this vs proxy_mock_response or proxy_transform, but the mechanism is fairly clear from the flow description, giving it a borderline 4.

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

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

No annotations are provided, so the description carries the burden. It does disclose several behavioral traits beyond the schema: it fetches a URL directly (side effect), applies patches non-persistently ('without registering them'), returns a sample with before/after values plus match count, and doesn't require the proxy running. However, it doesn't specify what happens on fetch failure, whether patches are applied in order, or whether the sample is a subset or all matches. Decent but not exhaustive.

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 sentences with zero waste. The front-loaded opening sentence contains the core purpose, the second sentence frames the use case and ties to the sibling tool, and the third sentence states the one operational caveat. Efficient and well-structured.

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

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

For a self-contained probe tool with 100% schema coverage and no output schema, the description covers the essential operational details: what it returns (modified samples + match count), when to use it (pre-update_transform validation), and a key runtime prerequisite (proxy not required). The only slight gap is describing failure behavior on network errors, but given the schema richness and clarity of purpose, the description is nearly complete.

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

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

Schema description coverage is 100%, with both parameters (url, patches) already described in detail in the JSON schema, including the patch sub-object structure (path, set, where), wildcard syntax examples, and special token formats like __NOW__ and __NOW_PLUS_<N><UNIT>__. The description adds the conceptual role of these parameters as a validation pipeline but doesn't substantially extend the schema's parameter-level docs. Baseline 3 is appropriate given full schema coverage.

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

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

The description clearly states the tool fetches a URL, applies given patches, returns a sample of modified fields (before/after) plus match count. It explicitly says this is a 'one-shot' test of transform rules without registering them, which clearly differentiates it from siblings like proxy_update_transform (which registers rules). The verb+resource+outcome are all specific.

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

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

The description explicitly states when to use this tool: 'Useful for verifying patch paths and wire values before calling proxy_update_transform.' This directly frames it as a pre-validation step before a sibling tool. It also discloses 'Does NOT require the proxy to be running,' which clarifies the operational precondition. This is explicit when/when-not guidance naming the alternative.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does disclose that this is an interception tool that modifies requests before forwarding to the real backend, which implies a live-traffic side effect distinct from pure mocks. It covers the key modification dimensions (headers, query, body). However, it doesn't disclose whether rules are additive, whether existing matching rules get overwritten, or any persistence behavior.

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

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

The description is two sentences with zero waste. The first sentence states the purpose and flow, the second provides practical parameter usage guidance. Every word contributes value.

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

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

For an 8-parameter tool with nested objects and no output schema, the description is reasonably complete—it explains the core flow (intercept, modify, forward, return) and how to use the major parameter groups. However, it doesn't explain the URL matching semantics (glob/substring vs regex) beyond what the schema already states, nor does it clarify edge cases like whether removing and setting a header in the same rule is supported. Given that schema covers all parameters, this is adequate.

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

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

Schema description coverage is 100%, so all 8 parameters are documented in the schema. The description adds meaningful value by grouping parameters into functional categories (setHeaders/removeHeaders for headers, setQuery/removeQuery for URL params, body for body replacement), which is helpful orientation beyond the schema's individual descriptions. This exceeds the baseline 3 for full coverage.

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

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

The description clearly states the tool intercepts and modifies requests: 'Intercept a request matching method+URL, modify it (headers, query params, body), forward to the real backend, and return the response.' It uses specific verbs (intercept, modify, forward) and explicitly lists the resources being modified. It distinguishes from sibling mock tools by framing this as request modification with real backend forwarding, though it doesn't explicitly name the distinguishing sibling.

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

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

The description gives clear operational guidance on how to use the tool: 'Use setHeaders/removeHeaders to modify headers, setQuery/removeQuery for URL params, and body to replace the request body.' This effectively explains which parameters to use for each modification type. However, it does not explicitly state when NOT to use this tool versus alternatives like proxy_mock_transform or proxy_mock_response, though the context implies this is for real-traffic interception rather than canned mock responses.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description does disclose that the tool persists to a file and overwrites/reuses after restart, which is useful. However, it does not mention potential side effects (e.g., whether it overwrites an existing file, whether file I/O failures are handled, or what happens if transforms are empty). With zero annotations, more detail would be warranted.

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

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

The description is two sentences with zero wasted words. It front-loads the core action and purpose, then adds the complementary reload reference. It's appropriately concise; the only minor gap is the absence of side-effect disclosure, but structurally it's 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?

For a single-parameter persistence tool with no output schema and no nested objects, the description covers the essential aspects well: what is saved, where, to what format, and how to retrieve it. The file-path restrictions are handled in the schema. This is reasonably complete for a tool of this simplicity.

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

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

Schema description coverage is 100%, so the schema fully documents the path parameter including default location and the --allowed-dir constraint. The description does not add parameter semantics beyond the schema. Per the rubric, a baseline of 3 applies since the schema does the heavy lifting.

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

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

The description clearly states the verb ('Save'), the resource ('both response and request transform rules'), and the output format ('to a JSON file'). It also specifies the persistence/reuse intent ('for reuse after a proxy restart'), and explicitly names the complementary sibling tool (proxy_load_transforms) to disambiguate from other proxy tools.

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

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

The description mentions the reload counterpart (proxy_load_transforms), giving context on the save/load workflow. However, it does not explicitly state when to use this tool vs. alternatives, nor does it mention any prerequisites like whether both request and response transforms must exist before saving. Usage context is implied but not fully specified.

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

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

With no annotations provided, the description carries the full burden and does well: it discloses that interception is unaffected, describes the effect on retained traffic, notes that already-captured entries are unaffected, and states that the active scope and captured-traffic count are returned. These are meaningful behavioral traits beyond 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?

The description is four sentences, with the main purpose stated immediately. Each sentence adds useful information (scope semantics, wildcards, return value, non-destructive behavior) without redundancy or fluff.

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

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

Given the tool's low complexity (one optional parameter, no output schema), the description is complete: it covers what the tool does, when to use it, parameter behavior, return value, and side effects. Nothing critical is missing.

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

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

Schema coverage is 100%, but the description adds valuable parameter semantics: subdomains are included, wildcards like '*.example.com' are allowed, and the omission/empty-array behavior is explained. This goes beyond the schema's simple example and improves agent understanding.

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

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

The description states a specific verb ('Restrict') and resource ('which traffic is retained in the proxy log'), clearly distinguishing it from sibling tools that control interception (proxy_start/stop) or serve mocks. It explicitly references the affected log (proxy_list_traffic), making the tool's purpose unambiguous.

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

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

The description gives a clear use case ('so the agent's context stays small during bug investigation') and clarifies that the proxy still intercepts all traffic, indicating this tool is for retention scoping only. However, it does not explicitly name alternative tools or state when not to use it beyond this distinction.

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

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

With no annotations provided, the description carries the full burden and does so exceptionally well. It discloses that unmatched requests pass through, that scope only affects retained logs (not MITM behavior), and that the proxy still MITMs all hosts. This goes beyond a simple 'start' operation and sets accurate expectations, including a caveat about the Android emulator alias.

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 paragraph of four sentences, front-loading the core purpose in the first sentence. Each sentence earns its place: purpose/output, passthrough behavior, and a specific configuration hint. No redundant filler, perfectly 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?

Given the tool's complexity (5 parameters, no output schema, no annotations), the description offers a complete picture: what it does, what it returns (LAN IP:port), how to use it with emulators, and how scope affects logging. It even warns about the proxy MITMing all hosts despite scope, covering edge cases. This is sufficient for an agent to invoke and interpret the result correctly.

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

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

The input schema already has 100% coverage with detailed per-parameter descriptions, so baseline is 3. The description adds extra value by explicitly explaining the practical use of hostRewrites (mapping 10.0.2.2 to 127.0.0.1) and clarifying that scope only controls log retention, not actual MITM behavior. This enriches the schema's information, justifying a 4.

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

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

The description clearly states the tool's primary action: 'Bring up the mockttp HTTPS MITM proxy.' It also specifies the output ('Returns the LAN IP : port') and distinguishes itself from siblings by being the start operation, unlike proxy_stop or proxy_list_traffic. The verb 'Bring up' is specific to the resource.

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 provides valuable contextual guidance, such as using hostRewrites for Android emulator devices and clarifying that unmatched requests pass through to the real headend. However, it does not explicitly contrast with alternatives like proxy_mock_response or proxy_scope, though the tool's role as the start command makes this implicit. The guidance is specific enough to be actionable.

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

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

With no annotations provided, the description carries the full burden. It discloses valuable behavioral traits: auto-saving transforms to transforms.json and the side-effect that device proxy configuration may persist after stopping. This is meaningful behavioral transparency beyond the basic 'stop' action, though it could mention whether traffic is affected or requires restart.

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

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

Two concise sentences, zero wasted words. Front-loaded with the core action ('Stop the proxy') followed by important side-effects. Each sentence earns its place, though it could arguably be more dense with additional behavioral context.

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

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

For a zero-parameter, no-output-schema tool, the description is reasonably complete. It covers the action, the persistence behavior, and a follow-up recommendation. It could benefit from noting whether stopping is idempotent or whether the proxy must be running first, and what the return indicates, but these are minor gaps for a simple stop operation.

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

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

The tool has 0 parameters, so schema coverage is trivially 100% and there's nothing for the description to add about parameter semantics. The baseline of 4 for zero-parameter tools applies. The description correctly focuses on behavior rather than parameters.

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

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

The description clearly states the tool stops the proxy. It distinguishes effectively from siblings by referencing start ('Stop the proxy' vs proxy_start), health checking (proxy_health), and transform saving (proxy_save_transforms). The verb+resource is specific and clear, though it doesn't explicitly name the sibling alternative.

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

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

The description provides clear operational context: transforms are auto-saved for next restart, and it warns that the device proxy may still be set, recommending proxy_health to detect this. It implies usage context well with the health check recommendation, though it doesn't explicitly enumerate when-not-to-use scenarios.

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

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

No annotations are provided, so the description carries the full burden. It discloses the idempotent upsert semantics and that existing same-key properties are replaced, which is valuable. However, it does not disclose mutation effects, whether existing rules get destroyed, auth/permission requirements, or any side effects on other rules sharing the same method+url.

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 just two sentences and both earn their place: the first explains what the tool does, the second clarifies the idempotent replacement semantics. Efficient and front-loaded with the primary action.

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 8 parameters, 2 required, nested objects, and no annotations or output schema, the description is reasonably complete for purpose but could clarify relationships to sibling transform tools and explain the upsert key more. The core behavior is clear, though behavioral side-effects and return value expectations 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 100%, so all 8 parameters are already documented in the schema. The description adds the 'idempotent upsert' key concept that ties method+url+regex together but does not add per-parameter meaning beyond schema. Baseline 3 is appropriate given the full 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 title and description state a specific verb+resource ('Add or update a request-modification rule'), and the description names the exact key ('method + url + regex') used for upsert semantics. It clearly distinguishes from siblings like proxy_mock_transform (mocking) and proxy_update_transform (transforms generally) by specifying it handles REQUEST transforms specifically.

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 explains the idempotent upsert behavior and the uniqueness key, which conveys when this replaces versus inserts. However, it does not explicitly name sibling alternatives or state when NOT to use this tool versus proxy_request_transform, proxy_update_transform, or proxy_save_transforms. The differentiation from siblings is implied rather than explicit.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It does disclose the key idempotency behavior ('if a rule with the same key exists, its patches are replaced'), which is the critical behavioral trait. However, it doesn't fully disclose what happens with non-key fields, whether partial updates occur, or confirmation/return behavior. Still, the key behavioral aspect is well covered.

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

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

Two sentences accomplish everything needed: the primary action with the key structure, the replacement behavior, and when-to-use guidance. Zero waste, front-loaded with the verb and purpose. Efficient and dense.

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

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

For a tool with no output schema and no annotations, the description plus the very well-documented schema (100% coverage) gives a complete picture. The patches parameter has rich documentation about __NOW__ macros and dotted-path syntax. The only gap is the lack of return-value/confirmation info, which is common for such tools and not severe given no output schema exists.

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

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

Schema coverage is 100%, so the schema already documents all 4 parameters well. The description adds value by explaining the logical key structure (method + url + regex) that ties the parameters together conceptually, which the schema doesn't convey. The url description in schema already provides substantive guidance about glob/substring matching and short substring advice.

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

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

The description clearly states the tool's function: idempotently upsert a transform rule keyed by (method + url + regex). It explicitly distinguishes this from clear+re-add approaches and names the sibling proxy_mock_transform context. The title adds 'intercept-and-transform rule' clarity. This is specific verb+resource+behavior.

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

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

The description explicitly says 'Use this instead of clear+re-add to avoid auto-review friction,' providing direct usage guidance and a rationale. It implies when to use this vs alternatives by highlighting the idempotent upsert benefit over clearing and re-adding rules.

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

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

No annotations are provided, so the description carries the behavioral burden. It identifies the operation as reporting versions, changelog, and npm status, which implies a read-only action with no destructive consequence. It does not explicitly assert 'no side effects' or mention the network dependency for the npm check, but the described behavior is unambiguous.

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

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

The description is two sentences, front-loads the specific outputs, and then adds a practical use case. Every clause contributes and there is no redundancy.

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

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

With one optional parameter, full schema coverage, and no output schema, the description adequately covers the tool's purpose and report categories. It explains what the tool returns (version, changelog, npm status) and gives a motivating example, making it complete for a simple informational 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?

The single optional sinceVersion parameter is fully documented in the schema ('Only list changes after this version, e.g. '0.1.0'. Omit for all releases.'). The description reinforces this with 'optionally since a specific version' but adds no format-level meaning beyond the schema, so baseline 3 is appropriate.

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

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

The description opens with 'Report the running server version, the changelog for recent releases..., and whether a newer version is published on npm,' using a specific verb and enumerating concrete outputs. This clearly distinguishes it from sibling control tools like proxy_stop or proxy_update_transform by focusing on version/release information.

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

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

It explicitly states 'Use this to learn what changed in recent releases — e.g. when in-repo skills seem out of date — without leaving the MCP,' giving a clear when-to-use scenario. However, it does not mention alternatives or when not to use it, so it stops short of a 5.

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