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

With no annotations provided, the description must carry full behavioral transparency. It only indicates an 'add' operation without disclosing side effects (e.g., modifying the plan), requirements, reversibility, or safety considerations. The relationship to get_execution_report is mentioned, but no side effects are revealed.

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 no wasted words. The core action and the key dependency are stated directly and in a logical order.

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 provides the essential role (feeds get_execution_report) and parent context, but lacks detail on required parameters (planId, parentId remain ambiguous) and does not disclose mutation side effects. For a tool with 4 parameters and no annotations, it is not 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 description coverage is only 25%, so the description must compensate. It clarifies parentId (Thread Group or TestPlan) and the tool's purpose, but does not explain planId or name beyond the schema's default, nor does it add much to filename. Compensation is partial.

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 (add) and a resource (Aggregate Report listener), and specifies the parent types (Thread Group or TestPlan). It also links the listener's output to get_execution_report, which distinguishes it from other listener tools like add_summary_report_listener.

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 when to use this tool (to produce output for get_execution_report), but it does not explicitly name alternatives or provide when-not-to-use guidance. The context is helpful but not as explicit as it could be.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only states that it adds a header manager, but does not mention any side effects (e.g., modifying the test plan), required permissions, idempotency, or what happens if the parent doesn't exist. For a mutation tool, this is a significant gap.

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

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

The description is a single, concise sentence with no filler. It is front-loaded with the action and placement, making it easy to scan. However, the brevity contributes to the lack of parameter and behavior detail.

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

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

Given four parameters with zero schema descriptions, no output schema, and no annotations, the description should provide substantial guidance. It only covers the core purpose and placement, leaving out parameter semantics, required IDs, header structure, and any behavioral caveats. The tool is underspecified for reliable agent 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 description coverage is 0%, and the description does not explain any of the four parameters (planId, parentId, headers, name). It fails to compensate for the schema's lack of documentation, leaving agents to guess the meaning and structure of the headers array and required IDs.

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 (add an HTTP Header Manager) and specifies the target (under an HTTP sampler or Thread Group), which distinguishes it from sibling tools that add other elements. The placement detail adds precision beyond a generic 'add' 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?

The description provides placement guidance (under sampler vs. Thread Group) which implicitly tells when to use it for scoping headers to all samplers. It does not explicitly mention alternatives or when not to use it, but there are no similar sibling tools that add headers, so this is adequate.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It only says 'Add', implying mutation, but doesn't mention side effects, requirements (like parent existence), or error behavior. This is a significant gap for a mutating operation.

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

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

The description is a single concise sentence that immediately conveys the primary action and target. There is no filler or redundancy; every word earns its place.

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

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

For a tool with 9 parameters, 6 required, and no output schema or annotations, the description is grossly incomplete. It doesn't explain how to specify the HTTP request (method, domain, path, etc.) or what the parent node requirements are, leaving the agent without enough context to invoke it correctly.

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

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

Schema description coverage is only 33%, and the description adds nothing about any of the 9 parameters. It fails to compensate for the undocumented parameters (name, method, planId, parentId, protocol, etc.), leaving the agent to guess their meaning and usage.

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

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

The description states a clear verb and resource: 'Add an HTTP Request sampler' and specifies the location 'under the given parent node'. It clearly distinguishes from siblings like add_thread_group or add_json_extractor by naming the sampler type, though it doesn't explicitly contrast them.

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

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

It provides minimal context by noting the parent is 'usually a Thread Group', but gives no guidance on when to use this tool versus alternatives like add_header_manager or add_response_assertion. No exclusions or conditions are mentioned, leaving the agent to infer when it applies.

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

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

With no annotations provided, the description must fully disclose behavioral traits. It only says 'Add', implying a mutation, but does not explain side effects like whether existing extractors are replaced, what happens if the parent sampler does not exist, or whether the operation is reversible. This is a significant gap for a mutation tool.

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

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

The description is a single, tightly worded sentence that front-loads the action and purpose. Every word earns its place, with no redundant information or filler.

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

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

