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 does usefully disclose the scope of destruction ('all captured HTTP traffics and body binaries'), implying a total, unfiltered wipe, but says nothing about irreversibility, permissions, or confirmation requirements.

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

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

A single front-loaded sentence with zero filler; it conveys verb, scope and target in one pass.

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 no-parameter, no-output-schema cleanup tool this is close to sufficient, but it stops short of stating whether the clear is permanent or how an agent should confirm success.

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 takes zero parameters, so the baseline of 4 applies. There is nothing for the description to add on the parameter front.

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

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

Names a specific verb ('Clears') and precise resources ('all captured HTTP traffics and body binaries'), which separates it from siblings like clear_system_logs and clear_rewrite_debug_events. It does not explicitly reference siblings, so it stays 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?

There is no statement of when to use this tool, when not to, or which alternative applies. The agent must infer usage purely from the verb 'clear' and the resource name.

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

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

No annotations are provided, so the description carries the full burden; it correctly discloses the scope-of-destruction behavior (full projection cleared when trace_id is omitted), which is the highest-value trait for a clear tool. It does not mention irreversibility, permissions, or confirmation requirements, leaving some behavioral gaps.

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

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

Two tight sentences, zero filler, with the destructive-scope warning front-loaded before the optional parameter nuance. Every clause earns its place.

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

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

For a single-optional-parameter destructive tool with no annotations and no output schema, the description covers the essential scoping risk. It falls slightly short of complete by omitting whether the clear is recoverable and whether any confirmation/permission is needed.

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

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

Schema description coverage is 100% and already documents trace_id and its omission semantics, so the schema does the heavy lifting. The description reinforces the omission consequence with an intent caveat but adds no new syntax or format detail.

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 ('Clears structured rewrite-debug events'), which cleanly distinguishes it from the sibling read tool get_rewrite_debug_events. An agent can pick it out without opening the schema.

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

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

Explicitly tells the agent when to pass trace_id (single-request clear) versus when to omit it (whole debug projection), and frames the omit case with 'only when intentionally', which is real guidance rather than restating the schema.

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

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

No annotations are provided, so the description carries the full burden. It does disclose what is destroyed (the contents of lemoncore.log), which is useful, but says nothing about irreversibility, required permissions, or whether the logs are archived before clearing — significant omissions for a destructive operation.

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

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

Two short sentences with the action front-loaded and no wasted words. Everything stated 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-param, no-output-schema tool the description covers purpose and a use case, but with no annotations and a destructive action it leaves the safety profile (reversibility, permissions) unaddressed. Minimally 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?

The tool takes zero parameters, so there is nothing for the description to clarify beyond the schema. Baseline for a no-parameter tool applies.

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

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

The description states a specific verb ("Empties") and a specific resource ("Lemon core engine root logs (lemoncore.log)"), naming the exact artifact affected. This is enough to distinguish it from sibling readers like fetch_system_logs and other clear_* tools, though it never explicitly contrasts itself with them.

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 offers one scenario for use ("before starting a fresh capture to isolate issues"), which implies context but stops short of stating when-not to use it or naming alternatives such as reading logs first via fetch_system_logs. Adequate but with clear gaps.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it says nothing about side effects: whether closing destroys the page's session/state, whether it can be reopened with open_web_page, or whether it is a safe idempotent action. A single sentence naming the target object does not disclose enough for a state-changing 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?

One short sentence with no filler, front-loaded with the action. It is appropriately sized, though it is arguably too terse for a state-changing tool rather than genuinely tight.

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 minimally adequate, but with no annotations it leaves the agent without any information about side effects or the resulting state. It names what is closed but not what the agent should expect afterward.

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 takes zero parameters, so there is nothing for the description to add and the baseline of 4 applies. The description does not misdescribe any inputs.

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

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

States a specific verb (closes) and resource (the Lemon iOS embedded WKWebView), which is unambiguous and distinct from sibling actions like refresh_web_page, go_back_web_page, and go_forward_web_page. It does not explicitly contrast itself with those siblings, so it stops short of a 5.

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

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

The description offers no when-to-use or when-not-to-use guidance, no prerequisites, and no mention of the related open_web_page sibling that would restore state. The context is inferable from the verb alone but nothing is stated.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses that the item is stored in Lemon's local runtime database and can be executed later, but omits whether creation requires specific permissions, how duplicates are handled, or any mutation safety profile for a write operation.

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

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

Two short sentences with zero filler, and the core purpose is front-loaded. The follow-up execution note is a useful second sentence that 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?

The description covers the tool's basic purpose and follow-up action, and the schema fully documents the five parameters including the nested headers object. However, without annotations or an output schema, a mutation tool of this complexity would benefit from more context on permissions, failure behavior, or runtime prerequisites.

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 every parameter is fully documented in the schema itself. The description adds no parameter-level detail beyond what the schema already provides, making the baseline score of 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?

States a specific verb ('Saves/Create') and resource ('HTTP replay item') with clear scope. It distinguishes itself from siblings like update_replay_item and delete_replay_item via 'new', and names the follow-up tool execute_replay_item.

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?

Implies the item is created for later execution and names the executing sibling, giving useful workflow context. However, it does not explicitly compare against alternatives such as update_replay_item or execute_replay_request, nor does it state when not to use this tool.

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

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

With no annotations, the description carries the full burden and discloses several runtime behaviors: tasks are locally stored, enabled by default unless enabled=false, packages must export onSchedule(input), and interval bounds (250..86400000 ms). It does not describe permissions or sandboxing beyond the manifest object in the schema, leaving some operational context uncovered.

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 front-loaded with the main action, then branches into mode-specific rules and defaults in a logical order. It is a bit dense with multiple independent constraints packed into four sentences, but every sentence adds a distinct constraint.

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 a rich nested schema and no output schema, the description covers the critical creation-time constraints and mode branches. It omits some higher-level context like where tasks execute or how scheduled runs are observed, but those are arguably outside the scope of a create tool.

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

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

Schema description coverage is already 100%, so the schema documents all 8 parameters. The description adds cross-parameter logic: script_type=single pairs with script, script_type=package pairs with script_package, and the onSchedule(input) export requirement for packages. This meaningfully supplements the schema.

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

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

The description opens with a specific verb and resource: 'Creates a locally stored Cron or millisecond-interval JavaScript task.' It distinguishes itself from siblings like update_scheduled_task and list_scheduled_tasks by naming the exact creation action and execution model.

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 clearly explains when to use each script_type mode and the schedule variants, but does not explicitly point to alternative tools for editing, enabling, or deleting tasks. The usage context for creation is well covered.

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 does disclose a meaningful trait beyond the name: the deletion is applied immediately with no second confirmation, warning the agent that the action is irreversible. It omits other behavioral facts an agent needs, such as whether deleting a non-existent UUID errors, permission requirements, or idempotency.

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

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

Two short sentences, front-loaded with the action and resource, with the side-effect warning immediately after. No filler, though the second sentence could have carried more than the single immediacy fact.

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

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

For a one-parameter destructive tool with complete schema documentation and no output schema, the description covers the action, the identifier, and the key side effect. The remaining gap is that no annotations exist to cover the safety profile, so more behavioral detail would have been welcome.

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

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

Schema description coverage is 100% and the single parameter ('id', Host mapping UUID) is fully documented in the schema. The description echoes 'by UUID', adding no format, constraint, or sourcing information beyond what the schema already provides, so the baseline of 3 applies.

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

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

States a specific verb and resource ('Deletes a native DNS custom Host mapping') plus the identifier type ('by UUID'), which distinguishes it from list_host_mappings and upsert_host_mapping in the sibling set. It stops short of naming those siblings or the relationship between them, so it is clear but not fully differentiated.

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

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

There is no guidance on when to use this tool versus the sibling upsert_host_mapping or list_host_mappings, nor any prerequisite such as looking up the UUID first. Usage is only implied by the verb 'Deletes'.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that all immutable revisions are deleted as a cascade, but it omits required permissions, irreversibility/confirmation behavior, and any runtime side effects.

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

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

A single, front-loaded sentence with no wasted words. The destructive scope is stated immediately.

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

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

Complexity is low (one param, complete schema, no output schema), but the tool is destructive and has no annotations. The description covers the core action and cascade effect but leaves safety and usage context thin for an irreversible 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?

Schema coverage is 100% and the single module_id parameter is fully documented in the schema. The description adds no parameter syntax, format, or constraint information beyond what the schema already provides, so the baseline of 3 applies.

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

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

States a specific verb (Deletes) and resource (installed UI Module), plus the cascading scope (all immutable revisions). This clearly separates it from sibling tools that delete rewrite scripts or rules, though it does not name a sibling for comparison.

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

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

No explicit when-to-use, when-not-to-use, or alternative guidance is provided. The description implies deletion but does not help an agent choose between this and rollback_module, toggle_module, or set_module_enabled.

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

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

