Loadster

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

The description adds valuable behavioral details beyond the annotations: if any row has the wrong column count, the whole write is rejected and nothing is written, and appending to an empty dataset infers column count from the first row. This atomic failure behavior is not expressed in the annotations or schema.

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

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

The description is composed of three purposeful sentences: the first states the action, the second explains the key behavioral guarantee, and the third handles an edge case. Every sentence adds necessary information 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?

For a three-parameter mutation tool with no output schema, the description covers the core call mechanics, validation rules, failure behavior, and an important edge case. An agent has enough context to invoke the tool correctly without 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?

Schema description coverage is only 33%, but the description compensates for the most important parameter, rows, by specifying that rows are data-only, must match the existing column count, and are rejected otherwise. projectId and datasetId are not described in detail, but their names plus the 'existing dataset' context make their meaning obvious.

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 combination—'Add rows to the end of an existing dataset'—which clearly distinguishes it from create, update, and delete operations. The phrase 'existing dataset' also prevents confusion with dataset creation tools.

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

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

The description gives clear context for when appending is appropriate: only new rows are sent, existing rows are untouched, and there is no need to read the table first. It does not explicitly name an alternative tool like update_dataset, but the usage context is clear enough for an agent to choose it correctly.

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

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

Annotations already cover the safety profile (non-readonly, non-destructive, non-idempotent, closed-world), so the bar is lower, and the description still adds substantive behavior: rows are treated as pure data, columns are addressed by zero-based index, and a header row would be ingested as a bot-visible row. It omits what happens on duplicate names or missing permissions, and the non-idempotent hint is never explained in prose.

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 the non-obvious data-format caveat, then the confirmation rule. No filler, and the most failure-prone detail (header rows) is placed before any optional 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 three-parameter mutation tool with a nested object and no output schema, the definition covers purpose, the critical table-format gotcha, and the confirmation guard. Missing pieces are the meaning/derivation of projectId and duplicate-name behavior, which leave some risk for an agent composing the call.

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

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

With 67% schema coverage, the description compensates where it matters most by clarifying that `dataset.values` must contain data rows only with no header — a rule the schema does not state. `projectId` remains undocumented in both description and schema, and the nested structure's relationship to projectId is left implicit, keeping this below a 5.

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 ("Create a new dataset in a project"), which cleanly separates it from sibling tools such as append_dataset_rows, update_dataset, and get_dataset. It stops short of explicitly naming those siblings, so an agent must infer the boundary rather than read it.

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

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

Gives a concrete precondition for invocation: confirm with the user unless they explicitly asked for a dataset. That is real when-to-use guidance. It does not address the create-vs-append decision (when an existing dataset should be extended with append_dataset_rows instead), which is the most likely misuse 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?

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false, so the agent knows this is a non-destructive, non-idempotent mutation. The description adds genuinely beyond that: the Fuel/billing consequence of enabling, the access-level gate, and the fact that the returned summary carries a Dashboard link. However, it does not state what happens on validation failure (e.g., duplicate names) or whether repeated calls create duplicates despite idempotentHint=false.

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

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

Front-loaded with the core action and initial state, then prerequisites. No filler sentences, though the Fuel/billing sentence is dense and slightly longer than necessary for the agent's decision. Overall well-structured rather than 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?

For a 9-parameter mutation with nested thresholds and no output schema, the description covers the creation lifecycle, enablement path, and points to the returned summary's link. The remaining gap is result-shape specifics, but without an output schema that is acceptable. Nearly complete.

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

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

Schema description coverage is 89%, so the schema already documents projectId-adjacent fields, engineIds semantics, frequency ranges, thresholds, and failure/recovery thresholds in detail. The description adds only a pointer to the 'monitoring' topic for choosing frequency and thresholds, which does not add syntax or constraint 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 and resource ('Create a Monitor in a project') plus the initial state ('initially disabled'), which distinguishes it cleanly from create_script, update_monitor, and enable_monitor. An agent knows exactly what object is produced.

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 follow-up tool (enable_monitor), the access level required ('Read+Write+Execute'), what happens below that level (tool absent, user enables via Dashboard link), and directs the agent to read the 'monitoring' topic before choosing frequency or thresholds. When-to-use, prerequisites, and alternatives are all 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?

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false and openWorldHint=false. The description goes beyond them by disclosing the return payload and, crucially, guarding against the non-idempotent duplicate-creation trap via the 'prefer existing' workflow. It stops short of stating what happens on name collisions or permission requirements, so it is strong but not exhaustive.

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

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

Three sentences, each earning its place: the action and return value first, then the routing/preference rule, then the escalation rule. Front-loaded with zero 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 one-parameter creation tool with no output schema, the description covers action, scope, return fields, and the decision workflow. Nothing an agent needs to invoke it correctly is missing.

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

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

The single 'name' parameter is documented at 100% schema coverage ('The name of the new project'). The description adds no syntax, length, or uniqueness constraints beyond the schema, so the baseline 3 applies.

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

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

States a specific verb+resource ('Create a project'), names the scope ('for the connected team'), and even declares the return fields (id, name, dashboard link). It is trivially distinguishable from siblings like list_projects or create_dataset.

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

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

Explicit when-to-use: 'Prefer an existing project: call list_projects first, and create a new one only if the team has none or the user explicitly asked for one.' It names the alternative tool and the exact conditions, plus a fallback instruction to ask the user when unsure.

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?

Goes well beyond the annotations by disclosing that the save is non-triggering, the exact refusal conditions (unknown engineId, too-short stage, exceeded bot/population caps) and that refusals name the limit. It also clarifies the subtle launchBlockers semantics — that blockers do not prevent the save and should be reported rather than worked around. Missing only rate/idempotency-style context, though idempotentHint=false already signals repeated calls create duplicates.

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

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

Front-loads the critical fact (no cost, no execution) and then layers permission, failure modes, and blocker semantics in a logical order. Some sentences are long and pack multiple clauses, but essentially every sentence carries distinct information.

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

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

Covers the three things an agent most needs for a non-idempotent create with no output schema: authorization, validation failure behavior, and how to interpret the returned summary (launchBlockers). It never describes the returned scenario object itself, which is a modest gap for 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?

Top-level description covers none of the required parameters directly, but it adds real constraints the schema doesn't: engineId must be one list_engines offers, stage length has a minimum, and the stage/ramp semantics are delegated to a named documentation topic. With 75% schema coverage doing the field-level work, this is a solid complement rather than a repeat.

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 ("Create a scenario in a project") and immediately bounds the effect with "saving costs nothing and starts nothing," which separates it from launch_load_test and update_scenario. An agent can identify the operation and its side-effect profile from the first clause alone.

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

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

Explicitly routes the agent elsewhere for the launch step ("Launch it with launch_load_test") and states the access level required, plus what happens below that level (tool absent, user launches from Dashboard). This is genuine when-to-use/when-not guidance rather than implied 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?

Annotations only declare the write/safety profile; the description adds non-obvious behavior beyond them: the tool returns a server summary plus dashboard link rather than the submitted object, and the read-back path is named ('the matching get tool reads it back'). It also discloses a reuse/ownership condition governing repeat calls, which is not derivable from idempotentHint=false.

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

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

Front-loaded with the core action, but roughly three sentences (type mapping, 'Browser script' ambiguity, no-duplicate rule) are reproduced verbatim in the script property's schema description, so a meaningful portion of the text does not earn its place at the tool level.

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 write tool with no output schema, the description covers prereqs, type ambiguity, reuse policy, and return shape — the pieces an agent needs before calling. The remaining gap is the commands/variables payload, which is delegated to get_command_schema/get_variable_schema, a reasonable but not fully closed handoff.

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 67% and the nested script object documents its type enum and tags field itself. The description's parameter-level contribution is limited to restating the HTTP/BROWSER/PLAYWRIGHT mapping already present in the schema's script description, and it says nothing about projectId or the variables/commands structure beyond pointing at the schema tools. Baseline 3 for partial coverage with heavy reliance on structured fields.

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 ('Create a new script in a project') and immediately disambiguates the three script types (HTTP/BROWSER/PLAYWRIGHT). It also distinguishes this from update_script/duplicate_script by telling the agent to edit and reuse an existing script instead of creating a new one.

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

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