For a tool with no annotations and no output schema, the description is adequate but not complete. It explains the main use case, but does not mention potential behavioral details (e.g., failure handling, idempotency) or prerequisites beyond the parent sampler. The missing parameter descriptions for name and planId are not addressed. A more comprehensive description would help for a mutation 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 description coverage is 67% (4 of 6 parameters have descriptions). The description adds no additional parameter-specific details beyond what the schema already provides; it merely restates the purpose which maps to jsonPathExpr and referenceName. Since the schema covers most parameters, the baseline of 3 is appropriate, and the description does not compensate for the undocumented name and planId 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 states a specific verb ('Add'), a clear resource ('JSON Extractor post-processor'), a location context ('under an HTTP sampler'), and the purpose ('save a value from the JSON response into a variable'). This clearly distinguishes it from sibling add_* tools like add_http_sampler or add_response_assertion.

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 indicates when to use this tool: when you need to add a JSON extraction post-processor. It provides context about the parent sampler. However, it does not explicitly state when not to use it or mention alternatives (e.g., if you need a different extractor type), but given the sibling list, the purpose is distinct enough.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states that the tool fails the sample when the response doesn't match, which is the primary side effect. However, it does not mention constraints (e.g., parent must be an HTTP sampler), error conditions, or any side effects on existing assertions. The core behavior is clear but details are missing.

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 that states the action and purpose without unnecessary words. It is concise and efficient, scoring well for conciseness, though it could be expanded slightly with parameter guidance without becoming 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 tool with 7 parameters, no output schema, and low schema description coverage, the description is inadequate. It doesn't explain the required parameters (planId, parentId, patterns) or optional ones (matchType, testField, name, not), nor does it describe the return behavior. An agent would need to infer too much from the schema alone, making the description incomplete.

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

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

Schema description coverage is only 14% (only 'not' has a description), so the description must compensate. It does not explain planId, parentId, patterns, matchType, testField, or name. The phrase 'if the response doesn't match' implies patterns are used for matching but offers no parameter semantics. The agent is left to guess from property names and enums, which is insufficient.

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: adding a Response Assertion under an HTTP sampler, with the purpose of failing the sample on mismatch. This is specific and distinguishes it from sibling add_* tools (e.g., add_http_sampler, add_json_extractor) by naming the resource and behavior. However, it doesn't explicitly contrast with alternatives, so a 4 is appropriate.

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

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

The description provides no guidance on when to use this tool versus others, nor any conditions where it should not be used. It only states what the tool does without context on selection. No exclusions or alternatives are mentioned, leaving the agent to infer appropriateness from the name alone.

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

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

With no annotations provided, the description carries the full burden for behavioral disclosure. It does mention that the listener's output is what get_execution_report reads, which is useful context, but it does not disclose any side effects, permissions, or reversibility of adding the listener. As a mutation tool, this is a notable gap.

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

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

The description is two short sentences with no filler. The primary action is front-loaded, and the follow-up sentence adds valuable context about the tool's relationship to get_execution_report. Every word earns its place.

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

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

For a tool with 4 parameters and no annotations or output schema, the description is too thin. It clarifies the parent types but omits details on planId and the return value. The link to get_execution_report is helpful, but the description does not adequately equip an agent to invoke the tool correctly with all parameters understood.

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

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

Schema description coverage is only 25%, so the description must compensate for the undocumented parameters. It provides some context for parentId by naming allowed parent types, but planId and name are not explained. The description does not clarify the meaning or format of the parameters beyond what is already in the schema, which is minimal.

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: adds a Summary Report listener under a parent (Thread Group or TestPlan). It also connects it to get_execution_report, which helps place its role. It does not explicitly contrast with the sibling add_aggregate_report_listener, so a 4 rather than 5 is appropriate.

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?

Some usage guidance is implied by mentioning the valid parents (Thread Group or TestPlan), but the description does not state when to choose this listener over the aggregate report alternative, nor any prerequisites or exclusions. Sibling tools exist but no comparison is made, so guidance is only implicit.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only states that a thread group is added and implies mutation, but does not mention side effects, permissions, reversibility, or what happens on success/failure. The brief note about the parent node being usually the TestPlan root is the only extra context.

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

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

The description is a single sentence with no wasted words. It is front-loaded with the action and resource, and the parenthetical clarification adds useful context without bloat.

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

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

For a tool with 7 parameters and no output schema, the description is sparse. It does not mention key parameters like planId, nor the relationship between loops and durationSeconds (though the schema mentions it). It also lacks any indication of what the tool returns or how the agent should interpret the result. The description is insufficient for full correct usage.

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 5 of 7 parameters, providing explanations for parentId, numThreads, rampTimeSeconds, loops, and durationSeconds. The description adds minimal value by mentioning 'given parent node' which relates to parentId, but does not clarify name or planId. Given the high schema coverage, a baseline 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 clearly states the action (Add) and the resource (Thread Group), and clarifies 'virtual users'. It also indicates the placement under a parent node. However, it does not explicitly differentiate from sibling add_* tools, though the resource type is distinct enough that an agent might infer the difference.

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

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

The description gives no guidance on when to use this tool versus alternatives. It only mentions the typical parent node, but does not specify when to prefer this over other nodes or tools. There are no exclusions or alternative tool references.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It discloses the return values (planId and root node id) and hints at their usage, but does not mention side effects, persistence, or any prerequisites. It is adequate but not rich enough for full transparency.

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

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