With no annotations, the description carries the full behavioral burden. It implies removal but never states that deletion is permanent/irreversible, whether it needs confirmation, or what happens when the UUID does not exist. Only the 'one item' scoping is 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 front-loaded sentence with the verb first and zero filler. 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 one-parameter delete tool with no annotations and no output schema, the definition is minimum viable. It leaves the irreversibility of the operation and any success/failure behavior undocumented, which an agent would want before calling a destructive tool.

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

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

Schema description coverage is 100% and the id property already documents itself as 'Saved replay item UUID'. The description only restates 'by UUID' without adding format, constraint, or lookup semantics, 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 (Deletes) and resource (one saved HTTP replay item), which cleanly separates it from the get/create/update/list_replay_item siblings by implication. It stops short of naming an explicit sibling or scope constraint, so it is clear but not fully differentiating.

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

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

The description offers no when-to-use guidance, no prerequisites, and no mention of how it relates to execute_replay_item or update_replay_item. An agent must infer that this is the deletion counterpart to create/update from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: not that deletion is irreversible, not whether it requires elevated permissions, not whether it affects active traffic or requires a runtime reload. For a destructive mutation tool this is a significant 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, front-loaded with the verb and resource, no filler. It is efficient, though its brevity is partly under-specification rather than disciplined conciseness.

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

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

A destructive, zero-annotation, no-output-schema tool whose only documentation is a single sentence leaves out irreversibility, authorization needs, and post-delete effects. An agent can call it, but cannot predict the consequences.

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

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

Schema description coverage is 0%, so the description must compensate. It does clarify that 'id' is the numeric rule identifier rather than a name or script ID, but that only restates the schema's type and adds no format, range, or lookup guidance.

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

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

States a specific verb (Delete) and resource (rewrite rule) plus the identifier form, which is enough to separate it from delete_rewrite_script, delete_module, and delete_host_mapping. It stops short of explicitly naming the closest sibling it must not be confused with.

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

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

There is no when-to-use or when-not-to-use guidance, no prerequisites (e.g. does the rule need to be disabled first, or does the runtime need a reload after deletion). Usage is only inferable from the verb.

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

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

No annotations are provided, so the description carries the full burden. It implies a mutation but never states that deletion is permanent/irreversible, whether it requires confirmation or specific permissions, or what happens to revisions of the script. 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?

A single short sentence with the action and resource front-loaded and no filler. It is efficient, though it is arguably too terse given the destructive nature of the operation.

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

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

For a one-parameter tool with no output schema, the description covers the minimum needed to invoke it, but with no annotations it omits the destructive/permanence semantics and the relationship to rollback_rewrite_script that an agent would need to act safely.

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

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

Schema description coverage is 0%, but there is only one parameter and the description adds the 'numeric ID' hint that matches the schema's integer type. It does not clarify where such an ID comes from (e.g. list_rewrite_scripts), so it adds only marginal value.

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

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

States a specific verb ('Delete') and resource ('rewrite script'), which cleanly separates it from delete_rewrite_rule (different resource) and rollback_rewrite_script (different verb). It does not explicitly name those siblings, but the resource naming is precise enough for correct selection.

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

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

No when-to-use guidance is given. Notably, the sibling rollback_rewrite_script exists as a non-destructive alternative, and the description never says when to delete versus roll back, nor whether prerequisites (e.g. script must be inactive) apply.

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. 'Deletes' implies a destructive, likely irreversible mutation, but the description never says whether deletion is permanent, what happens if the id does not exist, or whether any permission is required. It adds only the 'locally stored' qualifier, which is modest context for a destructive 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?

A single short sentence with the verb and scope front-loaded and no filler. It is efficient, though the extreme brevity means it omits information a destructive tool arguably needs.

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

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

For a one-parameter destructive tool with no annotations and no output schema, the description should disclose irreversibility, error behavior for a missing id, or authorization needs. It covers none of these, leaving the agent with only the bare action.

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 as 'Scheduled task id' with a type and range constraint. The description's 'by id' restates the schema rather than adding format or semantics, so the baseline 3 for high coverage 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 ('Deletes') and resource ('scheduled task'), plus scope qualifiers 'one', 'locally stored', and 'by id'. It implicitly distinguishes itself from neighbors like delete_rewrite_rule or delete_module by naming the resource, though it never explicitly contrasts with siblings such as get_scheduled_task or set_scheduled_task_enabled.

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

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

There is no when-to-use, when-not-to-use, or alternative guidance. It does not say whether to prefer set_scheduled_task_enabled for soft disabling, nor does it mention prerequisites such as the task existing. The reader must infer all usage context from the name alone.

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

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

No annotations are provided, so the description carries the full burden. It discloses only a soft advisory about read-only queries; it omits whether the enforcement is real or advisory, what SQL dialect features are supported, transaction/rollback behavior, row/time limits, and the shape of results.

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 tight sentence with the action and target front-loaded. The trailing parenthetical is slightly awkward but does not waste much space.

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 that accepts arbitrary SQL with no annotations, no output schema, and no result-shape documentation, the definition is too thin. An agent cannot tell how results are returned, whether queries are capped, or what errors to expect – key gaps for an unconstrained SQL executor.

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 'query' parameter is already documented as a standard SQLite SQL string. The description adds only the target database context, so the baseline 3 for a fully-covered schema is appropriate.

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

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

States a specific verb+resource: executes a raw SQL query against the Lemon SQLite database. Clearly distinct from all siblings, which deal with modules, rewrite rules, scheduled tasks, and traffic rather than direct DB access. Only sip is the vague qualifier 'diagnostic'.

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

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

No explicit when-to-use or when-not-to-use guidance, and no pointer to alternatives. The parenthetical '(Read-Only queries advised)' hints at intent but does not tell the agent when raw SQL is preferable to the many purpose-built sibling tools like list_rewrite_rules or search_traffic_previews.

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 usefully discloses the side effect ('Saved execution status is updated') and that it returns a response preview, but says nothing about permissions, idempotency, failure behavior, or network side effects of firing a live request.

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

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

Two sentences, no waste, with the core action and the runtime path front-loaded and the side effect last. Every clause earns its place.

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

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

With no annotations and no output schema, the description is responsible for more than it delivers. It covers the action, the return preview, and the state mutation, but omits error paths and safety/permission context needed for an execute-and-mutate 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?

Only one parameter exists and schema description coverage is 100%, so the schema already documents the UUID fully. The description adds no format or constraint detail beyond what the schema provides, which is the baseline case.

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 ('Executes one saved HTTP replay item') with the notable implementation detail of the native URLSession/runtime path, which implicitly distinguishes it from the sibling execute_replay_request. It is clear, though it never explicitly names the sibling it differs from.

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

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

There is no guidance on when to use this versus the closely-named sibling execute_replay_request, nor any prerequisites or exclusions. The agent must infer the 'saved item' vs 'ad-hoc request' distinction from the name and prose alone.

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

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

No annotations are provided, so the description carries the full burden. It discloses that this is a one-shot execution and that it does not save the request, but omits important behavioral details such as authentication/authorization requirements, side effects, rate limits, or what the response contains. It adds some value but is insufficient for a network request executor.

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

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

Two concise sentences with no wasted words. The primary action is front-loaded, and the usage guidance follows efficiently.

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

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

Given no annotations and no output schema, the description is somewhat incomplete. It fails to cover return values, error handling, or security constraints. It touches on the core purpose and one usage scenario but leaves notable gaps for a tool that makes outbound HTTP requests.

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 all parameters including url, method, body, and headers. The description adds no parameter-specific information beyond the schema, making a baseline of 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 uses a specific verb and resource ('Executes a one-shot HTTP replay') with a key qualifier ('without saving it'). It doesn't explicitly differentiate from the closest sibling 'execute_replay_item', though the one-shot/no-save wording implies a distinction.

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

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

It explicitly states when to use it: after inspecting a captured request with get_captured_request, or for an ad-hoc request. This is clear context, but it doesn't explain when to use a saved replay item (execute_replay_item) instead of the one-shot execution.

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 behavioral burden. It says 'fetching' (read operation) and 'full request/response bodies' (binary content), but doesn't disclose size limits, whether the payload is returned inline or as a file path, or any authentication requirements. This is a significant gap for a tool that likely returns large binary blobs.

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

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

A single efficient sentence that front-loads the action. No wasted words, though the phrase 'deep-dives into a specific HTTP payload' is slightly colorful for a tool description.

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 annotations, no output schema, and binary payload retrieval, the description is incomplete. It doesn't explain what the returned binary payload looks like, sizes, or how to work with it. The parameter schema covers the input fully, but the behavioral and output expectations are unaddressed.

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. The schema already documents that path is the physical .bin path discovered from previews. The description adds no parameter detail beyond what the schema provides, 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+resource: fetching full request/response bodies for a specific HTTP payload. The concept of 'deep-dive into a payload' is clear, but 'payload' is somewhat jargon-y and it doesn't distinguish clearly from siblings like get_captured_request or search_traffic_previews that also deal with HTTP traffic.

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

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