Explicit prerequisites ('Read the relevant get_documentation topics and use the schema tools first'), an explicit ambiguity rule ('if the user's wording doesn't say which, ask before creating'), and an explicit exclusion ('Don't create multiple scripts of the same type for one task'). The alternative path — edit and reuse a session-created script for probes/retries — is spelled out with its conditions.

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

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

The annotations already declare destructiveHint=true and readOnlyHint=false, so the description adds no behavioral depth beyond the fact that a dataset is removed. It does not disclose whether deletion is permanent, whether related data is cascaded/deleted, or what happens to dependent artifacts. Since annotations carry the destructiveness signal, a low but non-contradictory score applies.

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

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

The description is a single short sentence that front-loads the action and object; there is no redundant content.

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

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

For a destructive two-parameter tool with no output schema, the description is under-specified: it omits expected effects, failure conditions, and any post-delete behavior. The annotation indicates destruction, but the text alone would not tell an agent what will happen when the tool succeeds.

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

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

Schema coverage is 0%, so the description must compensate, but it only restates the object-container relationship ('a dataset from a project') that parameter names already imply. It gives no guidance on required formats, constraints, or the meaning of the two IDs beyond their names.

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

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

The description names a specific action ('Delete'), a specific object ('dataset'), and the containing scope ('from a project'), which is enough to distinguish it from sibling delete tools for monitors, scenarios, scripts, and assets. It is not merely a restatement of the name because it adds project scoping.

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 tool's intended use is clear from the phrasing, but the description gives no explicit guidance about when to choose it over alternatives or any preconditions/exclusions. Usage is implied rather than spelled out.

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

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

Beyond the destructiveHint annotation, the description specifies exactly what gets destroyed (Incidents, status-page membership) and what survives (the Script). This is valuable behavioral context that annotations alone do not provide, and it does not contradict the annotations.

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

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

Three sentences, each with a distinct job: state the action, list side effects, point to the alternative. There is no filler or redundant restating 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 destructive delete tool with a simple schema, the description covers the key behavioral concerns: permanent deletion, cascading removal, retention of the Script, and the safer alternative. It does not mention success/failure response semantics, and there is no output schema to cover that gap, so a small omission remains.

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

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

Schema description coverage is 0%, so the description carries the burden of explaining parameters. It only says 'from a project,' which weakly maps to projectId and monitorId, but it provides no additional detail about formats, relationships, or required preconditions. The description adds minimal meaning beyond the parameter names already visible 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?

The description opens with a specific verb and resource: 'Delete a Monitor from a project.' It also distinguishes itself from the sibling disable_monitor by explicitly framing deletion as permanent removal and naming the alternative. This makes the tool's purpose unambiguous.

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

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

The final sentence is an explicit when-not-to-use rule: 'To stop a Monitor running without losing it, use disable_monitor instead.' This gives the agent a clear decision boundary between delete_monitor and its closest sibling, with no inference required.

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

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

Annotations already declare destructiveHint=true, and the description adds a valuable behavioral detail beyond that: the scripts referenced by the scenario's populations are left untouched, so destruction is scoped to the scenario only. This helps the agent understand the side-effect boundary.

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 one sentence with no filler. It front-loads the action and adds the important side-effect clarification immediately, making it easy to parse.

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 delete operation with destructive annotations already present, this description is largely sufficient. It names the action, scope, and the key side-effect boundary. It does not cover error behavior or irreversibility, but those are less critical 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?

Schema description coverage is 0%, so the description must compensate, but it only provides minimal implicit semantics: 'from a project' hints that projectId identifies the project and scenarioId identifies the scenario. It does not explain ID formats, required relationships, or any validation constraints.

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

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

The description clearly states the action ('Delete'), the resource ('a scenario'), and the scope ('from a project'). This distinguishes it from sibling delete tools like delete_dataset, delete_monitor, and delete_script by naming the specific resource type.

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

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

The description gives clear context: use this when you need to remove a scenario from a project. It does not explicitly name alternatives or say when not to use it, but the context is unambiguous enough for an agent to select it over the related delete_* siblings.

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

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

The annotation already declares destructiveHint=true, and the description merely restates the destructive action without adding behavioral context. It does not mention irreversibility, cascading effects on associated assets, or whether deletion requires special permissions. No extra value beyond the annotation is provided.

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-formed sentence with no filler. It immediately states the action, object, and scope, making it easy for an agent to parse.

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 delete operation with two string parameters and a destructiveHint annotation, the description covers the core necessities. It could be enhanced by noting permanence or lack of idempotency, but the annotation and schema already carry much of that weight, and the tool is simple enough that this is nearly complete.

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

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

Schema description coverage is 0%, so the description must compensate. It maps semantics to both parameters: 'a script' corresponds to scriptId and 'from a project' corresponds to projectId, indicating the parent-child relationship. This is useful but minimal; it adds no guidance on where to find these IDs or any value constraints.

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 ('Delete'), a specific resource ('a script'), and the containing scope ('from a project'). This unambiguously differentiates it from sibling tools like delete_script_asset, delete_dataset, and delete_monitor.

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 makes the basic use case obvious: when you want to delete a script within a project. However, it offers no explicit guidance on when not to use it, such as distinguishing between deleting a script and deleting a script asset, or noting any prerequisites like ownership or permissions.

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

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

The annotations already carry destructiveHint=true, so the destructive nature is covered. The description adds a useful nuance: it deletes a file attached to a script, not the script itself. However, it does not disclose effects like irreversibility, failure behavior if the path is missing, or permission requirements beyond what annotations imply.

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

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

The description is a single concise sentence that states the core action without fluff. It is appropriately short for a straightforward delete operation and avoids repeating the title verbatim.

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 three-string-parameter delete operation with no output schema, the description is minimally adequate but not complete. It lacks usage guidance, parameter clarification beyond the schema, and any note about consequences or prerequisites. The destructiveHint annotation covers one behavioral aspect, but overall context is thinner than ideal.

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

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

Schema description coverage is only 33%; only 'path' has a schema description. The tool description does not compensate by explaining projectId, scriptId, or path in more detail. 'A file attached to a script' vaguely suggests the identifiers' roles, but the description does not clarify what path means or how it relates to the asset, leaving critical parameter semantics under-specified.

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 ('Delete') and resource ('a file attached to a script'), clearly distinguishing it from sibling delete_script, which deletes the entire script. It also aligns with the script-asset family (get/list/put_script_asset) without ambiguity.

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

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

The description gives no explicit guidance about when to use this tool versus alternatives. It does not mention that delete_script should be used for removing the whole script, or that put_script_asset could be used to replace an asset. The intended use is inferable from the name, but 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?

Annotations already cover readOnly, destructive, and idempotent hints, so "Idempotent" earns nothing. The description adds what the annotations cannot: that disabling closes open Incidents, halts Cycles, stops Fuel/plan consumption, and that the returned summary carries a Dashboard link for re-enabling. There is mild tension between closing Incidents and destructiveHint=false, but since the action is reversible via enable_monitor this reads as a state change rather than a contradiction.

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?

Purpose and effects are front-loaded in the opening clause, and the later sentences carry prerequisites and the recovery path rather than filler. The closing clause about "the link the returned summary carries" is slightly convoluted but still informative.

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 at least hint at a returned summary containing a Dashboard link, and it covers side effects and permissions well. However, the two required identifiers are left completely unexplained, which is the one thing an agent must get right to call this tool successfully.

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

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

Schema description coverage is 0% and neither monitorId nor projectId is mentioned anywhere in the description. For a two-parameter tool whose schema is entirely bare, the description should at minimum indicate that monitorId identifies the target Monitor and projectId scopes it. That gap is unmitigated.

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 ("Disable a Monitor") and immediately enumerates the consequences: scheduled Cycles stop, Fuel/plan usage stops, open Incidents close. It never distinguishes itself from the close-by sibling delete_monitor, which is the main ambiguity an agent would face, but the described effects are concrete enough to separate it from update_monitor or get_monitor.

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

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

Gives the reverse operation (enable_monitor) and, more usefully, the access-level prerequisite: the tool is only present at "Read+Write+Execute" and below that the user must act in the Dashboard. That is real routing guidance. It stops short of saying when a caller should prefer delete_monitor or update_monitor instead.

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

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

The annotations already indicate this is a non-read-only, non-idempotent, non-destructive operation. The description adds meaningful behavior beyond those annotations by specifying that the destination must be 'another project the token can access' and that the copy's summary is returned. This gives useful operational context without contradicting the annotations.

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

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

The description is a single, efficient sentence that front-loads the core action and then adds the key optional behaviors. Every clause earns its place, and there is no redundant restatement of the title or schema.

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

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

With no output schema, the description appropriately includes that the operation 'Returns the copy's summary.' The tool is simple enough that the description plus the 100%-covered schema covers the essential behavioral and parameter information. A minor gap is that it does not mention whether related assets or revisions are copied, but this is not critical for a basic duplicate 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%, so the baseline is 3. The description adds at least one meaningful nuance beyond the schema by noting the destination project must be accessible by the token, which is a permission-relevant detail for destinationProjectId. It also implicitly maps 'new name' to the name parameter, but the schema already documents these fields well.

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

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

The description clearly identifies the operation as 'Duplicate a script' with an optional new name and optional destination project, which is distinct from creating or importing a script. It is a specific verb+resource pair with enough detail to differentiate it from sibling tools like create_script and import_script.

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

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

The description clearly implies when to use this tool: when an existing script needs to be copied, optionally renamed, or moved to another project. It does not explicitly name alternatives or state when not to use it, but the duplicate semantics are clear enough for an agent to select it appropriately among siblings.

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

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

Annotations already declare idempotentHint=true and destructiveHint=true; the description reinforces both and adds real operational context: an immediate Cycle starts, startedCycleId reports it and is absent when nothing started, and Cycles burn Fuel unless the plan covers them. What's missing is any warning about the cost/irreversibility of the immediate Cycle beyond 'burns Fuel'.

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?

Effect is front-loaded in the first sentence, then costs, guards, and idempotency in a logical order. The startedCycleId sentence is long and comma-chained, packing three absence reasons into one clause, which slightly hurts readability.

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, and the description usefully documents the returned startedCycleId and when it is absent, which an agent otherwise could not infer. The remaining gap is identifier semantics, though for a two-id mutation tool this is minor.

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

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

Schema description coverage is 0%, so the description carries the full burden, yet it never explains projectId or monitorId (e.g., whether projectId is the Monitor's owning project or how to obtain monitorId). Only the parameter names imply 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?

Specific verb (Enable) plus resource (Monitor) with a precise statement of effect: Cycles run on their schedule and a Cycle starts at once. It is clearly distinguishable from siblings disable_monitor, update_monitor, and create_monitor.

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

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

Explicit preconditions ('Enable only after the user confirms in this conversation'), explicit refusal case (unclaimed Trial), explicit idempotent no-op case, and the counterpart tool (disable_monitor) is named as the way to reverse it. It also routes to get_documentation topic 'faqs/plan-or-fuel' for cost questions.

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

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

Annotations already indicate a safe, read-only, idempotent operation. The description adds useful behavioral detail beyond the annotations: the schema is recursive, and some fields include a 'notes' string covering non-reflectable accepted keys. This helps the agent understand what the returned schema will contain.

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 the core purpose front-loaded and the second sentence adding genuinely useful detail about non-reflectable keys. No wasted words.

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

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

For a single-parameter read-only tool with an output schema, the description is complete. It tells the agent what the tool does, when to use it, and what to expect in the response, including a notable caveat about 'notes' strings.

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 input schema already describes the single parameter with an example. The description does not add new parameter-level semantics, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Get'), names the resource ('recursive schema for one command type'), and states the intended outcome ('build a valid command object'). This clearly distinguishes it from sibling tools like list_command_types and get_variable_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 description clearly implies the use case: when you need to construct a valid command object for a single command type. It does not explicitly name alternatives or state when not to use it, but the context is clear enough for an agent to select it appropriately.

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

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

Annotations already establish read-only, idempotent, non-destructive behavior, and the description adds meaningful context beyond that: default first-five-row sampling, pagination semantics, row-count comparison, and a caveat about header-looking rows requiring clarification. No annotation contradiction is present.

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 retrieval behavior, then adds paging and data-caveat details without filler. It is dense but every sentence contributes useful operational 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?

With no output schema, the description usefully previews the returned metadata and rows, explains sampling and rowCount interpretation, and warns about header rows. It is nearly complete for this read tool, though the meanings of projectId and datasetId are 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?

The schema already documents limit and offset with defaults and maximums, and the description reinforces their paging role. However, projectId and datasetId have no descriptions in either the schema or the description, so required-parameter semantics remain only partially covered at 50% schema coverage.

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

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

The description states a specific verb and resource: get one dataset, including its metadata shape and a window of rows. It also implicitly distinguishes this from list_datasets by specifying a single dataset and from mutation siblings by describing a read-style retrieval.

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 how to fetch more rows with offset and limit and warns about interpreting rowOffset against rowCount, but it does not explicitly say when to use this tool versus list_datasets, update_dataset, or other siblings. Usage is therefore clear but mostly 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?

Annotations already declare readOnly, idempotent, non-destructive, and closed-world, so the safety profile is covered. The description adds useful behavior beyond that: the 3-topic cap and the fact that omitting keys returns the full topic index with keys and URLs. It doesn't mention truncation/paging, but the schema covers maxLength and startIndex.

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 short sentences, front-loaded with the primary capability, then the invocation rules. No filler and nothing repeated unnecessarily.

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

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

For a read-only documentation tool with full schema coverage and no output schema, the description covers what is returned (topic keys/URLs or topic text) and how to select topics. The only mild gap is not hinting at the paginated/nested-topic structure, which the schema handles.

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

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

Schema coverage is 100%, so the baseline is 3. The description restates the topic/topics equivalence and the omit-both behavior that the schema already documents, adding only the explicit 'up to 3' cap in prose; it does not clarify what happens if both topic and topics are supplied.

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

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

The description gives a specific verb and resource ('List the Loadster manual's topics') and explicitly states the two modes: metadata listing versus reading up to 3 topics' text. It does not differentiate from documentation-adjacent siblings like get_example or get_scripting_api, keeping it 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?

'Pass one key as topic, or up to 3 keys as topics. Omit both to list every topic' gives clear selection rules for each mode. It stops short of naming alternatives (e.g., when to use get_example instead), so it is a strong 4 rather than a 5.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive, and closed-world, so the safety profile is covered. The description adds the useful trait that the returned content is a small, valid worked example, but says nothing about size limits, language, or what the example contains. Adds modest value over the annotations.

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

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

A single front-loaded sentence with no filler; every word (small, valid, worked example, starting point) earns its place and sets expectations for the output.

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-only lookup whose safety is covered by annotations, the description is nearly complete. The only gap is that no output schema exists and the description only loosely characterizes the returned script (small, valid), leaving exact format to inference.

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

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

Schema description coverage is 100%, so the enum values and the Browser-vs-Playwright ambiguity warning are fully documented in the schema itself. The description adds nothing about the botType parameter, 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 (Get) and resource (a small, valid worked example script) scoped by bot type. It reads clearly as distinct from get_script (a user's actual script) and get_scripting_api, though it never explicitly names those 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?

'To use as a starting point' implies a scaffolding/template use case, but there is no explicit when-to-use guidance or routing against alternatives like get_script or create_script. Usage is only inferable.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds useful behavioral context by listing what the call returns, including notification delivery outcomes and status events, and by framing it as a read that typically requires follow-up reads. There is no contradiction with annotations.

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

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

The first two sentences are information-dense and front-loaded with valuable details. However, the final sentence about the 'monitoring' topic covering thresholds or noise is off-topic for invoking get_incident and does not earn its place, making the description less economical than it could be.

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

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

With no output schema, the description compensates by naming the return categories and prescribing the reconstruction workflow. It is complete enough for an agent to understand what it will get and what to do next. The minor off-topic sentence does not undermine completeness.

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

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

The schema already documents incidentId as 'as reported by list_incidents', and projectId is left to its name. The description does not add parameter-level meaning beyond mentioning that it fetches a single Incident. With 50% schema coverage, this is adequate but not enhanced by the description.

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

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

The description clearly states the tool gets a single Incident and enumerates the exact data returned: open/close times, notifications with delivery outcomes, status events, and the IDs of Cycles that opened and closed it. The 'single' wording distinguishes it from list_incidents, and the referenced get_monitor_cycle_detail helps differentiate it from related detail tools.

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

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

The description gives explicit follow-up guidance: read the Cycles with get_monitor_cycle_detail and cross-read the Monitor configuration and Script to reach a concrete diagnosis. It does not explicitly say 'use this instead of list_incidents', but the single-incident framing plus the schema hint that incidentId comes from list_incidents makes the intended context 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?

Annotations already cover read-only safety, but the description adds crucial behavioral context: unfinished tests return an error naming their status, advice buckets are heuristic not diagnostic, and the agent must reconcile buckets against the full data and name concrete elements. This goes well beyond what annotations provide.

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 report contents and error behavior before moving to advice guidance. It is dense but every sentence adds value—the final sentence about cross-reading Scenario and Scripts is long but actionable. Slightly verbose but appropriate for a report tool.

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

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

Given the tool's complexity, annotations, and the presence of an output schema, the description is complete: it explains what is returned, error behavior for unfinished tests, the heuristic nature of the advice data, and how to use the report for user advice. Nothing critical is missing.

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

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

Schema coverage is 75%, with descriptions for testId, loadTestId, and errorUrlLimit including detailed semantics in the schema. The tool description itself does not elaborate on parameter meaning beyond implying a finished test is required and the report's contents. Baseline 3 is appropriate since the schema carries the parameter semantics.

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 ('Get a finished Load Test's Test Report') and enumerates exactly what the report contains: aggregate totals, advice context, per-Population outcomes, and per-engine CPU stats. This distinguishes it from sibling tools like get_load_test_status and get_load_test_url_timings without opening their 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?

It clearly sets context: use for a finished test, and unfinished tests answer with an error naming their status, which implicitly tells the agent not to use this for status checks. It also instructs reading the 'analyzing-test-results' documentation and cross-reading Scenario/Scripts before advising. However, it does not explicitly name alternative tools (e.g., get_load_test_status) for incomplete tests.

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?

Beyond the readOnly/idempotent annotations, the description discloses a rate limit (10s minimum interval), the fact that a 'note' field signals test completion, and the polling lifecycle (stop polling when finished). These are operational traits an agent cannot get from the annotations alone.

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

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

Front-loaded with the core purpose followed by usage, rate limit, and termination guidance, all of which earn their place. The long enumeration of returned metrics is informative but heavy, slightly overlapping with the output schema.

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

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

An output schema exists, so the return-value explanation is partly redundant, but the description still covers purpose, cadence, termination, and the handoff to get_load_test_report. Only projectId semantics remain unaddressed, a minor gap for an ID parameter.

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 50%: loadTestId is documented as coming from list_load_tests, while projectId is undocumented in both schema and description. The description adds no parameter-level meaning of its own, which is the baseline-3 case at this coverage level, though the parameters are simple identifiers.

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 ('Get a Load Test's live status') and enumerates exactly what is returned: stage, elapsed time, bot counts per Population, percentiles, throughput, errors, engine region/online state/CPU. It is clearly distinguishable from get_load_test_report (final report) and get_load_test_url_timings, which it explicitly contrasts.

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

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

Gives explicit when-to-use ('tell the user how a test in progress is going', 'tell an overloaded engine from a slow target'), explicit when-to-stop ('once the test is over... stop polling'), and names the alternative action ('read the Test Report with get_load_test_report'). It also specifies a concrete polling cadence of no more often than every 10 seconds.

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

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

Annotations already cover read-only, idempotent, non-destructive, so the description spends its words on what actually matters: sorting by total time across all hits, units in milliseconds, and that results are paginated with a totalUrls field to detect truncation. Minor blemish: it refers to 'urlOffset' while the parameter is named 'offset', which could momentarily confuse an agent.

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 dense sentences: purpose plus returned fields first, then the sibling relationship and the paging check. Every clause earns its place, though the metric enumeration is long and the trailing 'page on with offset' clause is slightly redundant with the offset parameter 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?

An output schema exists, so the description needn't enumerate return structure exhaustively, yet it still names the metrics and the totalUrls field used to judge completeness. Combined with the pagination guidance and the finished-test precondition, an agent has everything needed to invoke and interpret this tool correctly.

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

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

Schema coverage is 75% (limit, offset, loadTestId documented; projectId bare), so the description adds genuine value: it explains offset-based paging against totalUrls and that ordering is by total time, which tells the agent how offset interacts with the result set. It does not restate the default-20/max-100 bounds, but the schema already does.

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 (response times per URL for a finished load test) plus the sort order and the exact metrics returned. It is clearly distinguishable from the report/percentile sibling because it names that sibling and positions itself as the drill-down view.

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

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

Explicitly says 'Use it to name the slow pages behind the percentiles in get_load_test_report', which routes the agent to this tool after reading a report. The 'finished Load Test' qualifier implicitly excludes in-progress tests, but no alternative is named for that case (e.g. get_load_test_status).

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

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

Annotations already cover read-only, idempotent and non-destructive behavior, so the bar is lower; the description adds real value beyond that by disclosing an access-level gate ('Read+Write+Execute') under which the tool is absent, and by noting the returned dashboard link. It does not describe the shape of the returned configuration, though the config-vs-steps split covers the most likely confusion.

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

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

Front-loaded with the primary action and scope, then alternates and fallbacks. Four sentences, each carrying distinct information with no repetition of the name or annotations. The access-level sentence is the longest but earns its place by explaining the absent-tool behavior.

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 two return elements (configuration and dashboard link) and by pushing steps to get_script. What remains uncovered is the internal shape of the configuration, which the reference to the 'monitoring' documentation topic partly addresses.

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

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

Schema coverage is 0%, so the description would ideally clarify projectId and monitorId, and it says nothing about either. The names are largely self-describing and the phrase 'a single Monitor' implies the identifier, which keeps this at minimum-viable rather than failing, but format or scoping details (e.g. whether monitorId is globally unique or project-scoped) are absent.

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 ('Get a single Monitor's full configuration and dashboard link') and immediately bounds scope to configuration, explicitly disclaiming steps. That boundary distinguishes it from get_script, get_monitor_cycle_detail and list_monitors without the agent needing to open any schema.

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

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

Gives concrete routing rules: steps come from get_script, enabling a disabled Monitor goes through enable_monitor, and there is a documented fallback path (Dashboard link) when the access level is insufficient. It names both the alternative tool and the conditions that select 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context beyond the schema: it explains that scriptRunId behaves like a played run, that the cycle names a scriptId for cross-reading, and how the detail connects to incident cycle references. It doesn't disclose things like pagination or response shape, but there is no output schema and the key relational traits are well described; a 4 is warranted given the strong context added.

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

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

The description is three sentences and front-loads the primary purpose ('Get one Cycle in full') before moving to related-tool routing. Every sentence adds either outcome detail or cross-tool guidance, and it avoids fluff. The only structural weakness is that it's a dense run-on sentence in the middle, but it remains readable and efficient.

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

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

For a read-only two-parameter detail tool with annotations covering safety, the description is nearly complete: it names the fields returned, explains cycleId provenance, and routes to sibling tools for deeper drill-down. It doesn't specify the exact output shape or mention what happens when a cycle is missing or in progress, and there is no output schema, but the essential usage context for an agent is present. A 4 reflects that it's strong but not exhaustive.

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

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

The schema already documents cycleId with the same source note ('as reported by list_monitor_cycles or an Incident's cycle references'), so the description's one parameter detail is redundant. projectId has no schema description and the description doesn't explain what the project id is for or how to obtain it. Schema coverage is 50%, so the description only partially compensates; it clarifies the source of cycleId but leaves projectId unexplained, so a 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 ('Get') and resource ('one Cycle in full') and enumerates exactly what fields are returned: status, failure message, engine, timestamps, and metrics. It also distinguishes this tool from siblings like list_monitor_cycles, get_play_status, and get_step_detail, so an agent can tell them apart 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?

The description explicitly says when to use this tool: with a cycle id from list_monitor_cycles or an Incident's cycle references. It also gives concrete routing guidance to alternatives—pass scriptRunId with project id to get_play_status for per-step results and get_step_detail for the exact failed request/response—and points to the 'monitoring' topic for threshold context. This is explicit when-to-use and when-to-use-other guidance.

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

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

Annotations already establish read-only, idempotent, non-destructive behavior, so the description does not need to repeat that. It adds useful behavioral context: defaulting to the last 7 days, per-Monitor and per-day aggregates, times in seconds, and a performance score range of 0-100. It could disclose more about edge cases or output shape, but the added context is solid.

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 focused sentences. The first front-loads the core purpose and key output semantics; the second routes to alternatives; the third is a concise prerequisite for interpretation. Every sentence earns its place with no redundancy.

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

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

For a read-only summary tool with no output schema, the description covers what it returns (aggregates, trends, units, score range), the defaults, related drill-down tools, and a required prerequisite reading step. This is enough for an agent to select and invoke the tool correctly without further clarification.

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 covers since and until with ISO-8601 descriptions, and the tool description adds period defaults. projectId lacks a schema description but is clearly implied by 'for a project'. The description also frames since/until meaningfully as the period for the aggregate health picture, which helps the agent understand the parameters' role.

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

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

The description identifies a specific verb ('Get'), resource ('Monitoring Summary'), and scope ('for a project: the aggregate health picture across its Monitors over a period'). It differentiates this aggregate tool from the more granular siblings by explicitly naming list_incidents and list_monitor_cycles as drill-down alternatives.

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 clear direction: use this tool for an aggregate monitoring health picture, and 'Drill down instead of asking for more' with specific sibling tools. It also instructs reading the 'monitoring' topic before interpreting results, which helps the agent use the output correctly. This is explicit usage guidance beyond what the schema provides.

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

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

Annotations already declare this tool read-only and idempotent, and the description meaningfully supplements that by explaining progressive filling of results, the wait-expiry return behavior, has-flag semantics, Playwright runner log placement, and screenshot ordering. This is rich behavioral context beyond what the annotations provide.

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 dense but every sentence contributes operational guidance: core purpose, polling advice, completion condition, drill-down guidance, and output interpretation details. It is structured with the most important usage instruction early, followed by progressively deeper behavioral notes.

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

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

Given the tool has an output schema and read-only annotations, the description covers everything an agent needs to use it correctly: when to call it, how long to wait, how to detect completion, how to interpret has-flags, and how to understand screenshot and log placement. No critical operational context is missing.

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

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

Schema coverage is 67%, with scriptRunId and waitSeconds already documented in the schema. The tool description adds practical context around waitSeconds usage, but projectId remains undocumented and the description does not add meaning for that parameter. Overall, the schema carries most of the parameter documentation burden.

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

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

The description clearly identifies the resource (a play) and the action (get current state), and further specifies it returns per-step results and logs. It differentiates itself from related tools by referencing play_script and get_step_detail, so an agent can select it correctly.

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

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

The description explicitly tells the agent when to use this tool: after play_script, call this with waitSeconds instead of polling. It also states when results are complete (running is false) and advises drilling down with get_step_detail only where has-flags are true.

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

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

Annotations already establish that this is read-only, idempotent, and non-destructive. The description adds substantial domain behavior beyond that: how to interpret the Fuel estimate, when estimatedFuelLow/High is present, what launchBlockers means, and how omitted population fields default.

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

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

The purpose is front-loaded and the content is relevant, but the description becomes dense and rambling, especially the long conditional explanation of when a Fuel estimate is present. It is informative rather than wasteful, but some clauses could be tightened.

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 read-only getter with an output schema and strong annotations, the description is complete enough: it explains the returned scenario contents, defaults, launch readiness, and documentation references. The main gap is that the required IDs are undocumented in both schema and description.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters, but it never mentions projectId or scenarioId or where to obtain them. The parameter names are self-evident, which prevents a 1, but the description adds essentially no parameter 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?

The description states a specific verb and resource: get a single scenario, including Populations, dashboard link, and launch readiness. It clearly distinguishes this from list_scenarios by emphasizing a single scenario, and it names concrete returned fields such as fuelBalance and launchBlockers.

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 by phrases like launchBlockers meaning it can launch as it stands, and by the downstream reference to launch_load_test. However, it never explicitly says when to use this tool versus list_scenarios or update_scenario, and it gives no exclusions for retrieval.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds the return-type trait ('viewable image') and the source of the key parameter, which is genuine context beyond the annotation hints. No contradiction with annotations.

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

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

Two sentences, each earning its place: the first states action and output type, the second states the data-source flow. Purpose is front-loaded and there is zero filler.

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

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

For a simple three-parameter fetch with rich annotations, the description covers purpose, output format, and the input-flow. The remaining gaps — the precise delivery format of the image and the meaning of the two ID parameters — would improve it but are not critical for a correct call.

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

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

Schema coverage is only 33%, so the description must compensate. It meaningfully explains screenshotKey's provenance (from a step in get_play_status), but projectId and scriptRunId receive no documentation in either the schema or the description; their names are self-explanatory, which prevents a lower score.

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 ('Fetch') and resource ('a screenshot captured during a play') and clarifies the output is a viewable image. The play-context framing distinguishes it from the many other get_* siblings, none of which deal with screenshots.

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?

Sentence 2 gives clear when-to-use context: this tool consumes a screenshotKey produced by get_play_status, establishing the prerequisite call flow. It stops short of explicitly naming alternatives or exclusions, but no sibling offers a competing screenshot-fetching path, so the omission is minor.

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

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

Annotations already cover the operational profile (readOnlyHint=true, idempotentHint=true, destructiveHint=false), lowering the burden. The description adds value beyond annotations by disclosing what the response contains and clarifying the domain semantics of 'variables' as dataset bindings that resolve ${...} references. No contradiction with annotations.

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

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

Two sentences with zero filler: the first front-loads purpose and return contents, and the second earns its place by disambiguating the potentially confusing term 'variables.' Nothing extraneous is present.

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

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

For a simple read-only getter with two required string parameters, the description covers the essential facts an agent needs: what is fetched, what the response includes, and what 'variables' means. The residual gaps — sibling differentiation and parameter format details — are accounted for in other dimensions, and annotations carry the operational traits.

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

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

Schema description coverage is 0%, so the description must compensate for parameter documentation, but it says nothing about projectId or scriptId beyond what the parameter names imply. The names are self-explanatory, yet the description supplies no format, origin, or relationship guidance for either parameter.

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

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

The description states a specific verb+resource ('Get a single script') and itemizes the return contents: 'full command list and variables, plus a dashboard link.' The qualifier 'single' distinguishes it from list_scripts, and the content details separate it from sibling getters like get_script_revision and get_script_asset.

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 is provided, and no alternatives are named despite lookalike siblings such as get_script_revision and get_script_asset. The description states what the tool does but leaves the agent to infer when it is the right choice.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds the base64 encoding detail, which is useful, but does not disclose other behaviors such as error cases or whether path must be relative to a specific root.

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 one efficient sentence, front-loads the action, and contains no redundant words. Every part 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 read operation, the description plus annotations provide a reasonable baseline, and the base64 return format is stated. However, with no output schema and sparse parameter documentation, the description leaves some ambiguity about asset path semantics and expected response structure.

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

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

Schema description coverage is only 33%, with only 'path' having a generic description. The tool description adds no explanation of projectId, scriptId, or how they relate to identifying a script asset, so the description fails to compensate for the low schema coverage.

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

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

The description states a specific verb ('Read'), a clear resource ('script asset's content'), and the output encoding ('as base64'). It is clear but does not explicitly distinguish itself from sibling tools like get_script or list_script_assets.

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 use when the agent needs to retrieve a script asset's content, and the read-only annotation reinforces this. However, it does not explicitly mention when to prefer this over siblings like list_script_assets or get_script.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds meaningful behavioral detail beyond that by explaining the two modes: omitting scope lists available scopes, while providing one fetches members with signatures and docs.

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, dense sentence with no filler. The main action and resource are front-loaded, and the optional behavior is stated compactly.

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

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

This is a low-complexity tool with one optional parameter and no output schema. The description covers both invocation modes and what the agent should expect in response (list of scopes or members with signatures/docs), which is sufficient for correct use.

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

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

The input schema already fully documents the single optional 'scope' parameter with an example and the omit-to-list behavior, so schema coverage is 100%. The description reinforces the mode distinction but does not add significant new parameter-level 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 uses specific verbs ('List', 'fetch') and names the exact resource: scripting API scopes and their members. The phrase 'available in code blocks' distinguishes this from schema/documentation siblings like get_command_schema or get_documentation.

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

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

The description provides clear context for when to use the tool: when an agent needs scripting API scopes or member signatures/docs in code blocks. It does not name alternatives or exclusions, but the tool's purpose is specific enough that the usage context is reasonably 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?

Annotations already disclose read-only, idempotent, and non-destructive behavior. The description adds that the response includes commands, which is useful beyond the structured fields. However, it does not describe the full return shape or behavior for invalid versions, leaving some ambiguity that annotations do not fully cover.

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 filler. Every phrase adds meaning: the action, the target resource, the included content, and the intended use case.

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 basic what and why, and annotations cover safety. However, with no output schema, it does not fully describe the return value beyond 'commands,' and it omits guidance that valid version numbers might come from list_script_revisions. This leaves moderate gaps for an agent trying to call it correctly without additional 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 description coverage is only 33%, with only 'version' described. The tool description does not compensate by explaining 'projectId' or 'scriptId' beyond their self-evident names, and it does not clarify required formats or relationships between the parameters. This is a significant gap given the low schema coverage.

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

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

The description uses a specific verb and resource: 'Get a specific past revision of a script.' It also adds 'including its commands,' which distinguishes it from list_script_revisions and get_script by clarifying that it returns executable content, not just metadata.

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?

'So you can inspect or diff it' provides a clear use case for when this tool is appropriate. It does not explicitly name alternatives or exclusions like get_script or restore_script_revision, but the intended context is evident from the wording.

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

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

Annotations already establish readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds useful behavior beyond that, such as the ability to request multiple steps in one call, the bot-type-shaped nature of parts, and the error behavior when requesting a part with no source available.

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 focused four-sentence paragraph with the main purpose front-loaded and no redundant filler. The phrase 'bot-type-shaped' is somewhat cryptic and could obscure the meaning, but overall the structure is efficient and 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?

Given the tool's moderate complexity, the annotations, and the presence of an output schema, the description covers the core purpose, common usage patterns, and important error behavior. It does not fully explain 'bot-type-shaped' parts or exhaustively cover all parameters, but the schema fills those gaps and the description is sufficient for an agent to invoke the tool correctly.

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

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

Schema description coverage is 80%, so most parameters are already documented. The description adds meaning by explaining the parts payload conceptually and by illustrating that stepIndexes can combine dependent steps, such as a failing request and the step that captured a token, in a single call.

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 and resource: it reads the payloads get_play_status leaves out, such as response bodies, headers, captured values, console messages, network activity, HTML, and logs, for one or more steps of a play. It also explicitly distinguishes itself from get_play_status by describing what this tool adds beyond 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?

The description gives clear context for when to use the tool: when you need detail beyond get_play_status, and it explicitly recommends using this instead of adding a validator or code block to echo a response. It does not explicitly state when to prefer get_play_status or other alternatives, so the guidance is strong but not fully exclusionary.

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

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

Annotations already mark the call read-only/idempotent/non-destructive, and the description adds substantial behavioral context: variables act as cursors, advancing per occurrence/iteration/bot depending on updateStrategy and choosing rows sequentially/randomly via selectionStrategy. It also documents reference syntax and the follow-up validation step, going well beyond the structured fields.

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

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

Four sentences, each earning its place: purpose, variable semantics, reference syntax, and post-edit validation. The most important identification information is front-loaded and the description avoids repetition of the title or 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?

For a no-argument metadata getter, the description covers what the schema contains and how to use the result, and it works well with the read-only annotations. It could be more complete by explicitly describing the shape/format of the returned schema, but the lack of an output schema makes this a minor gap rather than a critical omission.

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

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

The input schema has zero parameters, so there is no missing parameter documentation; the baseline for no-parameter tools is 4. The description adds useful domain semantics (dataSetId, updateStrategy, selectionStrategy) even though those are concepts in the returned schema rather than call parameters.

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

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

The first sentence names a specific verb and resource: 'Get the schema for binding a script variable to a dataset,' including update/selection strategies. This is clearly distinct from sibling tools like get_command_schema because it focuses on script variable-to-dataset binding.

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

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

The description gives clear context for when the tool is relevant: when working with script variable bindings and their strategies, and it advises running validate_script after changing bindings/references. It does not explicitly name alternatives or state when not to use it, but the intended use 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?

Annotations declare destructiveHint=true and readOnlyHint=false, and the description elaborates with critical side effects: it may create script assets, datasets, and a scenario, and replace=true replaces existing commands and variables. This adds meaningful behavioral detail that annotations alone do not convey, such as the scope of destruction and what gets created. It does not contradict annotations, and the description's mention of 'replace' aligns with destructiveHint.

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

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

The description is three sentences, each earning its place: the first defines the action and inputs, the second summarizes side effects, and the third provides an exclusion with a clear alternative. It is front-loaded with the core purpose and uses no filler or repetition.

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

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

Given the tool's complexity (parsing multiple formats, side effects, replace semantics) and the absence of an output schema, the description is thorough: it covers what inputs are needed, what happens on success (returns action items), the meaning of replace, and the exclusion case. No critical operational detail is missing for an agent to decide whether to call it.

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 83%, leaving the projectId parameter undocumented in the schema. The description does not explicitly describe each parameter, but it explains the overall purpose of 'source', 'content', and 'replace', and it mentions that import may create assets/datasets/scenario, which gives context for scriptId and projectId. While it doesn't fully compensate for the missing projectId description, the schema covers most parameters, so a slight bonus above baseline is warranted.

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 (import) and resource (open-source load test scripts into Loadster), enumerates the supported source formats, and explicitly contrasts with OpenAPI/Swagger and Postman, which are not supported. This clearly differentiates the tool from siblings like create_script and makes its purpose unmistakable.

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 explicit guidance on when to use this tool (for JMeter, k6, Locust files) and when not to (for OpenAPI/Swagger or Postman), even naming the alternative tool (create_script) to use instead. This goes beyond basic context and gives actionable 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?

Beyond the annotations (destructive/non-idempotent/openWorld), it discloses economically meaningful behavior: real traffic hits the user's site, Fuel is consumed when an estimate exists, refusals burn no Fuel and carry a reason, launchBlockers cause refusal with a list, and a timeout leaves launch state ambiguous so list_load_tests must be checked. That last point is exactly the context a non-idempotent tool needs. It also describes the return payload (id, stage, Dashboard link).

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

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

Front-loaded with the core action and the approval prerequisite, then moves to failure modes and follow-up tools in a logical order. It runs long and repeats the refusal theme twice ('the refusal gives the reason' and 'a refusal carries their message'), which is minor waste but not enough to obscure the instructions.

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 destructive, non-idempotent, open-world call with no output schema, the description covers preconditions (approval, Fuel reporting, launchBlockers), failure and timeout handling, and explicitly describes the result fields and the follow-up tools (get_load_test_status, stop_load_test). Nothing an agent needs to invoke it safely is missing.

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

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

Schema coverage is only 33% — label is documented in the schema, but projectId and scenarioId have no descriptions there. The description implicitly frames scenarioId as a saved Scenario read via get_scenario and projectId as its owning project, but never states that explicitly or discusses the optional label, so the coverage gap is only partially compensated.

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 ('Launch a saved Scenario as a Load Test, exactly as stored') and immediately distinguishes itself from creation/query siblings by noting the scenario must already exist and be read via get_scenario first. An agent can tell this apart from create_scenario, create_monitor or get_load_test_status without opening any schema.

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

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

Explicitly prescribes the sequence: read with get_scenario, report the Fuel estimate range and fuelBalance to the user, and launch only with approval. It also gives alternatives for edge cases — launch from the Dashboard when the plan refuses, and check list_load_tests before retrying after a timeout.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so the safety profile is covered. The description adds value by disclosing the return content (each type plus a description and the bot types it applies to), which matters since no output schema exists.

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

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

Two short sentences, no filler, with the purpose front-loaded and the workflow hint second. Every clause carries information.

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

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

For a single optional-param read-only list tool with strong annotations, the description covers purpose, timing and return content. Only the absence of routing versus sibling discovery tools (get_command_schema, get_scripting_api) keeps it from being 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?

Schema coverage is 100% and the enum description is unusually rich, including the "Browser script" ambiguity warning and the omit-to-list-all behavior. The description only echoes "available for a bot type," adding nothing beyond the schema, so the baseline 3 is 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?

It states a specific verb+resource (list the command/step types) and clarifies that results are the available types for a given bot type, so the agent knows exactly what it returns. It stops short of naming how it differs from look-alike siblings such as get_command_schema or get_scripting_api.

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

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

"Use this before authoring commands" gives a clear workflow trigger, which is genuine usage guidance. It never names the obvious alternative (get_command_schema) or states when this is the wrong pick, so routing between similar discovery tools is still left to inference.

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

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

Annotations already declare readOnly, idempotent and non-destructive, so safety is covered. The description adds real context beyond that: results are scoped to one project, tag output is names-only without full value tables, and tags are team-shared, which is non-obvious behavior an agent would otherwise miss.

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 result contents are front-loaded in the first clause, so an agent knows what it gets before anything else. The second sentence about tag reuse is slightly tangential to listing, but it is short and useful for the follow-on tagging workflow.

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 a single simple parameter, the description carries the needed burden by naming the returned fields and clarifying that tag values are omitted. Reading it, an agent can call this correctly without further guessing.

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

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

There is one required parameter, projectId, with 0% schema description coverage and no explanation in the description. The name is largely self-explanatory and the project scope is implied by 'in a project', but no format, source, or defaulting guidance is provided.

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 ('List the datasets in a project') and enumerates what comes back (id, name, row/column counts, tag names), which implicitly separates it from get_dataset. It stops short of naming get_dataset as the sibling that returns full data, so the differentiation is inferred rather than stated.

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

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

The phrase 'without the full value table' implies get_dataset is the right tool when full data is needed, but the alternative is never named and no explicit when-to-use statement is given. The tagging advice ('reuse a name the list tools already report') is an implied workflow cue rather than a usage rule for 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?

Annotations already declare read-only, idempotent, closed-world, non-destructive behavior. The description adds substantial domain behavior beyond that: caps and stage bounds are enforced on save, while capacities, locked regions, and per-region/per-engine caps matter only at launch and never block a save. It also explains the trial-specific locked entry behavior and the peak-bot limit.

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 purpose and the id constraint, then proceeds through engine types and enforcement timing. It is dense and every sentence contributes domain-critical information, though it is longer than strictly necessary for a list 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?

With no output schema and no parameters, the description carries the burden of explaining what is returned and how it is used. It describes entry ids, the three engine types, locked behavior, and limit fields, which is substantial. It does not fully enumerate the response shape, leaving a small 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?

The tool has zero parameters, so the baseline is 4. There are no parameters requiring semantic clarification, and the description does not need to explain schema details.

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: 'List everywhere a population can run.' It then defines what an engine is by classifying CLOUD, WILDCARD, and PRIVATE, and states the critical role of the entry id. This gives an agent a clear, differentiated understanding of the tool beyond the bare name.

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

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

The description supplies clear usage context: never invent an id, use the entry's id as a population's engineId, and for free-trial customers place populations on an entry with locked false. It does not explicitly name alternative sibling tools or when not to call this one, so it stops short of a 5.

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

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

Beyond the readOnly/idempotent annotations, the description adds sorting order, default unresolved-only behavior, Incident lifecycle semantics, and the 'lean rows' expectation. This is meaningful behavioral context that helps an agent predict results and 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 dense and mostly front-loaded with the core behavior. The lifecycle explanation is useful, though phrases like 'incident archaeology' and the final monitoring-topic sentence add color rather than critical operational guidance.

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?

It covers sorting, default filtering, optional filters, lifecycle behavior, and directs users to get_incident for detailed fields. With no output schema, it does not enumerate exact returned fields, but 'lean rows' and the pointer to get_incident provide adequate guidance for agent selection and invocation.

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 high (83%), so the description need not restate parameter meanings. It adds some context around since/until as a window and includeResolved as 'incident archaeology', but most parameter semantics are already in the schema. The projectId parameter lacks a schema description, but its meaning is obvious from the tool name.

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

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

The description clearly states the tool lists a project's Incidents with specific sorting and default filtering behavior. It also distinguishes itself from get_incident by noting that list rows are lean and details are available from get_incident.

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 explains when to use includeResolved, since/until, and monitorId, and directs users to get_incident when they need richer detail on a single Incident. This gives an agent clear decision criteria among sibling tools.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds useful behavior: results are ordered with in-progress tests first and finished tests newest-first. It also notes that this surface does not delete anything and that launch/stop require elevated access, though it does not detail result shape or pagination beyond the schema's limit/offset controls.

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 core listing behavior and ordering, then adds useful context about siblings and access level. It is slightly longer than strictly necessary because it explains sibling actions, but every sentence remains relevant and no critical information is 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?

With no output schema, the description appropriately explains that results are summary rows with stage information and ordered by in-progress versus finished status. It also points to sibling tools for deeper status and report views, though it does not enumerate the exact summary fields returned.

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

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

The schema description coverage is 67%, with limit and offset already documented as page size and zero-based offset. The description implies project scoping and windowed pagination through 'a project's Load Tests' and 'a window of summary rows', but it does not add format or constraints beyond what the schema provides, leaving projectId only indirectly defined.

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 (list a project's Load Tests) plus the ordering behavior: in-progress first with stage, then finished newest-first. It clearly distinguishes this listing tool from status-report and report-reading 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?

It explicitly routes the agent: use get_load_test_status to follow an in-progress test and get_load_test_report for a finished test's report. It also clarifies that launch/stop are separate actions requiring the Read+Write+Execute access level, so the agent knows when this tool is and is not the right one.

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

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

Annotations already mark this as read-only, idempotent, and non-destructive, so the bar is lower. The description adds valuable behavior: newest-first ordering, one row per Cycle, included fields, and the meaning of a Cycle with no status yet. No contradiction with annotations.

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

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

The description is three sentences with no wasted words. It front-loads the core behavior and output, then adds usage context and a pointer to related documentation, all in an efficient structure.

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

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

There is no output schema, so the description carries the burden of explaining the return shape; it does so clearly with fields, ordering, and status semantics. It also gives filtering guidance, an alternative tool, and a doc pointer, making it complete for the tool's complexity.

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

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

The schema already documents limit, since, and until with formats and constraints. The description adds contextual value by suggesting since/until/limit for pattern spotting, but it does not add meaning for monitorId or projectId beyond what their names imply.

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 ('List a Monitor's Cycles'), specifies ordering ('newest first'), and describes the row-level fields returned. It clearly distinguishes this from the sibling get_monitor_cycle_detail by framing this as the overview listing tool.

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

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

It names the exact use case: spotting patterns like flapping, slow drift, or regional failures. It also names the alternative tool for deeper investigation ('drill into one Cycle's full metrics and failure message with get_monitor_cycle_detail'), giving clear routing guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, so the safety profile is covered. The description adds meaningful behavioral context: CLOUD vs PRIVATE semantics, PRIVATE being the only kind that can reach customer-network hosts, and the ID-reuse warning. It could mention output format or pagination, but that's not critical for a 0-parameter read-only list.

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

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

Four sentences, each earning its place: purpose, ID warning, CLOUD/PRIVATE explanation, and relationship to siblings. The core purpose is front-loaded and there is no redundant restatement of the title.

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

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

For a parameterless read-only list with rich annotations, this is complete. It tells the agent what the entries mean, how they relate to other tools, and when to consult this endpoint, so no additional context is needed for correct invocation.

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

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

There are zero parameters, so the schema needs no elaboration. The description compensates by explaining the meaning of the returned entries' types and how the ids are consumed by other tools.

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: 'List everywhere a Monitor's Cycles can run from.' It distinguishes itself from list_engines by explicitly noting monitoring locations are their own set, not the load test regions list_engines offers.

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 explicit when-to-use guidance: 'Read this before create_monitor or update_monitor.' It also warns against inventing IDs, tells the agent these IDs are what engineIds names, and names the sibling list_engines as offering a different set.

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

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

Annotations already declare readOnly, idempotent, non-destructive, so safety is covered; the description adds the meaningful behavioral detail that rows are summaries lacking thresholds and engine ids. It does not mention volume, pagination, or ordering, which keeps it below a 5 for a list operation.

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

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

The purpose and the get_monitor pointer are well front-loaded, but the trailing tag-management paragraph describes how to create and reuse tags, which is not an action this read-only list tool performs. It reads as boilerplate shared across list tools and dilutes the payload.

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 rich annotations and no output schema, the description covers what is returned (summaries, not full config), where to go next, and which documentation topic explains the domain model. The only gap is nothing about result size or pagination.

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

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

There is a single required projectId at 0% schema description coverage, and the description only implies it via 'in a project' without giving a format, source, or how to obtain a valid id. That is the baseline-adequate minimum rather than compensation for the coverage gap.

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

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

States a specific verb and resource ('List the Monitors in a project') and then defines what a Monitor actually is, which the agent cannot infer from the name. It explicitly distinguishes itself from the sibling get_monitor by naming it as the path to full configuration.

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

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

Gives explicit routing: use this for summaries, use get_monitor for full configuration, and read the 'monitoring' documentation topic for how Monitors, Cycles, and Incidents behave. Alternatives and the condition that selects them are both 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds non-annotation behavior: the result carries id and name, and the empty-team case returns a message that points at create_project. It does not mention ordering or pagination, but for a zero-arg list tool that is a minor 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?

Front-loaded with the core purpose, then the empty-case behavior, then the creation preference. The last two sentences edge toward guidance for a different tool (create_project), which is useful but slightly beyond this tool's remit; still, 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?

With no output schema, the description correctly fills the gap by describing what comes back (id, name) and the empty-result behavior. For a no-parameter read-only list tool, an agent has everything it needs to call it correctly and interpret the response.

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

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

The tool takes zero parameters, so the schema has nothing to explain and the baseline is 4. The description still clarifies the shape of each returned entry (id and name), which is the only 'input-like' contract an agent needs here.

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

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

States a specific verb and resource ('List the Loadster projects'), scopes it ('the current token can access'), and names the returned fields ('each with its id and name'). An agent can distinguish it from create_project and the other list_* siblings without opening any schema.

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

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

Explicitly routes the agent: 'call list_projects first', create only if the team has none or the user asked, and 'ask the user before creating' when unsure. The alternative (create_project) is named along with the exact condition that selects 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?

Beyond the readOnly/idempotent annotations, it discloses meaningful behavior: access-level gating ("Read+Write+Execute"; below that the tool is absent), that saving a scenario costs nothing and runs nothing, and that tags are team-shared. The tagwrite guidance is tangential to a read-only list tool and partly serves other tools, keeping it from a 5.

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

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

The lead sentence is well front-loaded with the return fields and the get_scenario contrast. However, the trailing paragraph on tag creation/reuse is unrelated to a read-only list operation and dilutes focus, and the Scenario definition could be tighter.

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 the job of enumerating returned fields and their units (duration in milliseconds), and it covers prerequisites and the launch alternative. It stops short of noting ordering, pagination, or volume limits for a list endpoint, and says nothing concrete about the required projectId.

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

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

The single projectId parameter has 0% schema description coverage, and the description only implies its meaning through "in a project". It adds no format, source, or lookup guidance (e.g., obtainable from list_projects), so it does not compensate for the undocumented parameter.

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

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

Specific verb+resource ("List the scenarios in a project") with an explicit field manifest (id, name, version, population count, peak bots, duration, tags) and a direct contrast against get_scenario's heavier payload. It also defines what a Scenario is, so an agent can distinguish this browse-only tool from get_scenario, create_scenario, and list_load_tests without opening any schema.

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

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

It routes the agent away from this tool when full detail (populations, fuel estimate, launch blockers) is needed, implicitly pointing at get_scenario, and it explains the execution path via launch_load_test. It never states an explicit "use X instead when Y" rule for get_scenario or list_load_tests, so the choice is clear in context but not spelled out as a conditional.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safe read-only profile is covered. The description adds useful behavioral context by defining the asset types and explaining how paths are used as command reference keys.

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, front-loaded sentences with no filler. The main action and scope are stated immediately, and the path-as-key clarification is meaningful rather than 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 simple read-only list operation with rich annotations and only two straightforward parameters, the description is nearly complete. It could explicitly state the return shape or empty behavior, but the path-as-key sentence provides enough functional context, especially since no output schema exists.

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

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

Schema description coverage is 0%, so the description must compensate for parameter documentation. It never explains scriptId or projectId, how they relate, or where they come from. The parameter names are self-explanatory, but the description adds no direct parameter semantics.

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, 'List', and clearly identifies the resource: files attached to a script, with concrete examples (request bodies, upload files, Playwright support files). This distinguishes it from siblings like list_scripts or get_script_asset.

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 use when you need to enumerate the files attached to a script and adds that each path is the key a command references. However, it does not explicitly state when to prefer this over get_script_asset or put_script_asset, nor does it mention any 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?

Annotations already establish read-only, idempotent, non-destructive behavior. The description adds useful behavioral context beyond that: results are newest-first and include version, save time, author, and step count. No contradiction with annotations.

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

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

One clean, front-loaded sentence that states the operation, scope, ordering, and returned fields without wasted words.

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

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

For a simple read-only listing tool with strong annotations, the description covers enough: result shape and ordering are stated, and count is documented in the schema. It would be more complete with minimal guidance on projectId/scriptId, but names and context make this mostly self-evident.

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 only 33% and the description does not compensate. scriptId and projectId have no descriptions and are not explained in the tool description; only count is documented 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?

Description uses specific verb 'List' with resource 'a script's past revisions', and adds ordering ('newest first') and result contents. This clearly distinguishes it from singular get_script_revision and restore_script_revision.

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: call it to view revision history for a script. However, it does not explicitly state when to prefer it over get_script_revision or restore_script_revision, nor any 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?

Annotations already cover safety (readOnly, idempotent, non-destructive, closed-world), and the description adds real context beyond them: the shape of what comes back and the explicit exclusion of the full command list, which tells the agent to fetch get_script for commands. The note that tags are team-shared adds operational context about a shared namespace.

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 resource and returned fields. The trailing tag-management sentence is slightly off-topic for a list operation but is short and does convey a real constraint rather than padding.

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

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

No output schema exists, so the description usefully enumerates the returned fields and states what is deliberately omitted (command list). For a simple one-parameter read tool with full annotation coverage, this is close to complete; only projectId semantics and behavior on an invalid project are left 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?

There is a single required parameter, projectId, with 0% schema description coverage, so the description must carry the meaning. 'In a project' only loosely ties projectId to a project identifier and gives no format, ID-source, or error behavior (e.g. unknown project). This is minimal but present.

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 (List) and resource (scripts in a project) and enumerates the fields returned (id, name, bot type, step count, revision version, tag names). It is clearly distinguishable from siblings like list_scenarios or list_script_assets by the script-specific field set, though it never names an alternative tool 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 'when' is only implied: an agent needs a roster of scripts in a project. The explicit guidance present is about tagging ('reuse a name the list tools already report, create a new tag only when the user asks'), which is downstream advice rather than guidance on choosing this tool over get_script or list_script_revisions.

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

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

The description discloses the most important runtime behavior beyond annotations: the call returns immediately with a run id and queued status, and execution may take from seconds to minutes depending on the target. It also tells the agent where to read results. This goes well beyond the readOnly, idempotent, and destructive hints, with no contradiction.

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 that front-loads the action and proceeds through immediate return, duration context, and follow-up route. 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 an asynchronous tool with no output schema, the description provides the essential contract: what is returned now (run id, queued status), why the wait may be long, and how to get results. It covers the invocation context and follow-up, making it complete enough for an 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?

The schema already describes scriptId and skipWaitTimes; the description does not elaborate on projectId or add parameter-level constraints beyond the schema. Since coverage is 67% and the remaining parameter name is self-explanatory, the description adds little parameter semantics.

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 starts with the specific verb 'Start playing a saved script,' making the action and resource explicit. It also distinguishes itself from siblings by noting the return behavior and pointing to get_play_status, so an agent can tell it apart from create, validate, delete, and list 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 description clearly establishes the context: use this to initiate execution of a script that already exists, then poll for results. It explicitly routes to get_play_status for reading results, but it does not list exclusions or when-not conditions versus other script operations.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the agent knows this is a mutating operation. The description adds the 'upload or replace' behavior, which implies overwriting existing assets at the same path. It doesn't disclose whether replacement is destructive to existing content or if there are any side effects, but the annotations cover the safety profile. The description adds some context about how the asset is used (as a command key) but not deep behavioral 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?

The description is a single, focused sentence that front-loads the core action ('Upload or replace a script asset from base64 content') and then provides a useful example. It's concise and every sentence earns its place, though the example could be seen as slightly verbose.

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 destructiveHint=true, the description explains the primary use case and the path-key relationship. However, it doesn't mention what happens on replacement (e.g., overwriting existing content), any prerequisites (e.g., project/script must exist), or the response format. With no output schema, the agent might not know what to expect. The description is adequate but has 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 50%, with path and contentBase64 having descriptions. The description adds meaning by explaining the path's role as a key for commands, which goes beyond the schema's 'The asset path / key to store it under.' However, scriptId and projectId have no descriptions in the schema, and the description doesn't compensate for those. The description adds some value but doesn't fully cover the undocumented parameters.

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

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

The description clearly states the tool's function: 'Upload or replace a script asset from base64 content.' It specifies the resource (script asset) and the action (upload/replace), and distinguishes it from siblings like get_script_asset and delete_script_asset by focusing on the write operation. The example of using the path as a key for commands adds concrete context.

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

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

The description provides clear context on when to use this tool: when uploading or replacing a script asset, and explains how the path is used as a key for commands. It doesn't explicitly state when not to use it or name alternatives, but the sibling list includes get_script_asset and delete_script_asset, and the description's focus on upload/replace makes the usage context 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?

Annotations already declare readOnlyHint=false, destructiveHint=false and idempotentHint=false, so the safety profile is partly covered. The description adds meaningful context beyond them: the restore is additive, preserving the old revision as a new revision, which reassures the agent that history is not destroyed. It stops short of documenting permissions, effects on the current working copy, or repeat-call 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?

A single front-loaded sentence that conveys the action and its side effect with zero filler. Nothing could be removed without losing information.

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

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

For a 3-required-parameter mutation with no output schema, the description covers the mutation's semantics but leaves key gaps: which revision identifier the new revision receives, whether the script must be unpublished/not playing, and what to do with undocumented identifiers. Adequate as a minimum-viable definition, 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 coverage is only 33% — scriptId and projectId have no descriptions at all, and the description does not explain them or clarify the version identifier (revision number vs. internal id). The only parameter insight, that version is the revision to restore, is already in the schema, so the description barely compensates for the coverage gap.

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

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

The description states a specific verb (restore) plus a resource (a script to a past revision) and even explains the mechanism: the revision's commands become a new revision. This clearly separates it from read-only siblings like get_script_revision and list_script_revisions, 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?

Usage is implied — an agent can infer this is the rollback tool — but there is no explicit when-to-use guidance, no note that you should first call list_script_revisions/get_script_revision to obtain a valid version, and no comparison against alternatives like update_script or duplicate_script.

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

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

Annotations only declare readOnly=false, idempotent=true, destructive=false; the description adds the substantive semantics: graceful stop lets bots finish their current iteration and reports them in full, immediate kills mid-iteration, running tests move to STOPPING then end, unstarted tests are canceled, and already-ended tests are refused. That is a full state machine beyond what annotations convey.

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

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

Front-loaded with the purpose and the graceful/immediate split, then guidance, then lifecycle. Every sentence carries information, though the state-transition sentence plus the follow-up-tool sentence makes it denser than strictly necessary for a three-parameter 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?

No output schema exists, and the description compensates by telling the agent what the result carries (the post-stop stage) and which sibling to call next (get_load_test_status, then get_load_test_report). Combined with refusal and state-transition cases, nothing needed to invoke this correctly is missing.

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

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

Schema coverage is 67% and the schema already documents 'immediate' and loadTestId. The description still adds real meaning to 'immediate' by explaining the mid-iteration cutoff and shortened final iterations, but projectId is not addressed in either schema or description, so not everything is covered.

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?

Opens with a specific verb+resource: 'Stop a Load Test,' and immediately contrasts it with launch_load_test / get_load_test_status by describing the stop lifecycle. An agent can tell exactly what this tool does 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 states the default behavior and the decision rule: 'Stop gracefully unless the user asks to kill the test or the target needs relief now.' It also covers the edge case of killing an already-STOPPING test, giving both when-to and when-not guidance.

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

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

Annotations already indicate this is a mutating, non-destructive, idempotent operation. The description adds useful behavior: errors if the run does not exist, and the stop is not necessarily instantaneous ('once the stop takes effect'), plus the post-condition observable through get_play_status. No contradiction with annotations.

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

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

Two sentences, front-loaded with the core action, then concise behavioral details. Every sentence earns its place without redundancy or unnecessary 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 low-complexity two-parameter tool with no output schema, the description covers the core action, error behavior, and post-condition, and even points to a verification tool. The main gap is the undocumented projectId semantics, but overall the agent can select and invoke this tool correctly.

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

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

Schema description coverage is only 50%: scriptRunId is documented, but projectId has no description and the tool description does not explain it. The description adds no meaning for the required projectId parameter, leaving an important invocation detail to inference.

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: 'Stop a running play.' It also clarifies the error condition and expected observable outcome, referencing get_play_status, which distinguishes it from related run-management tools like play_script and get_play_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 description makes the usage context clear: use this tool to stop a running play, and verify the outcome via get_play_status. It implicitly contrasts with play_script by using 'stop,' though it does not explicitly name alternatives or state when not to use 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?

While annotations are sparse (readOnlyHint=false, etc.), the description discloses critical behavior: that feedback is optional, has a 2000-character limit, that longer submissions are rejected rather than truncated, and that it must not carry sensitive data. It clearly indicates that this is a non-essential side effect, which is valuable beyond the annotations.

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

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

The description is concise, front-loaded with the 'Optional' tag and purpose, and every sentence earns its place. It covers what the tool does, when to use it, content constraints, and length behavior without fluff.

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

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

Given that the tool is a simple side-action with no output schema, the description is nearly complete. It covers the purpose, optional usage, content restrictions, and rejection on length. However, it does not mention what happens on successful submission (e.g., response or confirmation), but given the low complexity and lack of output schema, this is a minor 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?

The schema description coverage is 100%, meaning the schema already documents each parameter (outcome, feedback, taskDescription). The description adds context about the feedback content and length limit, but does not significantly add detail beyond what the schema provides. Baseline 3 is appropriate because the schema does the heavy lifting, and the description complements with usage context.

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

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

The description clearly states this tool sends feedback about the tool surface to the Loadster team)Skip. It explicitly notes that nothing requires it and no task depends on it, which disambiguates its purpose from other action tools. The verb is specific ('sends a note') and the resource is clear ('about this tool 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?

The description says 'Optional' and explicitly states when it is not needed ('Nothing requires it and no task depends on it'). It clarifies feedback content boundaries: what it should and should not contain (excluding conversation data) and warns about the length limit being rejected. This guidance is direct and excludes misuse.

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