The description is two sentences with zero redundancy. It front-loads the core action, then concisely provides the critical return information and usage hint. Every word earns its place.

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

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

For a simple create operation with a single parameter and no output schema, the description explains the return values and their practical use. It is complete for the immediate purpose, though it could mention potential side effects or idempotency, but that does not detract significantly.

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 describes the only parameter 'name' with an adequate human-readable description (100% coverage). The tool description adds no extra detail about the parameter, so it stays at the baseline of 3.

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

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

The description clearly states 'Create a new JMeter test plan' with a specific verb and resource. It further differentiates from siblings by noting that it returns planId and the root TestPlan node id, which is unique to this tool among the listed 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?

The description provides clear context on how to use the return value ('which you'll use as parentId for the first thread group'), implying it is the first step in building a plan. It does not explicitly contrast with alternatives like add_thread_group, but the usage context is evident and sufficient for a create-first 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?

Since no annotations are provided, the description carries full responsibility. It discloses the asynchronous execution model, the immediate return of an executionId, and the necessity to poll status and retrieve results. This is critical behavioral information that an agent needs to know to avoid blocking or assuming synchronous completion.

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

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

The description is two sentences, front-loaded with the core action. The second sentence packs the async behavior and follow-up steps without waste. Every sentence adds value; there is no redundancy or fluff.

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

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

For a single-parameter asynchronous tool with no output schema, the description covers the essential operational model: what it starts, how it returns, and the required polling/report steps. It leaves no critical ambiguity for an agent to execute correctly. The mention of non-GUI mode adds practical context without going overboard.

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 only one parameter, planId, with 0% schema description coverage. The description does not directly explain the parameter, but its name and the tool's reference to 'test plan' make it self-explanatory as the ID of the plan to run. While the description does not add extra meaning, the parameter's purpose is evident from context. Given the low coverage, a 3 is appropriate – it does not harm, but could be more explicit about where to get planId (e.g., from list_test_plans).

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 ('Start running a test plan'), the resource ('a test plan'), the mode (non-GUI), and the immediate return with an executionId. It distinguishes itself from siblings by focusing on the initiation of execution, while get_execution_status and get_execution_report are for monitoring/results, and create_test_plan is for creation.

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 instructs the agent on the follow-up workflow: 'Poll get_execution_status to know when it's done, then call get_execution_report to read the results.' This tells when to use this tool (to start) and what to use next. It also states the async nature ('returns immediately... continues in the background'), providing clear context for correct usage.

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

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

With no annotations, the description carries the full burden. It discloses that the operation is read-only ('Read'), the data source (listener output), and that it can be called on running executions. It does not mention potential side effects, latency, or error handling for invalid IDs, but for a read operation this is acceptable. It adds context about the metrics but not deeper behavioral details like caching or consistency.

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, information-dense sentence that front-loads the core purpose and immediately lists the output metrics. Every word contributes value; there is no fluff or repetition. It is concise without losing specificity.

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

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

For a tool with one parameter and no output schema, the description covers the essential elements: what it does, when it can be used (finished or running), and exactly which metrics it returns. The lack of an output schema is mitigated by the metrics list. It does not mention error conditions or return formatting, but that is a minor gap given the simplicity of the tool.

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

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

The schema has a single parameter, executionId, with 0% description coverage. The tool description does not explicitly explain what the parameter means beyond its name—it only says the tool retrieves results for 'an execution', but does not reiterate that executionId must be the ID of the execution whose report is desired. Since schema coverage is zero and the description fails to compensate, the parameter semantics are 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 ('Read and aggregate') with a clear resource ('results of a finished (or still-running) execution') and enumerates the exact metrics returned (per-label and overall count, error rate, latency percentiles, throughput, KB/sec). It distinguishes itself from siblings like get_execution_status by focusing on detailed report data from listener output.

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 states the tool works on finished or still-running executions and specifies the source (Aggregate Report / Summary Report listener output), giving context for when it applies. However, it does not explicitly contrast it with siblings like get_execution_status, nor does it state when NOT to use it (e.g., for just checking status). Usage is implied but not fully explicit.

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

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

With no annotations, the description carries the full burden. It discloses that it returns status plus log tail, which is the core behavior, and implies read-only nature. However, it does not mention potential side effects (none expected), polling behavior, or log length limits, so it is adequate but not rich.

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

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

A single, well-structured sentence that front-loads the purpose and includes essential details (statuses, log tail). 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 simple status-check tool with one parameter and no output schema, the description covers what it does and what it returns. It does not explain how to interpret the status (e.g., polling until completed), but that could be considered usage guidance rather than essential 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?

The schema has 0% description coverage, and the description does not explain the executionId parameter beyond its obvious relation to the run. It does not specify that executionId is the ID returned by execute_test_plan, which would have compensated for the coverage gap. The meaning is inferred but not stated.

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 checks the status of a test run, specifies it is for runs started with execute_test_plan, and enumerates the possible statuses (running/completed/failed) plus the log tail. This distinguishes it from siblings like get_execution_report (which likely provides full report) and stop_execution (which stops the run).

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 ties usage to runs from execute_test_plan, which gives clear context on when to invoke it. However, it does not mention when not to use it or point to alternatives like get_execution_report for full results, so it lacks 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?

With no annotations, the description carries the full burden. It clearly indicates this is a retrieval operation ('get') and specifies what it returns, which is enough to infer it is read-only and non-destructive. It does not mention potential side effects or response size, but for a getter with a single parameter, this is adequate.

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, clearly structured sentence that front-loads the primary action ('Get the full element tree') and then adds contextual detail (ids and their use). Every word serves a purpose with no fluff.

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

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

For a simple read tool with one parameter and no output schema, the description fully explains what is returned (the full element tree, including ids and types) and why it matters (for parentId). It gives an agent enough to decide when and how to call it correctly.

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

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

The schema has one parameter (planId) with 0% description coverage. The description does not explicitly explain what planId is, though it is easily inferred as the identifier of the test plan from the context. It adds no direct parameter detail, but the single, self-explanatory parameter name mitigates the weak 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 action ('Get the full element tree') and a specific resource ('a test plan'), and clarifies it returns every node's id and type. This distinguishes it from siblings like list_test_plans (which lists plans) and get_execution_report (which reports execution results), making its 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?

It explicitly mentions that node ids are needed as parentId for add_* tools, giving a clear reason to use this tool before making structural modifications. It does not explicitly say when not to use it, but the context of adding nodes is clear, and the sibling tools for execution vs. structure are implicitly separated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that it lists test plans, without indicating whether the operation is read-only, if there are side effects, rate limits, or pagination behavior. For a potentially safe listing operation, the lack of any safety or side-effect context is a gap.

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

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

The description is a single efficient sentence that clearly states the action and scope. It is front-loaded with the verb and resource, avoiding any extraneous text.

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

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

Given the low complexity (no parameters) and lack of an output schema, the description provides adequate context for most use cases. However, it does not detail the return format (e.g., list of test plan IDs, full objects, or metadata), which could be relevant for agents expecting a specific structure. Since no output schema exists, a brief note on return content would improve completeness.

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

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

The tool has zero parameters, so the baseline is 4. No parameter documentation is needed, and the description adds nothing beyond the schema, which is appropriate since there is nothing to clarify.

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 clear verb ('List') and a specific resource ('all test plans in the workspace'). It naturally distinguishes itself from sibling tools like get_test_plan (which targets a single plan) and create_test_plan (which creates), so an agent can identify its purpose 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?

The description implies usage for enumerating all test plans, but it does not explicitly state when to use it versus alternatives like get_test_plan for a specific plan. No exclusions or conditions are mentioned, so the guidance remains implicit rather than explicit.

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

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

With no annotations, the description carries the full burden of disclosing behavior. It does reveal the internal action (SIGTERM), but omits consequences such as whether the stop is graceful, what happens if the execution is already stopped, or whether any cleanup occurs. It also does not mention potential side effects or error states. The provided detail is useful but incomplete.

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

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

The description is a single, tight sentence with no filler. It front-loads the primary action and includes the key behavioral detail (SIGTERM) without redundancy. Every word contributes meaning.

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

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

The tool is simple with one parameter and no output schema. The description covers the core action and mechanism, but given the absence of annotations and output schema, it could state what the caller should expect (e.g., a success status or error if execution not found). It also omits edge cases like calling on an already stopped execution. These gaps are moderate for a low-complexity tool.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'running test execution' which loosely implies the executionId identifies that execution, but it does not explicitly explain the parameter. For a single unambiguous identifier, this minimal inference is acceptable, but the description adds no explicit clarification beyond the schema's bare type.

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 ('Stop a running test execution') and the specific mechanism ('sends SIGTERM to the JMeter process'). It distinguishes itself from siblings like execute_test_plan (which starts) and get_execution_status (which reports status) by focusing on termination. The verb and resource are specific and unambiguous.

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

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

The description implies it should be used on a running execution but does not explicitly state when to use it versus alternatives. It lacks exclusions, such as 'only use if execution is in a running state' or 'for status checks, use get_execution_status instead'. No guidance is provided on prerequisite conditions or alternatives.

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