No explicit when-to-use guidance. The description implies it's for fetching binary bodies that previews don't contain, but it doesn't state when to use this vs get_captured_request or search_traffic_previews. An agent must infer usage from context.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses scope (non-database files, AppGroup container) and where ESM packages actually live, but omits whether the operation is read-only, size/error behavior, or permission requirements.

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, purpose front-loaded with the routing caveat second. Efficient with no obvious filler, though the second sentence is somewhat narrow relative to the tool's general scope.

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

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

With no output schema and no annotations, the description adequately covers what is fetched and where, plus a key misrouting warning. It lacks return-format and failure-mode context, but is complete enough for a simple single-parameter read tool.

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

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

Schema description coverage is 100% and the single path parameter already has example values in the schema. The description adds no syntax or format detail beyond what the schema provides, so the baseline 3 is appropriate.

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

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

States a specific verb (Fetches) and resource (a specific non-database file from the iOS device's AppGroup container), and the 'non-database' qualifier plus the named sibling get_rewrite_script_package lets an agent distinguish it from related tools without opening schemas.

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

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

Explicitly routes the agent: for ESM rewrite script packages, use get_rewrite_script_package instead, and warns not to look for RewriteScripts/*.js files. This is a clear when-not/alternative for one important case, though it doesn't address other siblings like fetch_binary_payload or fetch_system_logs.

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 present, the description carries the full burden. 'Safely reads' correctly signals a non-destructive read and naming the exact log file adds real context, but it omits permission requirements, whether reads rotate/truncate logs, and any rate or size limits beyond the schema's bytes parameter.

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

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

Two tight sentences, front-loaded with the action and resource, then the use case. 'Safely' and 'Suitable for large log files' are the only vaguely filler-ish bits, but every sentence contributes.

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

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

For a one-parameter read tool with no annotations and no output schema, the description covers purpose and file target but says nothing about the return shape (raw log text? truncated?) or failure behavior when the log is absent. Adequate but with a visible gap.

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

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

Schema description coverage is 100%, and the single 'bytes' parameter is already fully documented in the schema (default 102400, ~1500 lines, when to increase). The description adds nothing about parameters, so the baseline 3 applies.

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

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

States a concrete verb (reads the tail) and a precise resource (lemoncore.log, the Lemon core engine log), plus the intent (analyzing system/runtime network errors). It is clear on its own, though it never names a sibling such as clear_system_logs to disambiguate log-related operations.

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 phrase 'to analyze system or runtime network errors' and 'Suitable for large log files' imply when this tool is appropriate, but there is no explicit when-not guidance or comparison against alternatives like fetch_device_file or clear_system_logs. Usage is only inferred, not stated.

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

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

No annotations are provided, so the description carries the full burden. It does disclose a genuinely useful behavioral trait — that body metadata distinguishes missing, empty, text, and binary-file payloads, hinting that binary content is not inlined — but it says nothing about permissions, size limits, or failure modes when an id is stale.

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 dense sentence, front-loaded with the verb and resource, with no wasted clauses. It is slightly overpacked by enumerating three identifier types that the schema does not support.

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 should explain what comes back; it only gestures at body metadata categories and leaves the response shape otherwise unspecified. For a detail-fetch tool this is adequate-but-thin, and the identifier mismatch with the schema is left unresolved.

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

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

Schema description coverage is 100% for the single trace_id parameter, so the baseline is 3. The description's claim that transaction_id and a legacy database id also work is not reflected in the schema, which adds ambiguity rather than meaning.

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 (reads) and resource (one complete captured request/response) plus the lookup keys, and its sibling search_traffic_previews is named as the source of identifiers, so an agent can tell the preview-list tool from the full-detail tool. The only wrinkle is that it advertises three key types (transaction_id, trace_id, legacy database id) while the schema accepts only trace_id.

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 reference to search_traffic_previews implies this is the follow-up call when you need full bodies rather than preview listings, but there is no explicit when-to-use/when-not statement or exclusion. Usage is inferable rather than stated.

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

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

No annotations are provided, so the description carries the full burden. It states a read but doesn't disclose whether the value is cached, whether it can be null/unset, whether it requires a device connection, or any failure modes. Minimal behavioral context.

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

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

A single, front-loaded sentence with no waste. Appropriate sizing for a zero-parameter getter.

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 no-param read with no output schema, an agent still lacks whether the return is a URL vs IP, format, and behavior when unset. Adequate but leaves gaps that could be closed in one sentence.

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?

Zero parameters, so per the rubric the baseline is 4. The description correctly implies no inputs are needed, and there is nothing to mis-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?

States a specific verb (Retrieves) and a specific resource (the current network URL/IP used for iOS device communication). This is clear and distinguishable, though the sibling set_lemon_target_ip is a natural counterpart that the description doesn't explicitly differentiate from.

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?

Implies usage as a read of the current target IP, but gives no explicit when-to-use guidance, no mention of the paired set_lemon_target_ip, and no context about when this value would be needed (e.g., debugging connectivity). Minimum viable.

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

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

With no annotations, the description carries the full burden; 'Fetches' implies a read-only operation and it usefully discloses the payload contents (manifest plus ESM sources), which is more than the schema says. However, it omits behavioral traits such as payload size, whether sources are truncated, or auth requirements for historical revisions.

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

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

A single front-loaded sentence with the core action and payload named first and no filler. Every clause (complete manifest, ESM sources, active or historical) 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?

There is no output schema, so the description must characterize the return value, and it does so by naming the manifest and ESM sources. For a two-parameter read tool with full schema coverage this is nearly sufficient; only the size/shape of the returned package is left implicit.

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

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

Schema description coverage is 100%, so both module_id ('Reverse-domain Module id') and revision ('Optional historical revision') are already documented. The description's 'active or historical' phrasing loosely maps to the revision parameter but adds no format or default detail beyond the schema, making the baseline 3 correct.

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 (Fetches) and resource (complete manifest and ESM sources for a Module revision), which is more precise than the sibling list_module_revisions or inspect_module. It never names an alternative or explicitly contrasts scope, so it stops short of full 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?

'active or historical Module revision' implies that supplying the revision parameter retrieves history and omitting it gets the current version, giving implicit usage context. There is no explicit when-to-use/when-not guidance and no routing to siblings such as get_rewrite_script_package or inspect_module.

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

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

With no annotations, the description carries the full burden, and it does disclose the report's content (workers, leases, runtime limits), which is useful behavioral context. However, it never states that the call is side-effect-free, whether it requires elevated permissions, or whether it can be expensive on a busy runtime.

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

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

A single front-loaded sentence with no filler or repetition. It is tight, though it is short enough that it could have afforded one more sentence of routing guidance without becoming bloated.

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

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

There is no output schema, so the description is the only source for return content, and it lists the three reported categories only in outline form with no structure or units. For a zero-param diagnostic read it is adequate but not 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. No parameter-level detail is needed or missing.

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 (Reports) and resource (Module runtime status), and enumerates what is covered: active workers, leases, and runtime limits. The 'Module' qualifier separates it from the near-identical siblings get_rewrite_runtime_status and get_scheduled_task_runtime_status.

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 call this versus siblings like inspect_module, list_modules, or get_rewrite_runtime_status. The read-only inspection intent is only implied by 'Reports', with no exclusions or prerequisites stated.

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

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

No annotations are provided, so the description carries the full burden. It mentions the return content (request headers and body) but does not disclose authorization requirements, error behavior for invalid UUIDs, whether the item is cached, or rate limits. For a read tool with zero annotation coverage, this is a significant gap.

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

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

A single, well-structured sentence that front-loads the verb and resource. Every word earns its place; no redundancy or filler.

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

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

For a tool that reads a single resource, the description mentions the return fields (headers and body) but omits critical context: there is no indication of authentication needs, no mention of error handling, and no output schema to fall back on. With no annotations, the description is insufficient to fully understand behavioral aspects.

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 parameter is already fully documented. The description adds no additional meaning beyond the schema, but the baseline for high coverage is 3. A 3 would be appropriate if the description repeated the schema; here it doesn't, but it also doesn't add value. However, the description mentions that the UUID identifies a 'saved HTTP replay item', which is a tiny contextual hint. Considering the baseline 3, I'll score 4 because the description implicitly confirms what the UUID represents, but this is a stretch. Strictly, with 100% coverage and no added parameter info, it should be 3. I'll set it to 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 states a specific verb ('Reads') and resource ('one saved HTTP replay item by UUID'), and mentions the included payload (request headers and body). It is clearly distinguishable from sibling tools like list_replay_items or execute_replay_item, but lacks a title and doesn't explicitly contrast with 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?

No guidance on when to use this tool versus alternatives like list_replay_items or other replay-item operations. The implied use case (fetching a single item by UUID) is clear, but there are no explicit when/when-not statements or alternative routing.

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. 'Reads' implies a non-mutating operation, which is the key safety signal, but there is no disclosure of ordering (newest-first per the offset field), default limit behavior, or return shape beyond what the schema already encodes.

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 with no filler, and the resource identification is front-loaded ahead of the filtering guidance. Nothing needs trimming, though it is arguably too lean given the absence of annotations.

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 annotations and no output schema, the description is the only place behavioral context can live, and it stays thin — no return format, ordering, or default-pagination note. The parameter coverage is fully handled by the schema, so it is adequate but not complete for a no-annotation debug reader.

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 level, limit, offset, trace_id, and event_type, making the baseline 3 appropriate. The description's 'filter by trace, rewrite phase, or severity' maps trace→trace_id and severity→level but introduces a 'rewrite phase' filter that no parameter actually exposes, a minor mismatch.

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 (reads) and resource (rewrite-debug event projection), and the word 'independent structured' distinguishes it from generic trace events. It stops short of naming the sibling it complements, clear_rewrite_debug_events, but the read/clear split is inferable from the name and description.

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

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

Explicitly routes the agent: use this 'instead of scanning generic trace events', which is a real alternative condition. It doesn't state when NOT to use it or point at clear_rewrite_debug_events for the delete path, but the usage context is clear.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the content categories of the response (enablement flags, limits, sync state, counts), which usefully characterizes a read-only diagnostic, but it never states explicitly that it is non-mutating or whether it has side effects or auth requirements.

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

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

A single front-loaded sentence that states the action first and then lists the reported facets; every clause earns its place and there is no filler.

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

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

With no output schema and no annotations, the description must carry the load, and enumerating the returned status facets (enablement, limits, sync state, counts) is adequate for a zero-argument diagnostic tool. It stops short of describing the shape or units of the reported values.

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

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

The tool takes zero parameters, so there is no parameter semantics to convey beyond what the empty schema already shows. Baseline 4 applies for a no-parameter tool.

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

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

States a specific verb ('Reports') plus the resource (rewrite runtime status) and enumerates the reported facets: rewrite/JS enablement, resource limits, sync state, and script counts. This cleanly differentiates it from sibling status tools like get_module_runtime_status and get_scheduled_task_runtime_status.

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 sentence describes what the tool returns but gives no when-to-use guidance, no prerequisites, and does not mention related siblings such as reload_rewrite_runtime or get_rewrite_debug_events. Usage is left entirely 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?

No annotations are provided, so the description carries the full burden. 'Returns' strongly implies a non-mutating introspection call and naming the returned payload (JSON schema + enum values) is informative, but it says nothing about whether this is a static or runtime-derived schema, caching, or failure 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?

A single front-loaded sentence that identifies the verb, the return payload, and the domain. No filler, nothing to trim.

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

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

With no output schema, the description does tell the agent what comes back (JSON schema and enum values), which is the key information for a schema-discovery tool. It lacks guidance on how the result should be used in a create/update workflow, keeping it just short of 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate; the schema field itself is empty and 100% covered. Baseline 4 applies for a no-parameter tool.

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

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

States a specific verb ('Returns') and resource ('the exact JSON schema and accepted enum values for creating or updating Rewrite Rules and Actions'), which clearly separates it from siblings like upsert_rewrite_rule or list_rewrite_rules. It never names an alternative explicitly, so it falls short of a 5.

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

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

The mention of 'creating or updating Rewrite Rules and Actions' implies the tool is used to discover valid fields/enums before calling upsert_rewrite_rule, but it never states when to use this versus validate_module_package or the script-package validators. Usage is implied rather than stated.

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

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

No annotations exist, so the description carries the full burden. It states scope (complete manifest + modules) but omits return format, size/performance characteristics, and whether it is a pure read. For a fetch tool with zero annotation coverage, this is adequate but incomplete.

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 tight sentence with no filler, and the key scope ('complete manifest and source modules') is front-loaded. Efficient, though minimal.

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

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

For a two-parameter read with 100% schema coverage and no output schema, the description conveys the returned payload type, but lacks any note on error behavior, missing revisions, or large-package handling. Adequate but leaves gaps.

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

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

Schema description coverage is 100%, so the schema already documents both 'id' and the optional 'revision'. The description adds the concept of active vs historical revisions, but that is already captured in the schema's revision description. 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?

Clear verb+resource: 'Fetches the complete manifest and source modules for ... ESM rewrite script revision'. It names the specific artifact (manifest + source modules), distinguishing it from validate_/list_ siblings. However it does not explicitly contrast with sibling get_module_package or list_rewrite_script_revisions, so it stops short of a 5.

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

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

The phrase 'active or historical revision' implies the revision parameter usage, but there is no explicit when-to-use/when-not guidance or naming of alternatives like validate_rewrite_script_package. Usage is only implied.

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

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

No annotations are provided, so the description carries the full burden. It discloses only that the task is 'locally stored'; it says nothing about behavior for a nonexistent id, permissions, or the returned shape, leaving the agent to guess at failure 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?

A single sentence with zero filler, front-loading the verb and resource. Nothing in it is redundant or padded.

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

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

For a one-parameter read tool with no output schema and no annotations, the description is minimally sufficient but stops short of covering what happens when the id is unknown or what the response contains. Adequate, with visible gaps.

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

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

Schema description coverage is 100% (the id parameter is documented as 'Scheduled task id'), so the schema already does the work. The description's 'by id' adds no syntax or format 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?

States a specific verb (fetches) and resource (Cron or interval JavaScript task) with a clear scope of one item by id, which implicitly separates it from list_scheduled_tasks. It does not explicitly name a sibling, but the singular/by-id framing is 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 'one ... by id' phrasing implies retrieval of a single task, contrasted with the list sibling, but there is no explicit when-to-use/when-not or reference to the runtime-status sibling. Usage is inferable rather than stated.

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

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

No annotations exist, so the description carries the full burden. It does disclose one genuine behavioral trait beyond structured data: script source is deliberately withheld from the response. However, it says nothing about how fresh the state is, whether it requires the task runtime to be active, or what failure looks like when a task is 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?

A single front-loaded sentence with no filler. The scope constraint is packed into the same sentence as the purpose rather than padded into extra lines.

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

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

With no output schema, the description is the only source for what comes back, yet it never characterizes the runtime state itself (states, fields, or shape). For a zero-param read tool this is a moderate gap rather than a fatal one, since the leading clause at least tells the agent the response is a state snapshot and excludes script source.

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 takes zero parameters, so there are no argument semantics to document and the baseline of 4 applies. The schema is trivially complete.

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: returns the PacketTunnel scheduled-task runtime state, and adds a distinguishing scope note ('without exposing script source') that separates it from config-oriented siblings like get_scheduled_task. It stops short of naming which sibling to prefer when an agent wants configuration rather than runtime state.

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

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

There is no explicit when-to-use guidance. The agent must infer from the name and from siblings such as get_scheduled_task vs get_scheduled_task_runtime_status that this returns live state rather than stored configuration; that routing decision is left entirely 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?

With no annotations at all, the description carries the full burden; it does disclose that navigation happens inside the app's embedded WKWebView (not an external browser), which is genuinely useful scoping. It says nothing about what happens when there is no prior history entry, whether the call errors or no-ops, or what is returned.

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

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

A single front-loaded sentence naming the action and its target context, with no filler or repetition of the tool name.

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

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

For a zero-parameter, no-output-schema navigation tool, the core information an agent needs is present. The only real gap is the no-history edge case, which is a minor omission given the tool's 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?

The tool takes zero parameters, so the baseline is 4; there is nothing about arguments for the description to clarify or omit.

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 ('navigates back') with a precise resource ('Lemon iOS embedded WKWebView history'), which an agent can cleanly separate from go_forward_web_page, open_web_page and refresh_web_page. It does not explicitly name the sibling it complements, so it stops short of a 5.

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

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

No when-to-use or when-not-to-use guidance, and no mention of alternatives such as go_forward_web_page or open_web_page. The correct invocation is only inferable from the tool name and the surrounding web-page family.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the navigation action but omits what happens when no forward history exists, whether it triggers a page load, required permissions, or any side effects.

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

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

The description is a single, front-loaded sentence with no wasted words. It is appropriately sized for a simple navigation tool.

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

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

For a zero-parameter navigation tool with no output schema and no annotations, the description covers the core action but lacks context on prerequisites, failure modes, and how it relates to sibling navigation tools. It is minimally adequate but incomplete.

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 100%. Per the rules, a 0-parameter tool receives a baseline of 4; there is nothing to clarify beyond that.

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

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

Specific verb 'Navigates forward' and resource 'Lemon iOS embedded WKWebView history' clearly state what the tool does. It distinguishes itself from the sibling go_back_web_page by direction, so an agent can identify it without opening the schema.

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

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

No explicit when-to-use guidance, prerequisites, or alternatives are provided. It does not state that forward history must exist or mention go_back_web_page as the counterpart. Usage is only vaguely implied by the action itself.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Fetches' implies a read, but the description says nothing about permissions, whether the module must be installed/enabled, payload size, or error behavior when the module_id is unknown.

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

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

A single efficient sentence with the resource and scope front-loaded; every word earns its place and there is no filler.

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

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

With no output schema, the description usefully enumerates the three returned artifacts, which is the main thing an agent needs. The lack of annotations leaves permission and failure behavior unspecified, but for a one-param read tool this is close to 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 coverage is 100% and module_id is documented as a reverse-domain id, so the schema already does the work. The description adds only the implication that the target must be an installed module, which is marginal added value.

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

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

States a specific verb ('Fetches') and enumerates exactly what is retrieved: active manifest, UI schema, and ESM sources of one installed Module. This meaningfully differentiates it from siblings like get_module_package or get_module_runtime_status, though it doesn't name those siblings directly.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as get_module_package. The agent must infer context from the sibling list on its own.

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

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

With no annotations, the description carries the full behavioral burden and discloses almost nothing: it does not say whether an existing module is overwritten, whether validation runs first, what permissions are needed, or whether the operation is reversible. 'Compatibility alias' is the only behavioral hint, and it is ambiguous.

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

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

A single efficient sentence with the key identifying phrase ('Compatibility alias') front-loaded. It wastes no words, though its brevity is partly under-specification rather than true economy.

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 mutation-style tool with no annotations and no output schema, the description should explain effects, failure modes, and how it relates to the many sibling module tools (upsert_module, validate_module_package, reload_module_runtime). None of that is present, leaving the agent unable to call it confidently.

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

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

Schema description coverage is 100% for the single package_json parameter, so the schema fully documents it. The description adds no format, size, or content guidance beyond the schema, so the baseline 3 applies.

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

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

The description names a resource (Module package) and an action, but hedges between two different operations ('installing or publishing') and labels itself a 'compatibility alias'. An agent cannot tell from this whether it installs locally, publishes remotely, or both, nor how it differs from the sibling upsert_module or validate_module_package.

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?

'Compatibility alias' faintly suggests it is a legacy shim that duplicates newer functionality, but no alternative tool is named and no condition for choosing it over upsert_module is given. There is no when-to-use or when-not-to-use guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions that mappings are 'currently applied by Lemon,' which gives some state context, but it does not state that the operation is read-only, describe side effects, auth needs, or return format.

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

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

A single front-loaded sentence with no wasted words. It is appropriately sized for a simple, parameterless list operation.

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

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

For a no-param list tool with no annotations and no output schema, the description could do more to explain return values or scope. It conveys the basic purpose but leaves gaps around what the mappings look like and when to prefer other host-related tools.

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

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

The tool takes zero parameters, so the baseline is 4 per the scoring rules. The description correctly implies there are no filters or identifiers to pass.

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 ('Lists') and resource ('native DNS custom Host mappings currently applied by Lemon'). It is clear what the tool does, but it does not explicitly distinguish itself from siblings like upsert_host_mapping or delete_host_mapping beyond the obvious list-vs-mutate difference.

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

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

The description provides no when-to-use guidance, no exclusions, and no alternatives. It merely states what the tool does, leaving the agent to infer that it is used for viewing host mappings.

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 helpfully discloses that revisions are 'immutable' and that the active revision is included, which is real behavioral context. However, it omits read-only confirmation, return structure, ordering, or pagination details.

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

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

A single efficient sentence that front-loads the resource and names the concrete payload (revisions, hashes, active revision). Zero waste.

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

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

For a read-only list tool with one required, fully documented parameter and no output schema, the description adequately states what is returned. But with no annotations it leaves open whether the call is safe/read-only and how many revisions or in what order they appear.

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

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

Schema coverage is 100% with module_id documented as 'Reverse-domain Module id'. The description adds no parameter-level meaning beyond the schema's baseline.

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

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

States a specific verb (Lists) and resource (Module revisions) plus the return content (hashes, active revision). It doesn't explicitly differentiate from the sibling list_rewrite_script_revisions or from inspect_module, but the resource 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 versus inspect_module or other module tools. An agent must infer usage from the name alone; no conditions or alternatives are named.

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

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

No annotations exist, so the description carries the full behavioral burden, yet it says nothing about whether this requires authentication, whether reads are scoped to the host, result ordering, or pagination. Listing the returned fields ('active revisions, and enabled state') is helpful but is not behavioral 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?

A single front-loaded sentence with no filler; the verb and resource lead and the returned attributes follow. Nothing here wastes the agent's 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 read tool with no output schema and no annotations, the description covers the basic shape of the result but omits auth/permission expectations and result-size or ordering behavior. It is minimally viable rather than fully self-sufficient.

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 takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a parameterless tool applies. No parameter claims are made that could conflict with the empty schema.

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

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

States a specific verb ('Lists') and a clearly bounded resource ('installed host-side UI Modules') plus the attributes surfaced (active revisions, enabled state). It does not explicitly distinguish itself from the close sibling list_module_revisions, which mentions revisions as a separate tool, leaving mild ambiguity about which list to pick.

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

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

The description gives no when-to-use guidance, no prerequisites (e.g., must a module be installed), and never names an alternative sibling such as list_module_revisions or inspect_module. The agent must infer invocation context from the name alone.

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

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

No annotations are provided, so the description carries the full burden. It does disclose that the data comes from a local runtime database (a useful persistence hint), but says nothing about ordering, pagination, result limits, or whether the operation is read-only beyond the word 'lists'.

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 front-loaded sentence with no filler. The resource and its storage location are stated immediately and nothing is redundant.

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 list tool with no output schema and no annotations, the description covers the essentials but leaves the return shape, ordering, and result size undefined. Adequate minimum-viable coverage rather than a complete picture.

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 takes zero parameters, so there is nothing for the description to clarify. Baseline 4 applies; the schema is trivially complete at 100% 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 (lists) and resource (saved HTTP replay items) plus where they live (Lemon's local runtime database). An agent can distinguish it from the singular get_replay_item by the plural 'items', but no sibling is explicitly named.

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

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

There is no statement of when to use this versus get_replay_item, execute_replay_item, or search_traffic_previews. Usage is only implied by the plural noun, leaving the agent to infer that this is the enumerate-all path.

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. 'Fetches all existing' implies a non-paginated read-only listing, but it says nothing about ordering, volume, permissions, or failure behavior for a tool that may return every rule in the system.

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 compact sentence with the resource and scope front-loaded, no filler. It could be marginally sharper by using the term 'rules' consistent with the tool name and siblings.

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 no-argument lister this is close to sufficient, and mentioning MatchGroups hints at the return structure. But with no output schema and no annotations, a brief note on what a returned rule looks like (or that results are unpaginated) would remove the remaining ambiguity.

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

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

The tool takes zero parameters and the schema is empty, so there is nothing for the description to clarify. Per the baseline for 0-param tools, a 4 is appropriate.

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

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

States a specific verb (Fetches) and resource (rewrite policies with their MatchGroups), which clearly distinguishes it from write-oriented siblings like upsert_rewrite_rule and delete_rewrite_rule. However, it uses 'policies' where the tool and siblings use 'rules', introducing minor terminology drift.

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

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

No indication of when to call this versus related tools such as list_rewrite_scripts or get_rewrite_schema, and no prerequisites or context. The agent must infer usage purely from the name.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses that revisions are immutable and previews the returned fields (hashes, sizes, active revision), but never states that this is a read-only/non-destructive operation, nor does it mention pagination or any rate/permission considerations for a revision history that could be long.

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, front-loaded with the verb and resource, and each clause (immutable, hashes, byte sizes, active revision) adds information. No filler or redundancy.

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

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

With no output schema and no annotations, the description carries the return-value burden and does so by naming the fields returned. Combined with a fully documented single parameter, an agent has enough to call it correctly; only pagination/ordering behavior is left unstated.

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

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

Schema description coverage is 100% with a single 'id' parameter documented as 'Script package id', so the schema already does the work. The description adds no syntax, format, or lookup detail beyond what the schema provides, which is the expected baseline.

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

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

States a specific verb ('Lists') and resource ('immutable revisions for a rewrite script package'), and enumerates what the listing contains (content hashes, byte sizes, active revision). This distinguishes it from siblings like list_rewrite_scripts and get_rewrite_script_package, though it never names those alternatives explicitly.

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

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

The description offers no when-to-use guidance, no prerequisites, and no alternatives. It never hints that this is the tool to consult before rollback_rewrite_script or to compare against get_rewrite_script_package, leaving the agent to infer the selection context from the name alone.

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

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

No annotations are supplied, so the description carries the full behavioral burden. It usefully discloses the returned shape (ids, active revisions, enabled state), but says nothing about pagination, result limits, ordering, or required permissions. Adequate for a simple read-only list, but not rich.

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

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

Two tight sentences with no filler, and the primary purpose is front-loaded ahead of the alternative-tool pointer. Every clause earns its place.

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

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

With no output schema, the description compensates by naming the fields that come back. For a parameterless list tool this is close to sufficient; a note on volume/pagination would make it fully 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?

The tool takes zero parameters, so per the baseline there is nothing for the description to disambiguate beyond the schema. No parameter-level explanation is needed or missing.

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 (Lists) and resource (ESM rewrite script packages), and names the returned fields (ids, active revisions, enabled state). It explicitly differentiates itself from get_rewrite_script_package by scoping that sibling to source-module reads, so an agent can separate the two 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?

The second sentence routes the agent to the correct alternative for reading source modules, which is exactly the kind of when-to-use-this-vs-that guidance that matters here. It stops short of exclusions (e.g. when not to list) but the primary routing decision is made 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?

With no annotations provided, the description carries the full behavioral burden. It discloses useful traits: tasks are locally stored, backed by Cron or millisecond intervals, and the listing includes runtime state and next run time. It does not explicitly state this is a read-only operation or mention pagination/ordering, but for a parameterless list tool the disclosure is reasonable.

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

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

A single front-loaded sentence that packs the resource, the task types, and the returned fields with no filler. Nothing to trim.

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

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

For a simple zero-param read tool with no output schema, the description covers enough to call it correctly and even previews the returned data. It is only slightly short on how it relates to the sibling get/list variants.

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 takes zero parameters, so there are no parameter semantics to clarify; the baseline for a 0-param tool applies. Nothing in the description misleads about inputs.

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

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

States a specific verb (Lists) and resource (scheduled tasks), and adds the useful qualifier that they are locally stored Cron or millisecond-interval JavaScript tasks with runtime state and next run time. However, it does not differentiate from siblings like get_scheduled_task or get_scheduled_task_runtime_status, which overlap in what they surface.

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

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

No guidance on when to use this versus get_scheduled_task (single item) or get_scheduled_task_runtime_status, despite those being obvious alternatives in the sibling list. The agent must infer routing from names alone.

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

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

With no annotations, the description carries the full burden, and it does disclose a meaningful behavioral trait: the page renders in an embedded WKWebView inside the iOS app rather than an external browser. However, it is silent on error behavior for invalid/non-HTTP URLs, whether an existing page is replaced, and what the call returns.

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

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

A single tight sentence with zero waste; the action verb and target environment are front-loaded.

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

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

For a one-parameter tool with no output schema, the description covers the essentials of what happens and where. It stops short of describing navigation side effects (page replacement, history) or failure modes, leaving the agent to guess at behavior on repeat or invalid calls.

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 exists and schema coverage is 100%, so the schema already documents the url field including its HTTP/HTTPS constraint and 4096-char limit. The description merely restates the accepted schemes, adding no format or example detail beyond the schema.

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

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

States a specific verb ('Opens') and resource (HTTP or HTTPS URL) and locates the action precisely ('inside the Lemon iOS app's embedded WKWebView'), which separates it from sibling navigation tools like refresh_web_page or close_web_page. It does not explicitly name those siblings, but the verb/resource pair is 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?

Usage is only implied: an agent can infer this is the entry point that must precede refresh_web_page, go_back_web_page, or close_web_page, but the description never says so. There is no statement of when to use this versus the other WebView tools, nor any exclusion criteria.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing beyond the execution target. It does not say whether in-page state (form input, scroll position, session) is discarded, what happens if no page is currently open, or whether the call blocks until load completes.

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, front-loaded with the action and object, with no filler. 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-argument action with no output schema this is close to sufficient, but with no annotations the description should at least cover the no-page-open case and whether page state is lost. It leaves those gaps for a tool that mutates browser state.

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 takes zero parameters, so the baseline is 4; there is nothing for the description to clarify or compensate for. The single sentence adds no parameter detail because none is needed.

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 (reloads) and resource (the current page), plus the execution context (Lemon iOS embedded WKWebView). This implicitly separates it from open_web_page and go_back/go_forward_web_page, but it never names a sibling or spells out the distinction explicitly.

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

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

Usage is only implied: an agent can infer you reload when the current page needs refreshing, as opposed to opening a new one. There is no explicit when-to-use statement, no mention of alternatives, and no conditions such as 'no page open' behavior.

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

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

With no annotations, the description carries the full burden. It usefully discloses a non-obvious trait: the effect is deferred until the next activation rather than immediate. It says nothing about whether in-flight requests are interrupted, required permissions, or downtime risk from releasing a live worker.

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, front-loaded with the action and followed immediately by its effect. Nothing could be trimmed without losing meaning.

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

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

For a one-parameter, no-annotation runtime-mutation tool with no output schema, the description is minimally adequate but thin: it omits return behavior, disruption impact on live traffic, and any auth or permission context.

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

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

Schema coverage is 100% and the single parameter is already documented ('Optional Module id; omit to reload all'). The description's 'one Module worker or all workers' merely restates that behavior, adding no format, scoping, or default detail beyond the schema.

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

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

The description names a specific action ('Releases') and resource ('Module worker'), and adds the observable consequence: the next activation loads the active revision. It is clearly distinguishable from the rewrite-domain sibling reload_rewrite_runtime by its Module scope, though it never explicitly names that 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?

Usage is implied rather than stated: the agent can infer this is for forcing a fresh worker load after a revision change. There is no explicit when-to-use, no prerequisites, and no routing advice against alternatives such as toggling the module or reinstalling it.

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

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

With no annotations, the description carries the full burden and does disclose two important behavioral facts: the operation can fail when the VPN runtime is not running, and persisted scripts are unaffected by the reload. It does not describe the response or whether the reload is disruptive to in-flight traffic, keeping it below 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?

Two short sentences, no waste, with the action front-loaded and the caveat and side-effect following. Every sentence earns its place.

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

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

For a zero-parameter, no-annotation, no-output-schema tool, the description covers the failure precondition and the non-destructive scope of the reload, which is most of what an agent needs. It stops short of explaining what a successful reload changes at runtime.

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 takes zero parameters, so there is nothing to document and no schema gap for the description to compensate for. Baseline 4 applies.

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

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

The description states a specific verb ('reload') and resource ('active rewrite snapshot from runtime.sqlite'), which is enough for an agent to distinguish it from the similarly named reload_module_runtime sibling. It lacks any explicit sibling-routing sentence, so it falls short of a 5.

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

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

There is no statement of when to use this versus alternatives such as get_rewrite_runtime_status, rollback_rewrite_script, or reload_module_runtime. Usage is only implied by the name and the mention of failure conditions, which is insufficient 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?

With no annotations, the description carries the full burden, and it does disclose one important trait: revisions are immutable and history is retained, implying a non-destructive mutation. However, it says nothing about whether the rollback takes effect immediately, whether the running worker must be reloaded (a real concern given the 'reload' parameter), permission requirements, or impact on live traffic.

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

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

A single front-loaded sentence with no filler, stating the action and the key consequence immediately.

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

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

For a mutation tool with no annotations and no output schema, the description conveys the core effect but omits operational essentials: prerequisites for a valid revision, whether a runtime reload is needed, and how success is reported. It is minimally adequate rather than 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 all three parameters are already documented in the schema. The description reinforces that 'revision' refers to an immutable historical revision, but adds no syntax, format, or default information beyond what the schema states; baseline 3 applies.

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

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

The description names a specific verb ('Switches') and resource ('a Module') plus the target state ('an immutable historical revision'). It is clearly distinguishable from read-oriented siblings like list_module_revisions or inspect_module, though it does not explicitly name any sibling as an 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?

There is no guidance on when to roll back versus using upsert_module, toggle_module, or reload_module_runtime, nor a prerequisite such as discovering valid revisions via list_module_revisions. Usage context is left entirely 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?

With no annotations, the description carries the full burden. It does disclose that this is a mutation (activating a revision) and that historical revisions are retained (non-destructive in that sense). However, it doesn't state permission requirements, whether the operation is reversible, or what the effect on the running runtime is. 'Historical revisions are retained' is a useful retention guarantee, but gaps remain.

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

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

Two concise sentences, front-loaded with the action. Every sentence earns its place, including the retention guarantee. No waste.

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

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

For a mutation tool with no annotations and no output schema, the description covers the core action and a key side effect (retention) but is thin on behavioral context: no permissions, no runtime impact, no rollback semantics. Adequate minimum but clearly missing pieces an agent would want before calling a mutation.

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 all three parameters (id, reload, revision) are already documented in the schema. The description adds no parameter-level detail beyond what the schema provides. Baseline 3 is appropriate when schema fully documents 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?

States a specific verb ('makes... the active revision') and resource (rewrite script package revision), which clearly distinguishes it from list/get siblings. It's not differentiated from rollback_module, but that operates on a different resource type (module vs script package), so the distinction is inferable. Clear but lacks explicit 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 'existing immutable revision' phrasing implies the revision must already exist, providing implicit guidance. However, there's no explicit statement of when to use this vs. upsert_rewrite_script or reload_rewrite_runtime, nor any stated prerequisites. Usage is implied rather than 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?

With no annotations, the description carries the full behavioral burden. It implies a read operation via 'Find' and scopes it to 'recent logs', but says nothing about result caps, whether results are paged, what 'previews' contain, or any auth/scope constraints.

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

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

A single efficient sentence with the search scope front-loaded and no wasted words. It is appropriately sized, though the brevity comes at the cost of behavioral detail.

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

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

For a 2-param search tool with full schema coverage and no output schema, the description is minimally adequate. However it never explains what a 'preview' result is or how many/which logs are considered 'recent', leaving real gaps for the agent.

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

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

Schema description coverage is 100%, so both parameters are already documented (keyword as 'Search term, URL substring, or Hostname', limit as item count). The description's mention of 'keywords or hosts' echoes the keyword param but adds no syntax or format detail, so the baseline 3 applies.

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

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

States a specific verb (Find) and resource (HTTP traffic) with a clear scope (targeting keywords or hosts across recent logs). It is easy to understand, but it does not distinguish itself from related traffic/log siblings such as get_captured_request or clear_captured_traffic.

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

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

There is no explicit when-to-use guidance, no when-not-to-use, and no named alternatives. The phrase 'across recent logs' weakly implies a recency-bounded search context, but nothing tells the agent how this differs from other traffic-retrieval tools.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Manually override' correctly implies a mutation, and the failure scenario adds useful context, but it says nothing about persistence, whether the override survives a restart, whether it affects active connections, or permission/auth requirements.

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

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

Two sentences, zero waste, and the primary action is front-loaded ahead of the conditional guidance. Every sentence earns its place.

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

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

For a two-parameter mutation tool with no output schema, the description covers purpose, trigger condition, and target resource adequately. It is slightly incomplete on post-set behavior and effects on the existing connection, which an agent might need to reason about consequences.

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 'ip' and 'port' are already fully documented in the schema including format example and default. The description adds no parameter-level detail beyond what the schema supplies, 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 ('override') plus resource ('target IP address of the iOS Lemon device'), with the 'Manually' qualifier signaling this bypasses automatic discovery. It is clearly distinguishable from its sibling get_lemon_target_ip, which reads rather than sets the value.

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

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

Explicitly names the triggering conditions: use when mDNS/Bonjour discovery fails or when the device sits on a different network IP. This gives clear when-to-use guidance, though it never states when not to use it or that get_lemon_target_ip is the read counterpart.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not disclose whether disabling a module takes effect immediately or requires a runtime reload, whether the change is reversible, or what permissions are required for a state-changing 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?

A single short sentence with no wasted words, and the key qualifier 'compatibility alias' is front-loaded. It is terse rather than padded, though the terseness is partly what leaves gaps elsewhere.

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 state-changing two-parameter tool with no annotations and no output schema, the description says almost nothing about effects, prerequisites, or the alias's relationship to toggle_module. An agent can call it, but cannot predict what disabling a module actually does.

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 module_id (reverse-domain id) and enabled (whether the Module can be opened) documented in the schema itself. The description adds nothing beyond the schema, so the baseline 3 applies.

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

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

The description names a specific verb pair (enabling/disabling), the resource (one UI Module), and adds the notable qualifier that this is a 'compatibility alias'. That qualifier distinguishes it from the sibling toggle_module, though it does not name that sibling outright.

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?

Calling itself a 'compatibility alias' implies this is a legacy path that should only be used for backwards compatibility, which is a usable hint. However, it never states explicitly when to prefer toggle_module or under what conditions this alias is appropriate, so the guidance remains implied rather than 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?

With no annotations, the description carries the full burden. It usefully discloses that enabling requires a configured schedule entitlement, but omits other behavioral details such as required permissions, reversibility, side effects on disabling, or return 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?

Two sentences, front-loaded with the action and followed by the key prerequisite. No redundant or filler content; every sentence earns its place.

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

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

For a simple two-parameter toggle with full schema coverage and no output schema, the description covers the core action and a notable entitlement prerequisite. It could be slightly more complete by contrasting with update_scheduled_task or noting behavior when the entitlement is absent.

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

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

Schema coverage is 100%, so the input schema already documents both id and enabled. The description does not add syntax, format, or constraint details beyond what the schema provides, matching the baseline of 3 when the schema does the heavy lifting.

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

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

The description states a specific verb (enables or disables) and resource (one scheduled task), making the purpose clear. It does not explicitly differentiate itself from siblings like update_scheduled_task, so it falls short of a 5.

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

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

The description implies usage (use this to enable or disable a scheduled task) but gives no explicit when-to-use guidance, exclusions, or named alternatives. The entitlement note is a prerequisite, not 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?

With no annotations, the description carries the full behavioral burden and does not meet it. It does not say whether the change takes effect immediately or requires reload_module_runtime, whether it needs elevated permission, or whether disabling a module is reversible.

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 filler, action stated up front. Nothing to trim and nothing buried.

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 unannotated state-changing tool with no output schema, the description is too thin: it omits activation timing, reload requirements, and sibling distinction. The low complexity of a two-parameter toggle keeps this from being a 1, but the gaps are real.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema, establishing the baseline of 3. The description adds only the constraint that the target must be an 'installed' UI Module, which is marginal extra meaning beyond the schema.

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

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

Specific verb pair ('enables or disables') with a clear resource ('one installed UI Module'), so the agent knows this is a mutation on a single module. It does not, however, differentiate itself from the sibling set_module_enabled, which appears to do the same thing.

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

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

No when-to-use context, no prerequisites, and no mention of the near-identical sibling set_module_enabled or how to pick between them. Usage must be inferred entirely from the name.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the call is blocking and returns success/error, which is useful behavioral context, but omits whether the VPN is affected globally, whether it requires privilege, and whether the toggle is reversible.

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

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

Two short sentences, front-loaded with the operation and followed by the expected interaction pattern. No filler, though it could be slightly more informative without losing brevity.

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 toggle with no annotations and no output schema, the description is minimally sufficient: it names the resource, the two actions, and the blocking behavior. It leaves privilege requirements, scope, and failure consequences unspecified, so it is adequate but not rich.

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

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

Schema description coverage is 100% and the single 'action' parameter is documented in the schema with an enum and description. The description says 'starts or stops' which mirrors the enum but adds no format or semantic detail beyond the schema. 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 (starts or stops) and resource (Lemon iOS VPN), making the operation understandable. Sibling names like toggle_module and set_module_enabled are adjacent in concept but target a different resource, which this description implies rather than explicitly distinguishes.

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 instruction to 'wait for success or error response' implies the tool is synchronous/blocking, giving some usage context. There is no explicit when-to-use guidance, no mention of alternatives (e.g., toggle_module for modules), and no exclusions.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses that execution history is preserved, which is a non-obvious trait for a mutation, but it omits whether the update is a full replace vs. a patch (all four core fields are required, hinting at replace), permission requirements, and reversibility.

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

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

A single efficient sentence with the mutation verb and the key invariant front-loaded. Every word earns its place 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?

For a 6-parameter mutation with a nested headers object, no annotations, and no output schema, one sentence is thin. The description should clarify replace-vs-partial semantics and header handling; the execution-history note is helpful but leaves most behavioral questions open.

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 every parameter including the nested headers map is already documented in the schema. The description adds no parameter-level meaning beyond that, which is the baseline 3 when the schema does the heavy lifting.

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

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

States a specific verb+resource combination ('Updates a saved HTTP replay item') and adds a scope qualifier ('without changing its execution history'). This clearly distinguishes it from create/get/list/delete/execute siblings by implication, though it never names them explicitly.

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

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

The description gives no when-to-use guidance, no prerequisites, and no comparison against alternatives like create_replay_item or execute_replay_item. An agent must infer from the verb alone that this is the modification path.

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

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

With no annotations, the description carries the full behavioral burden. It adds one real constraint beyond structured data — packages must export onSchedule(input) from their manifest entry — but omits update semantics (full replacement vs. partial patch), permission implications of the manifest, and whether changes take effect immediately or require a reload.

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, front-loaded with purpose, then mode selection, then the package contract. Every sentence carries distinct information and none is filler.

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

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

For a 9-parameter tool with a nested package object, required-field semantics, and no annotations or output schema, the description covers the single/package split but leaves key gaps: what happens to omitted optional fields on update, how the manifest permissions are honored, and what a successful update returns.

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 a baseline of 3 applies. The description goes further by explaining the script_type=single + script versus script_type=package + script_package pairing and the package entry contract, which the schema only gestures at with generic field descriptions.

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

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

The description states a specific verb ("Updates") and a precise resource ("locally stored Cron or millisecond-interval JavaScript task"), which cleanly separates it from create_scheduled_task and set_scheduled_task_enabled. It does not name a sibling alternative explicitly, but the verb choice makes the distinction 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?

It explains which script_type mode to choose and what each requires, which is genuine usage guidance for the parameters. However, it never addresses when to call update_scheduled_task versus create_scheduled_task, what prerequisites exist, or whether an existing task must first be fetched.

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

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

With no annotations, the description carries the full burden. It usefully discloses that writes are immediate and require no second confirmation, which is meaningful for a mutation tool. However, it says nothing about idempotency, required permissions, what happens to omitted fields on update, or the effect of the block action, leaving substantial behavioral gaps.

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 that are front-loaded: the create/update behavior leads, and the immediacy caveat follows. Neither sentence is redundant and there is no filler.

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

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

For a six-parameter mutation tool with no annotations and no output schema, the description covers mode selection and write immediacy but omits the map-vs-block semantics, the fact that target is expected for map and omitted for block, and what the call returns. Those gaps are partially compensated by the unusually complete schema, keeping it at an adequate-but-incomplete level.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters (id, action, domain, target, comment, enabled) with defaults and constraints. The description adds only the id-presence rule, which the id's own schema description already states ('omit to create a new mapping'). Baseline 3 is appropriate.

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

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

The description states a specific verb and resource ('Creates a native DNS Host mapping, or updates one') and explicitly resolves the upsert ambiguity by tying the update branch to the presence of an existing mapping id. The 'Host mapping' resource is distinct from the other upsert siblings (upsert_rewrite_rule, upsert_module), so an agent can place it correctly without opening the schema.

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

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

It clearly states the condition that selects each mode: omit the id to create, provide an existing mapping id to update. This is real when-to-use guidance for an upsert. It stops short of naming alternatives for related intents (e.g., list_host_mappings to find an id, delete_host_mapping to remove one), so no explicit exclusion guidance is present.

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 does disclose two useful traits: that revisions are immutable (implying no edits to existing revisions) and that the runtime reload is an optional side effect. It omits permissions/authorization requirements, idempotency/conflict behavior when a module already exists, and whether publishing a revision is irreversible.

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

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

Two short sentences, front-loaded with the create-vs-revision duality before the optional side effect. Every clause earns its place with no filler.

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

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

A mutation tool with no annotations and no output schema should do more: authorization needs, conflict/idempotency semantics, and how it differs from install_module are all missing. The schema is fully described, so parameter coverage is not the gap, but behavioral context is only minimally sufficient.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema; baseline 3 applies. The description reinforces the optional reload behavior but adds no format or constraint detail for package_json beyond what the schema states.

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

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

States specific verbs and resource: installs a new Module or publishes a new immutable revision, with an optional runtime reload. This is clear on its own, but it does not distinguish itself from the sibling install_module or explain how 'upsert' relates to it, leaving ambiguity an agent must resolve elsewhere.

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

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

No when-to-use guidance and no exclusions. It never says when to choose upsert_module over install_module, reload_module_runtime, validate_module_package, or rollback_module, which are all adjacent siblings in the same module family.

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

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

With no annotations, the description carries the full behavioral burden for a mutation tool. It discloses that updates are keyed on 'id' and that groups are ordered, but says nothing about permissions, what happens to existing rules not supplied, duplicate/conflict behavior, or whether the operation is reversible.

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

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

Two sentences, front-loaded with the core action and followed by the update precondition. No filler or redundancy.

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

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

For a two-parameter mutation tool with no annotations and no output schema, the description covers the essentials of identification and ordering but leaves behavioral gaps (error/conflict handling, return expectations, permissions) unaddressed. Adequate but with clear missing pieces.

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 would be 3, but the description adds a genuinely useful detail not present in the schema: the 'id' field that turns an add into an update. The schema example shows only name/enabled/priority, so this 'id' guidance fills a real gap.

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

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

The description states a specific verb pair (add/update) and resource (rewrite policy), making it distinguishable from siblings like delete_rewrite_rule and list_rewrite_rules. It does not differentiate itself from the similarly named upsert_rewrite_script, but the policy-vs-script distinction is reasonably implied.

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

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

It gives one concrete usage precondition: include an 'id' in the rule object to perform an update, which clarifies the upsert semantics. However, it offers no guidance on when to prefer this over upsert_rewrite_script, nor any prerequisites or exclusions.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses immutability of revisions and the reload semantics, which is useful. However, it omits permission requirements, whether an existing revision is replaced, error conditions, and the safety profile of a mutation tool.

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

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

Two sentences, front-loaded with the core action and followed by practical field guidance. Every clause adds value with no repetition or filler.

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

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

For a complex mutation tool with nested manifest/permissions objects and no output schema, the description covers the main calling patterns but leaves gaps: no mention of atomicity, permission defaults beyond content shorthand, or validation behavior. Adequate but not 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 already documents id, name, reload, content, modules, and manifest in detail. The description only adds meaning for 'reload' (immediate runtime snapshot reload after persistence) and the content-vs-manifest choice, which the schema largely covers. Baseline 3 applies.

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

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

The description states a clear verb and resource: creating a new ESM rewrite script package or publishing a new immutable revision. The dual create/update nature is well captured. It does not explicitly differentiate from siblings like upsert_module or rollback_rewrite_script, but the specific 'rewrite script package' scope is clear enough.

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

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

The description implies usage through the create-vs-update distinction and the manifest/content choice, but gives no explicit when-to-use or when-not-to-use guidance against alternatives like rollback_rewrite_script or validate_rewrite_script_package. No exclusions or prerequisites 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?

With no annotations, the description carries the full burden. It usefully discloses that the operation is non-persisting and that validation uses the iOS validator, which is real behavioral content. But it says nothing about what a failed validation looks like, whether the package is executed or merely parsed, or any permissions needed.

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, no filler, with the operation and its key scoping constraint (non-persisting) both front-loaded before any detail.

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

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

A single-parameter validate tool with a fully described schema and no output schema; the description covers the operation, the input expectation, and the non-persisting guarantee, which is what an agent needs to call it correctly. Further elaboration was not required.

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% for the single parameter, so the schema already documents package_json as the complete JSON package with manifest and sources. The description adds no format, size, or content constraints beyond that, so baseline 3 applies.

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

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

Specific verb ('Validates') plus specific resource ('a Module package'), and the trailing clause 'without persisting it' separates it from mutation siblings like upsert_module and install_module. It does not, however, explicitly name or contrast with validate_rewrite_script_package, its closest structural 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 phrase 'without persisting it' implies the intended use case (dry-run check before upsert_module/install_module), but no sentence states when to call this instead of upsert_module, install_module, or inspect_module, and no prerequisites 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?

With no annotations, the description carries the full burden. It usefully discloses the important behavioral trait — 'It does not write anything' — and that validation mirrors iOS-side manifest, module-path, and size rules. However, it says nothing about what a failure produces (error list, throw, partial pass), which matters most for a validation tool.

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

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

Two tight sentences with no filler, and the read-only guarantee is front-loaded as the second clause where it is easy to see. Nothing is wasted, though there is little content to structure.

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

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

For a nested-object, two-param tool with no annotations and no output schema, the description covers purpose and side effects but omits the one thing an agent most needs: what the validation returns on success or failure. Adequate but with a clear gap.

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

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

Top-level schema coverage is 0% for the two required params, so per the rubric the description should compensate. It partially does by naming the categories checked (manifest, module paths, sizes), but gives no guidance on the shape of `modules` vs the manifest's `modules` allowlist, which is a real ambiguity in the schema.

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

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

States a specific verb (validates) and a specific resource (an ESM rewrite package), and adds that it does not write anything, which separates it from persistence siblings like upsert_rewrite_script. It does not explicitly distinguish itself from the near-twin validate_module_package, leaving that to inference, but the resource scope is otherwise 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 phrase 'the same iOS-side ... rules used before persistence' implies this is a pre-flight dry run prior to installing/upserting a package, but it never states when to call this instead of validate_module_package or upsert_rewrite_script. Usage must be inferred from context rather than read.

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