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

Annotations already indicate this is destructive and non-idempotent. The description adds the useful nuance that this is a cancellation 'request' rather than a guaranteed immediate cancel, and that it applies only to 'running' downloads. It does not elaborate on side effects or state changes, but the annotations cover the core safety profile.

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. It conveys the action, resource, and state condition efficiently.

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

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

Given the simple one-parameter shape and existing output schema, the description is mostly adequate, but it leaves the source of operation_id implicit and gives no guidance on cancellation semantics beyond 'request.' This is sufficient for a minimal viable definition but 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?

The only parameter, operation_id, has 0% schema description coverage and the description does not explain where the ID comes from or how it is obtained. An agent must infer from sibling tools that the operation_id refers to a previously started artifact download, which is not explicitly 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 states a specific verb ('Request cancellation') and a clear resource ('running artifact download'). It also distinguishes itself from sibling tools like cancel_workspace_bundle_download and get_artifact_download_status by naming the exact operation it targets.

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 word 'running' gives implied usage context: this tool is for canceling an artifact download that is currently in progress. However, it does not explicitly mention when not to use it, nor does it name alternatives such as cancel_workspace_bundle_download for workspace bundle downloads.

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 signal destructive, non-read-only, and non-idempotent behavior. The description adds the non-obvious operational requirement that JENKINS_MCP_ENABLE_WRITES=1 must be set for the write to be allowed, which is useful context beyond the annotations. There is no contradiction; the description aligns with the 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 two short sentences with no filler. The core action is front-loaded in the first sentence, and the critical prerequisite is in the second. 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 single-parameter tool with an output schema and annotations covering destructiveness, the description is largely complete. It includes the important write-enable requirement. A minor gap is that it does not point to sibling tools like jenkins_list_queue or jenkins_get_queue_item for discovering item IDs, but the low complexity keeps this from being 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 schema has 0% description coverage for item_id, and the description does not explain what item_id represents beyond the general phrase 'queue item.' An agent can infer it is the queue item identifier, but the description provides no guidance on where to obtain it or whether it is the numeric queue ID returned by jenkins_list_queue or jenkins_get_queue_item. This is insufficient to compensate for the lack of schema descriptions.

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

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

The description states a specific verb ('Cancel') and a specific resource ('Jenkins queue item'), making the action and target unambiguous. It is clearly distinct from read-oriented siblings like jenkins_get_queue_item and mutation tools for builds or jobs, though it does not explicitly name alternatives or differentiate itself beyond the verb and resource.

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

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

The description implies usage by stating the action, but it does not explicitly explain when to choose this tool over alternatives. The only guideline provided is the prerequisite JENKINS_MCP_ENABLE_WRITES=1, which is an operational condition rather than context about selecting this tool versus 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 indicate destructiveHint=true, so the cancellation is appropriately flagged as destructive. The description adds the useful context that the operation must be 'running', but it does not clarify whether cancellation is asynchronous, whether it can be undone, or what happens to the in-progress operation beyond that hint.

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 or repetition. It states the action and target clearly while staying very short, earning 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?

Given the tool's low complexity—one required parameter and an output schema—the description is minimally adequate for selecting and invoking it. However, it omits usage guidance and does not clarify how operation_id connects to the broader workspace bundle lifecycle, leaving some burden on the agent to infer context from sibling tools.

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

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

Schema description coverage is 0%, and the description does not compensate by explaining operation_id beyond naming the operation it refers to. The parameter name is self-descriptive and the tool context helps, but there is no detail on where the ID comes from or how to obtain it, so the description adds minimal value for parameter 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 clearly states the action ('request cancellation') and the resource ('a running workspace bundle operation'), matching the tool name. It does not explicitly call out the sibling distinction from cancel_artifact_download, but the 'workspace bundle' phrasing provides enough specificity to separate it from artifact-download cancellation.

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

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

No guidance is given about when to use this tool versus alternatives like cancel_artifact_download, get_workspace_bundle_status, or cleanup_workspace_bundle_operations. The phrase 'running workspace bundle operation' implies a precondition, but there is no explicit when-to-use or when-not-to-use guidance.

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

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

The description aligns with destructiveHint=true and adds valuable scoping: only bounded, terminal, local, and older-than-age items are deleted. It does not, however, clarify whether deletion is permanent or whether it removes local bundle artifacts vs. operation records, so the behavioral picture is only partially complete.

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 tightly written sentence with the action verb at the beginning, no filler, and every qualifier ('bounded', 'terminal', 'local', 'older than') contributing meaning. This is appropriately concise.

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 destructive tool with an output schema, the description is nearly sufficient, but it leaves the meaning of 'terminal local workspace operations' implicit. An agent without prior Jenkins bundle-domain knowledge would still have to infer what resource is actually being deleted and when a local operation counts as terminal.

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 carry parameter meaning. 'older than the requested age' clearly maps to older_than_days and 'bounded' hints at max_operations, but the description does not explain the bound's behavior or units. The schema's property titles and default values help close the 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 uses a specific verb ('Delete') plus a scoped resource ('bounded, terminal local workspace operations') and a condition ('older than the requested age'). This makes the tool distinguishable from the sibling workspace bundle download/cancel/status tools. It would be a 5 if it unpacked the domain jargon ('terminal', 'workspace operations') slightly more.

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 'terminal' and 'older than the requested age' imply eligibility conditions, so an agent can infer when deletion is appropriate. However, the description never explicitly says to use this instead of cancel_workspace_bundle_download or get_workspace_bundle_status, nor does it state what to check before running a destructive cleanup.

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 the tool is not read-only, not idempotent, and not destructive. The description adds context about required permissions, which is useful. However, it does not disclose what happens if the destination job name already exists, whether build history is copied, or other side effects, providing only modest additional clarity.

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 core action is front-loaded, and the permission note is useful without being wordy. Well-structured 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 simple two-parameter operation, the description states the action and permission requirements, and an output schema is present. However, it omits key edge-case information such as behavior on name conflicts and the exact meaning of 'job-config flags', leaving an agent to guess at failure modes for a mutating 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?

Input schema coverage is 0%, and the description provides no explanation of from_job or new_name. The parameter names are self-explanatory, but the description does not compensate for the missing schema documentation with any additional semantics like path formats, naming rules, or how to reference the source job.

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 copies a top-level job, specifying the verb and resource. The qualifier 'top-level' narrows the scope. However, it does not explicitly differentiate from sibling tools like jenkins_create_job or jenkins_update_job_config, making it clear but lacking explicit sibling distinction.

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

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

The only usage guidance is a permission requirement ('Requires write and job-config flags'), which is a precondition rather than a directive on when to use this tool versus alternatives. There is no mention of use cases or when to prefer copy over create/update. An agent must infer usage 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?

Annotations already communicate readOnly=false, idempotent=false, destructive=false, and openWorld=true. The description adds useful behavioral detail by stating that write and job-config permissions are required and that the tool only creates top-level jobs, not folder-scoped jobs. 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 short sentences with the primary action front-loaded. The permission requirement is the only extra information, and there is no redundancy with the schema 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 simple two-parameter creation tool with an output schema and annotations, the description is broadly sufficient. However, it omits likely failure conditions such as duplicate job names or invalid config XML, and it gives no guidance about when to prefer sibling tools for related operations.

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 loosely explains that config_xml contains the job's config.xml, and 'name' is self-explanatory, but it does not clarify format, uniqueness constraints, or expected XML structure. This is minimally adequate.

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 ('Create') and names the resource ('top-level job') plus the source artifact ('config.xml'). This clearly distinguishes it from sibling tools like jenkins_update_job_config, jenkins_copy_job, and jenkins_delete_job.

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 this tool is for creating a new top-level Jenkins job from XML, and adds a permission prerequisite. However, it does not explicitly state when not to use it or name alternatives such as updating an existing job or copying a job.

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 tool as destructive (destructiveHint=true), so the description adds the specific permission flags required, which is useful operational context. It does not disclose that deletion is permanent or that the job parameter can accept an array for batch deletion, but the core safety trait is covered by 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 two short sentences, front-loading the primary action and then adding a compact permission note. Every word earns its place with no redundant or filler 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?

For a single-parameter destructive operation, the description covers the action and required permissions, and the existing annotations plus output schema fill in safety and return-value details. It could mention batch deletion or irreversibility, but the tool is simple enough that the description is largely adequate.

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

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

The input schema provides no description for the 'job' parameter (0% coverage) and the description does not explain it either. The parameter name and the action give some clue that it is a job name, but the description fails to mention the accepted array form or any formatting requirements.

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 defines the action precisely as 'Delete a job' with a specific verb and resource, and this is clearly distinct from sibling tools like jenkins_create_job, jenkins_copy_job, and jenkins_disable_job. The permission note does not obscure the core purpose.

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

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

There is no explicit guidance about when to use this tool over alternatives or when not to use it. The intended use is implied by the verb 'Delete', and the permission requirement ('Requires write, job-config, and delete flags') provides a precondition but no routing to or from 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 the write and destructive nature, so the bar is lower. The description adds one useful operational context beyond annotations: the JENKINS_MCP_ENABLE_WRITES=1 requirement. It does not disclose downstream effects on queued/running builds or that the operation is reversible via enable_job. 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 short sentences, front-loaded with the verb, zero filler. Both sentences earn their place, though the size is minimal rather than richly 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?

Complexity is low (single required parameter) and an output schema exists, so return values need no explanation. The env var gate is covered and annotations carry the safety profile, but the missing consequences (effect on running builds, reversibility) leave the picture slightly 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 0%, so the description must compensate, but it adds nothing beyond the word "job" already present in the schema. It does not explain that the parameter accepts an array to disable multiple jobs, nor any naming format expectations.

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?

"Disable a job" uses a specific verb and resource, making the action unambiguous. It is clearly distinct from sibling actions like enable, delete, or update, though it does not explicitly name the 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?

The description states an environmental prerequisite (JENKINS_MCP_ENABLE_WRITES=1) but gives no guidance on when to choose disable over enable_job, delete_job, or update_job_config, nor any exclusion conditions. This is a gate, not usage direction.

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, potentially destructive operation, and the description does not contradict them. It adds useful context beyond the annotations by stating the JENKINS_MCP_ENABLE_WRITES=1 prerequisite, which is a meaningful environmental requirement. It does not elaborate on downstream effects like the job becoming schedulable, but the annotation burden is partially met.

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 extremely concise: one short sentence states the action, and a second states the prerequisite. There is no wasted text, and the most important operational requirement is included.

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 one-parameter write operation, the description plus annotations cover the basic safety and action requirements. However, the schema's array support is undocumented, and the description does not mention the practical consequence of enabling a job. It is adequate but leaves some 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 0%, so the description carries the burden of explaining the 'job' parameter. It only says 'a job,' which matches the singular string usage but does not explain that the schema also accepts an array of jobs, nor does it clarify whether the value is a name, path, or ID. This is a meaningful 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 uses a specific verb and resource: 'Enable a job.' It clearly states the tool's action and is not a tautology. However, it does not explicitly differentiate itself from sibling tools like jenkins_disable_job beyond the obvious opposite meaning.

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 one key usage condition: it requires JENKINS_MCP_ENABLE_WRITES=1, which helps an agent know when the tool is allowed. However, it gives no explicit guidance on when to prefer this tool over alternatives, nor does it mention that it is the counterpart to jenkins_disable_job.

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 says 'Get ... status', implying a read-only polling operation, while annotations set destructiveHint=true, readOnlyHint=false, and idempotentHint=false. This is an annotation contradiction: a tool described as retrieving status is marked as destructive with no explanation of 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?

One compact sentence with no filler; the key information (resource, data points returned) is front-loaded and immediately usable.

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 one-paragraph description omits the crucial relationship to starting an artifact download and fails to address the contradiction with the destructiveHint annotation. An output schema exists, but the description still lacks behavioral and usage context needed for safe 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 operation_id beyond the name/title. It can be inferred that operation_id identifies an artifact download operation, but the description adds no detail about where to obtain it or its expected format.

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 the specific verb 'Get' with a clear resource 'artifact download status' and enumerates what it returns (bytes, speed, paths, final status). This is distinct from sibling operations like start_artifact_download or cancel_artifact_download.

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

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

No explicit guidance on when to call this tool or when to prefer alternatives. The relationship to jenkins_start_artifact_download is implied at best; there is no mention of prerequisites, polling semantics, or when cancellation should be used 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, and the description is consistent with them (no contradiction). It adds mild value by disclosing that permalinks like lastBuild resolve to builds, but it doesn't describe error behavior or what happens with an invalid build reference; the output schema covers return shape.

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

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

A single sentence with no filler — verb, resource, and addressing modes are all front-loaded. 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 read-only getter with an output schema, the description covers the core invocation path (job plus build identification). However, with 0% schema description coverage and a large sibling family, it leaves the tree parameter's semantics and the job parameter's accepted shapes uncompensated, and gives no routing hints among the many build-related getters.

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 explains the build parameter's dual nature (integer number or permalink string), which maps to the anyOf in the schema, but it says nothing about the job parameter's string-or-array form or the tree filter 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 uses a specific verb (get) and a concrete resource (a Jenkins build), and clarifies the addressing mode (by number or permalink like lastBuild). This distinguishes it from siblings such as jenkins_get_build_log or jenkins_list_builds, though it doesn't explicitly name 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?

The description implies the usage scenario — fetch a specific build when you already have a number or permalink — but offers no explicit when/when-not guidance or named alternatives. It doesn't help an agent decide between this and the build-log, test-report, or artifacts tools beyond the resource name itself.

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

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

The annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds modest context by indicating the artifacts are read from the build JSON API response rather than downloaded directly. However, it does not clarify what 'exported' means or confirm that no artifact download is started.

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 with the core action front-loaded. It has no filler, but the phrasing 'exported on a build JSON API response' is slightly awkward and could be more direct.

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 simplicity, output schema presence, and read-only annotations, the description is adequate for basic identification. However, it lacks parameter guidance and explicit differentiation from artifact-download siblings, so an agent may not have enough context to invoke it correctly in ambiguous situations.

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 missing parameter documentation. It does not explain what 'job' and 'build' mean, how the array form of 'job' behaves, or why 'build' can be an integer or string. The parameter names are somewhat self-explanatory, but the description adds no semantic detail.

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

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

The description clearly identifies the action ('List artifacts') and the resource ('a build JSON API response'). It is distinct from download-related siblings like jenkins_start_artifact_download because it frames the tool as reading a list, though the phrase 'exported on' is somewhat awkward and could be clearer.

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

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

No guidance is provided about when to use this tool versus alternatives such as jenkins_get_build or jenkins_start_artifact_download. The description implies a listing use case, but it does not explicitly state when this tool is preferred or when another tool should be used 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?

With readOnlyHint=true already declared, the description adds meaningful behavior by disclosing that the output is truncated by JENKINS_MCP_MAX_LOG_BYTES. This goes beyond the annotations and sets an expectation about log size, though it does not explain the limit's value or behavior for smaller logs.

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 filler, and the key behavioral detail about truncation is included directly. It is concise while still conveying the core operation.

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

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

For a simple read-only log fetch with an output schema present, the description covers the core operation and truncation behavior. However, it omits parameter semantics and any routing to chunked log retrieval, so an agent facing large logs or unusual job/build representations would be under-informed.

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 the job or build parameters. The names are recognizable, but the schema allows job as an array and build as integer or string, so an agent receives no guidance about valid forms or their 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: retrieving consoleText for a Jenkins build. The truncation note also distinguishes it from related log tools such as jenkins_get_build_log_chunk and jenkins_search_build_log.

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 truncation note implies this tool returns a bounded log snapshot, and the sibling list hints at chunked/search alternatives. However, the description never explicitly states when to prefer this tool over jenkins_get_build_log_chunk or how to retrieve an untruncated log, so usage context remains 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?

Annotations already declare readOnlyHint=true, so no contradiction exists. The description adds valuable behavioral context: this is not a full-log fetch but a single progressive response, and it returns a safe cursor for the next call. This goes beyond what the annotation alone conveys.

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, front-loaded sentence with no filler. It communicates the core action and result efficiently.

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

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

The description works as a minimal definition but lacks guidance on how to begin a progressive log read, how the returned cursor maps to the `start` parameter, and when to stop. The presence of an output schema reduces the need to describe return values, but the pagination workflow could be clearer.

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 0% schema description coverage, the description must compensate for parameter meaning. It provides meaningful cursor semantics ('return Jenkins' next safe cursor') which hints at the `start` parameter, but it does not explicitly define `job`, `build`, or how the cursor connects to `start`.

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: read one progressive log response and return the next safe cursor. It clearly distinguishes this from the sibling tools `jenkins_get_build_log` and `jenkins_search_build_log` by emphasizing progressive chunked reads with cursor management.

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 'one progressive log response' implies this tool is for incremental/paginated log reading, but the description does not explicitly say when to use this tool instead of `jenkins_get_build_log` or `jenkins_search_build_log`, nor does it mention any exclusions or alternatives.

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 openWorldHint=true, so the read-only safety profile is covered without description effort. The description adds one useful behavioral detail — nested paths use slash-separated names or a list — but it discloses nothing about error behavior (e.g., job not found) or how the tree parameter shapes the response, leaving behavior beyond the path format unaddressed.

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 totaling 17 words with the core purpose front-loaded and a single clarifying clause about path syntax. Every sentence earns its place, and there is zero redundancy or filler.

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

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

For a simple two-parameter read tool with a provided output schema and safety annotations, the description is close to adequate. The output schema excuses omitting return-value details, but the tree parameter remains completely undocumented, and there is no explicit differentiation from sibling fetch tools. Error behavior is also unmentioned, leaving meaningful 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?

With 0% schema description coverage, the description carries the full burden of parameter documentation. It does explain the job parameter's non-obvious format (slash-separated nesting or an array), which adds real meaning beyond the schema's anyOf type. However, it says nothing about the tree parameter, leaving the optional filter entirely unexplained.

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

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

The description clearly states the verb and resource: 'Get one job by Jenkins job path.' The phrase 'one job' implicitly distinguishes it from the sibling jenkins_list_jobs. However, it does not explicitly contrast itself with related fetch tools like jenkins_get_job_config or jenkins_get_json, so sibling differentiation is implied 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 description gives no explicit when-to-use guidance or exclusions. The use case is only implied — retrieve a single known job by its path — which suggests when an agent should pick it over listing jobs, but it doesn't name alternatives or state when not to use it, such as when needing job configuration 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 description adds a meaningful permission-dependent behavioral note: secrets may be redacted without Configure permission. This goes beyond the readOnlyHint and openWorldHint annotations and helps the agent anticipate potentially incomplete data. No contradiction exists between the description and 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 compact sentence with the core action and resource first, followed by the permission caveat. Every part is informative, and there is no filler or redundant restatement.

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

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

For a one-parameter tool with an output schema and readOnly annotations, the description is complete enough. It covers the core behavior, the serialized config.xml resource, and the important redaction caveat, while the schema handles the parameter 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 0%, and the description offers no additional meaning for the 'job' parameter beyond what the schema's field name implies. The name 'job' is self-explanatory to a degree, but the description should clarify whether a job name or path is expected, especially since the schema allows either a string or an array.

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 the specific action ('Read') and the resource ('serialized job config.xml'), which clearly identifies this as the read-config operation. This distinguishes it from siblings like jenkins_update_job_config, jenkins_get_job, and jenkins_delete_job.

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 conveys the general use case: retrieving a job's config.xml. However, it does not explicitly state when to prefer this tool over jenkins_get_job or when not to use it, so the usage context remains implied rather than fully specified.

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

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

Annotations already mark the tool as read-only; the description adds useful behavioral context by stating it rejects external URLs and path traversal. No contradiction and no hidden write or destructive behavior is implied.

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

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

One sentence front-loads the verb and resource and then states the key constraint. There is no filler or redundant restatement 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?

The description is adequate for the simple 'path' parameter, and the output schema covers return values, but it lacks guidance on the 'query' parameter and on choosing this tool over specialized siblings. For a generic Jenkins JSON API accessor, this is a minimal but not fully complete definition.

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 only clarifies 'path' as a relative Jenkins API path. The optional 'query' parameter is left entirely undocumented by both schema and description, so an agent must guess at its formatting and purpose.

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'), resource ('relative Jenkins JSON API path'), and constraints ('rejects external URLs and traversal'). It is distinct from the specialized sibling tools that target specific Jenkins objects, though it does not explicitly name an alternative.

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

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

No guidance is given about when to use this generic API-path tool versus the many specialized siblings. The security restriction is a validity constraint, not a usage condition, and no fallback or alternative condition is mentioned.

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 openWorldHint=true, so the safety profile is clear. The description adds a minor detail about the special built-in node name, but does not disclose additional behavior such as error handling or case sensitivity.

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, and the core action is stated first. Every sentence adds value.

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

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

The tool is simple with one parameter and an output schema present. The description covers the essential invocation detail, though it omits behavior for nonexistent nodes; this is minor given the 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. It explains that the single 'node' parameter is a Jenkins computer/node name and gives the special value '(built-in)' for the built-in node, which is enough to invoke the tool correctly.

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 operation: retrieving one Jenkins computer/node by name. It also distinguishes this from the sibling jenkins_list_nodes by emphasizing 'one' and lookup by name rather than enumeration.

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 useful guidance for the built-in node parameter value, but does not explicitly state when to prefer this tool over jenkins_list_nodes or other siblings. The usage context is implied rather than explicit.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description's read-only 'Get' aligns with the annotations and adds no contradictory behavior, though it does not disclose additional contextual details like error 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?

One sentence with no filler, core information front-loaded, and every word contributes to the meaning. It is appropriately sized for the simplicity of the operation.

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

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

For a simple read-only fetch by ID, the description is mostly complete: the output schema covers return values and annotations cover the safety profile. It could add a brief pointer to jenkins_list_queue for discovering IDs, but this is an enhancement rather than a critical gap.

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

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

Schema description coverage is 0%, so the description had the burden of explaining item_id. It only restates 'by ID', adding little beyond the schema's property name and integer type. It does not explain where the queue item ID comes from or how it relates to jenkins_list_queue.

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 exact resource ('Jenkins queue item'), and specifies the scope ('by ID'). This clearly differentiates it from sibling tools like jenkins_list_queue, which lists multiple items, and jenkins_cancel_queue_item, which mutates.

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 'by ID' qualifier gives clear context: use this tool when you need one specific queue item and already have its ID. It does not explicitly mention alternatives or exclusions, but the intended usage is unambiguous.

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 openWorldHint=true, so the description does not need to re-establish safety. It adds useful context about the endpoint and plugin dependency, but does not disclose behavior when no test report is available or how failures are surfaced. This is acceptable but not richly transparent.

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. It names the endpoint, the precondition, and an example plugin, earning its place with minimal word count.

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 tool with an output schema and readOnly/openWorld annotations, the description covers the essential context: what endpoint is accessed and when it is applicable. It could add a note about what happens when no test-report plugin exists, but overall the tool is simple enough that the description is largely 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 should compensate for the undocumented job and build parameters. It does not explain that job can be a string or array representing a folder path, nor whether build accepts a number, build name, or both. The parameter names are self-evident at a basic level, but meaningful type semantics are missing.

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

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

The description states a specific verb and resource: 'Get /testReport/api/json'. It also identifies the key precondition that a test-report plugin such as JUnit must provide the report, which clearly distinguishes this tool from generic Jenkins JSON or build retrieval 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 a clear usage context: use it when a test-report plugin provides /testReport/api/json. It does not name sibling alternatives or explicitly state when not to use it, but the conditional wording gives enough guidance 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 declare readOnlyHint=true and openWorldHint=true, and the description's 'Get' does not contradict them. It adds that the tool targets a single named view, but no behavioral details such as exact-match behavior, response shape, or implications of the open-world hint are disclosed.

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

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

The description is a single front-loaded sentence with no filler. Every word contributes: the object, the cardinality, and the lookup key.

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 one-required-parameter read tool, this is nearly complete: the only required input is made clear, read safety is captured by annotations, and an output schema exists so return values do not need explaining. The main missing piece is guidance on the optional tree parameter or the relationship to list_views.

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 should compensate, and it only clarifies the 'view' parameter via 'by name'. The optional 'tree' parameter is not explained at all, leaving its purpose opaque.

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

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

The description names a specific verb ('Get'), resource ('Jenkins view'), and selection criterion ('by name'), and it is clearly distinct from sibling list_views, which enumerates all views. 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?

The wording implies the tool is for retrieving a single known view by name, but it never states when to prefer this over jenkins_list_views or names any alternative. It offers no explicit when-to-use or exclusion guidance, so usage context is only implied.

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

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

The description presents this as a read-only status retrieval ('Get ... progress ... and final status'), but the annotations declare destructiveHint=true, readOnlyHint=false, and idempotentHint=false. This is a direct contradiction between the described behavior and the annotation metadata, leaving the agent with conflicting safety expectations.

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, compact sentence that front-loads the action and resource, then lists the relevant status dimensions. Every phrase earns its place with 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?

For a simple one-parameter status tool, the description lists output fields well, but it leaves out essential operational context: where operation_id comes from, how this tool relates to start/cancel/cleanup bundle operations, and whether repeated polling is expected. The contradictory destructiveHint annotation further undermines 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 only parameter, operation_id, has no schema description and 0% schema coverage. The tool description never explains what this ID represents, how to obtain it, or that it likely comes from a prior start_workspace_bundle_download call. The description focuses on output fields rather than 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 uses a specific verb and resource ('Get ... workspace bundle status') and enumerates the exact status fields returned: download/extract/log progress, bytes, speed, paths, and final status. This clearly distinguishes it from sibling tools like start_workspace_bundle_download and cancel_workspace_bundle_download.

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 that this is the polling/status tool for a workspace bundle download operation, but it never explicitly states when to use it (e.g., after starting a bundle download) or why it should be chosen over sibling tools like jenkins_get_artifact_download_status. Usage is inferable 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 communicate readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds meaningful behavioral context: the listing is 'bounded' (matching max_depth/max_entries) and reflects the live workspace rather than a build-number-bound snapshot. 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 short sentences with no wasted words. The first sentence front-loads the primary action, and the second earns its place by clarifying the live, non-build-bound nature of the paths.

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 output schema and readOnlyHint reduce the burden, but with four parameters and zero schema coverage, the definition leaves meaningful gaps: workspace_path interpretation, multi-job support implied by the array variant, and exactly what bounds apply. An agent can make a plausible guess, but the description is not fully complete for correct invocation in edge cases.

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 says 'bounded' without explaining max_depth, max_entries, or workspace_path. The parameter names are somewhat self-explanatory, but workspace_path semantics in particular—relative vs absolute, default root behavior—are not clarified. The description provides minimal added meaning beyond the schema structure.

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 a specific resource ('bounded live workspace tree'), and the second sentence ('Paths are not bound to a build number') distinguishes it from build-bound artifact or workspace-bundle tools. An agent can tell what this tool does and roughly how it differs from related 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 phrase 'live workspace tree' and 'Paths are not bound to a build number' imply this is for current workspace contents rather than build artifacts or downloaded bundles. However, it never explicitly states when to prefer this tool over alternatives such as jenkins_get_build_artifacts or the workspace bundle download 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 provide readOnlyHint=true and openWorldHint=true, covering the safety profile. The description adds the useful detail that data comes from top-level Jenkins JSON and version headers, which is consistent with annotations. No contradiction; it just does not disclose any additional behavioral nuances like rate limits or failure modes.

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

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

The entire description is one front-loaded sentence with no wasted words. It states the action, the result, and the data source efficiently.

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

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

For a zero-parameter read-only health snapshot with an output schema available, the description provides all necessary context: what it does and where the data comes from. 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?

The tool has zero parameters and the input schema is empty, so there is nothing for the description to explain. Per the baseline for zero-parameter tools, this is fully adequate.

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 ('Return') and names a concrete resource ('small health snapshot') with explicit data sources ('top-level Jenkins JSON and version headers'). This clearly distinguishes it from siblings like jenkins_version and jenkins_get_json, so an agent knows exactly what this tool produces.

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

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

There is no guidance on when to use this tool versus alternatives such as jenkins_get_json or jenkins_version. The phrase 'small health snapshot' implies a lightweight check, but no explicit context or exclusions are given, leaving the agent to infer selection criteria.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the description needs to add context beyond those. It adds 'recent' to clarify scope but does not disclose details like build ordering, pagination limits, or how the tree parameter changes the response. This is adequate for a simple read-only list but not rich.

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

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

The description is a single sentence with no filler words. It states the action and target resource directly, making it highly scannable and efficient for an agent.

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

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

This is a simple read-only list operation with an output schema provided, so return values are already covered. The description plus annotations are nearly sufficient for successful invocation. The main gap is the lack of tree parameter guidance, but the default value and simple invocation path make the tool usable without 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 0%, so the description must compensate for undocumented parameters. It only clarifies the 'job' parameter by mentioning 'for a job.' The 'tree' parameter is left unexplained beyond its default string, which is not self-evident. The description does not sufficiently bridge the schema 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 clearly states a specific verb and resource: 'List recent builds for a job.' This unambiguously identifies the tool's function and differentiates it from siblings like jenkins_get_build or jenkins_get_build_log, which target individual builds or logs rather than listing recent builds.

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 intended use case is implied: when you need a listing of recent builds for a specific job. However, there is no explicit guidance about when to prefer this over sibling tools or any exclusions, such as when to use jenkins_get_build instead. The usage context is inferable but not directly stated.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered by structured data. The description adds the user-visibility scoping behavior, which tells the agent results are filtered by the authenticated user's Jenkins permissions. No contradiction exists, but the description contributes only modest behavioral context 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?

Eight words with no filler; the verb and object are front-loaded and every word earns its place. The sentence is appropriately sized for the information it deliberately conveys.

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 output schema and annotations carry the return-value and safety burden, and the tool is low-complexity with two optional parameters. However, the description omits how to control output shape via tree and recursion via depth, and provides no pointer to sibling tools. It is adequate for a simple read-only enumerator but has clear 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 0%, so the description bears the full burden of explaining the two parameters (tree and depth). It mentions neither. The schema's default value 'jobs[name,fullName,url,color,_class]' hints at the tree format and 'depth' is plausibly self-explanatory, but the description itself adds zero parameter meaning, failing to compensate 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 and resource: 'List jobs visible to the Jenkins user.' The phrase 'visible to the Jenkins user' adds meaningful scoping (ACL-filtered results). It is clear, but it does not explicitly differentiate itself from sibling tools such as jenkins_get_job or jenkins_list_views, which keeps it a 4 rather than a 5.

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

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

No guidance is given on when to use this tool versus alternatives. The description does not mention when not to use it, when a sibling like jenkins_get_job or jenkins_list_views would be more appropriate, or any prerequisites. The one-line purpose statement only implies usage through its literal meaning.

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 openWorldHint=true, so the description does not need to restate safety. It adds useful context that results are filtered by user visibility, but it does not disclose behaviors like default field selection or whether offline nodes are included. The output schema covers return shape, so the added value is modest.

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, tightly worded sentence with no unnecessary content. The action and resource are front-loaded, making the tool's purpose immediately clear.

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 one optional parameter and an output schema, the description provides enough for default invocation and clarifies the visibility filter. The main gap is the undocumented tree parameter, but its schema default makes the tool callable without needing to understand 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 0% and the description does not explain the 'tree' parameter or how it affects the response. The parameter's optional nature and default value are only visible in the schema, so the description contributes no additional meaning for the agent.

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 ('List') and resource ('Jenkins computers/nodes') with an explicit scope ('visible to the user'). This distinguishes it from jenkins_get_node and other list-style siblings by indicating a plural, filtered listing.

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 alternatives like jenkins_get_node or other list tools. The verb 'List' implies the use case, but no explicit when-to-use or when-not-to-use information is given.

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

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

The readOnlyHint and openWorldHint annotations already convey that this is a safe, non-mutating query. The description adds the source endpoint and the 'visible' qualifier, which hints at filtering, but it does not clarify behavior such as whether disabled or hidden plugins are included or how pagination works. Still, it does not contradict annotations and adds some 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, compact sentence that conveys the essential purpose without filler. It is front-loaded with the action and resource, making it easy for an agent to scan.

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 presence of an output schema and read-only annotations lightens the load, but the near-total lack of parameter guidance and usage context leaves the definition slightly under-specified. The agent can still invoke it correctly using the default, but the description alone would not fully support parameter customization.

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, tree, with 0% description coverage. The description does not mention or explain the tree parameter at all, leaving the agent to infer its meaning from the default value alone. This is a notable gap for a parameter that controls response field selection.

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

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

The description states a specific action (List) and resource (installed Jenkins plugins), and adds the scoping detail 'visible through pluginManager/api/json'. This is unambiguous and clearly distinct from all sibling tools, none of which list plugins.

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

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

No guidance is provided about when to use this tool versus alternatives. While no sibling directly overlaps, the description does not mention related tools such as jenkins_get_json or jenkins_list_jobs, nor any conditions that would make this the preferred 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=true and openWorldHint=true, covering the safety profile. The description adds the 'visible' qualifier, which is useful, but does not mention behavior such as pagination, ordering, or the meaning of the default tree 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?

The description is a single five-word sentence that front-loads the action and resource with no filler. Every word earns its place.

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

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

This is a simple read-only listing tool with an output schema, read-only annotations, and an optional parameter carrying a sensible default. The description is adequate for basic invocation, although the undocumented tree parameter 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?

There is one parameter, tree, with 0% schema description coverage, and the tool description does not explain it. The schema provides only a type and default value, which is insufficient for an agent to understand how the tree parameter controls the response 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?

The description states a specific verb ('List') and resource ('Jenkins queue items'), with 'visible' adding scope. It clearly distinguishes the listing operation from item-level tools like jenkins_get_queue_item and jenkins_cancel_queue_item, though it does not name them explicitly.

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

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

The verb 'List' implies this tool is for enumerating queue items rather than inspecting a single item, so usage context is inferable. However, there is no explicit guidance about when to prefer this over jenkins_get_queue_item or how 'visible' should be interpreted.

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 and openWorldHint, setting a lower bar. The description adds only the visibility scoping ('visible to the user'), which hints at permission-based filtering but does not elaborate on pagination, response shape, or the role of the tree parameter. No additional behavioral detail is provided beyond what annotations already 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?

The description is a single efficient sentence that front-loads the action ('List') and the object ('Jenkins views'). It contains no filler words, repetition, or unnecessary 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?

Although an output schema exists and the core action is simple, the description omits any explanation of the tree parameter, which is essential for customizing the response. It also provides no context about when to use this tool versus jenkins_get_view. These gaps make the description incomplete for an agent to confidently invoke the tool with informed parameter choices.

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 only parameter, 'tree', has 0% schema description coverage and the description does not mention it at all. The agent receives no explanation of what the tree parameter controls or what format is expected. The description completely fails to compensate for the schema 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 uses the specific verb 'List' with the resource 'Jenkins views' and adds the scope 'visible to the user'. This clearly distinguishes it from sibling tools like jenkins_get_view, which retrieves a single view, and other list tools like jenkins_list_jobs.

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 alternatives. It does not mention jenkins_get_view for viewing details of a single view, nor any conditions, prerequisites, or exclusions. The agent must infer usage from the one-line description 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?

Annotations already indicate readOnlyHint=true, and the description adds useful behavioral detail: the operation streams, is bounded, and requires an exact case-sensitive literal rather than a regex or substring. This goes beyond the annotations without contradicting them.

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 word earns its place by conveying the action, the resource, the scope, and the matching semantics.

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 output schema covers return values and annotations cover safety, but the description does not explain the meaning of max_matches or max_scan_bytes boundaries, nor does it clarify interaction between 'bounded' scanning and the search result. It is adequate for a simple read-only search, but not fully self-sufficient.

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

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

Schema description coverage is 0%, so the description must compensate, but it only implicitly clarifies 'pattern' as an exact case-sensitive literal and 'bounded consoleText' as scan limitations. The roles of job, build, max_matches, and max_scan_bytes are left entirely 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 names a specific verb ('search') and resource ('build log') and adds precise matching semantics: exact, case-sensitive literal over bounded consoleText. This clearly differentiates it from sibling tools like jenkins_get_build_log and jenkins_get_build_log_chunk, which retrieve rather than search.

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

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

No guidance is given about when to use this tool versus alternatives such as jenkins_get_build_log or jenkins_get_build_log_chunk. The description implies search use, but it never states conditions, exclusions, or a preferred alternative.

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

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

Annotations already indicate non-readonly and non-idempotent behavior, and the description adds useful context by revealing that the download is asynchronous, gated, and writes to local disk. However, 'gated' is left unexplained, and there is no mention of whether a gate requires approval or what local path is used.

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

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

A single, front-loaded sentence with no filler or redundancy. It immediately names the action, the object, and the execution mode, making the definition easy to scan.

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 async initiation tool with no parameter descriptions, no explicit status-check guidance, and no explanation of 'gated', the one-line description leaves meaningful gaps. An agent may know to start the download but not how to construct valid arguments or how to monitor completion, even though an 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 the lack of parameter documentation. It does not explain how 'job' (which may be a string or array), 'build' (which defaults to lastBuild), or 'artifact_path' should be specified. The only hint is the word 'artifact', which adds minimal value beyond the schema property 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 uses a specific verb ('Start') and clearly identifies the resource ('one archived build artifact') and destination ('local disk'). It also signals the async/gated nature, which helps distinguish it from status and cancellation siblings, though it does not explicitly name those 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?

The phrase 'Start a gated async download' implies this is the initiation step of a multi-step download workflow, but it does not explicitly state when to use it versus the workspace download tools or when to follow up with status/cancel tools. Usage context is implied rather than directly explained.

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 not read-only, not idempotent, and destructive. The description adds the notion of 'start or join' and 'guarded' capture, which hints at concurrent-access or reuse semantics beyond the annotations. However, it does not disclose what gets destroyed, whether bundles are overwritten, or what cleanup is required, so the added behavioral context is thin.

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

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

The description is a single, front-loaded sentence with no filler. It is efficient and easy to parse. It sacrifices some clarity for brevity, leaving terms like 'guarded' undefined, but as a concise summary it works well.

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

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

Despite having an output schema, this tool appears to be part of a multi-step bundle download workflow with sibling status/cancel/cleanup operations. The description does not explain where this tool fits in that workflow, what 'joining' means in practice, or how parameters affect the operation. Given 0% parameter coverage and no usage guidance, the description is not complete enough for an agent to call it confidently.

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

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

Schema description coverage is 0%, and the description provides no parameter explanations. It does not clarify that 'job' is the Jenkins job to capture, that 'build' can be a numeric build or a string like 'lastBuild', or what 'force_refresh' actually forces. The schema only has titles and defaults, so the description must compensate but does not.

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 ('Start or join') and a resource ('guarded workspace capture') plus an additional deliverable ('exact build console log'). This distinguishes it from simple log-fetching tools and indicates it starts a bundle download. However, 'guarded workspace capture' is somewhat jargon-heavy and not fully self-explanatory.

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

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

No guidance is given about when to use this tool versus siblings like start_workspace_path_download, get_workspace_bundle_status, or cancel_workspace_bundle_download. The phrase 'start or join' hints at idempotent/join behavior but does not explain the workflow or exclusion conditions. An agent gets no help routing between the many bundle/workspace-related 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 indicate destructiveHint=true, readOnlyHint=false, and idempotentHint=false. The description adds some useful context by saying the operation is 'guarded' and can be started or joined, which hints at concurrency and statefulness. However, it does not explain what destructive side effects occur or how a caller should manage the resulting 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 compact sentence with no filler. It loses a point because 'guarded' and 'plus exact console log' are vague enough that brevity comes at the expense of clarity.

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 an output schema, so return shape is covered, but for a stateful, destructive operation with five parameters and zero schema descriptions, the description is far too thin. It lacks parameter semantics, lifecycle guidance, and any relationship to the status/cancel/cleanup siblings, leaving the agent to guess at 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?

The schema has 0% description coverage, and the description compensates very little. It hints at 'workspace_path' and possibly 'kind' via 'file/folder', but job, build, and force_refresh are entirely unexplained, and no values or defaults for 'kind' are given.

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 operation ('start or join') on a specific resource ('workspace file/folder capture') and adds that an exact console log is included. It is distinguishable from the bundled workspace download siblings, though 'guarded' and 'exact console log' remain somewhat ambiguous.

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

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

There is no guidance about when to use this tool instead of jenkins_start_workspace_bundle_download, jenkins_get_workspace_bundle_status, or related cancel/cleanup tools. The phrase 'start or join' implies an asynchronous or resumable workflow, but no explicit context, prerequisites, or alternative conditions are provided.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the description is not contradicting them. It adds the critical prerequisite, JENKINS_MCP_ENABLE_WRITES=1, which is beyond the structured annotations and is essential for the agent to know before invoking the tool. It does not disclose consequences for already-finished builds, but the added context is valuable.

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 exactly two sentences with no fluff. The main action is front-loaded, and the prerequisite follows immediately. 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?

The description mentions a critical environment variable and the action, but it lacks parameter semantics and usage guidance. Given this is a destructive write operation with 0% parameter schema coverage, an agent would still be uncertain how to correctly populate the 'job' and 'build' arguments, especially with their polymorphic types. The output schema exists but does not compensate for these 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 0% and the description does not explain either parameter. The schema shows 'job' accepts string or array and 'build' accepts integer or string, but the agent receives no guidance on what values are expected, what the array means, or the relationship between the two parameters. The description entirely fails to compensate for the missing schema descriptions.

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

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

The description uses a specific verb ('Stop') with a clear resource ('a running build'), which unambiguously identifies the tool's function. It also naturally differentiates from sibling tools like jenkins_cancel_queue_item (which cancels queued items) and jenkins_delete_job (which deletes jobs).

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 only a prerequisite (JENKINS_MCP_ENABLE_WRITES=1) and provides no guidance on when to use this tool versus alternatives. It does not mention when not to use it, how it relates to jenkins_cancel_queue_item, or what conditions justify stopping a build.

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 carry the safety profile (readOnlyHint=false, destructiveHint=true, idempotentHint=false), so the bar is lower. The description adds a genuinely useful behavioral constraint — 'Requires JENKINS_MCP_ENABLE_WRITES=1' — which captures a write-gating configuration an agent must check before invoking. No contradiction with annotations; it aligns with the non-read-only, destructive hints.

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

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

Two short sentences with zero filler. The core action and scoping qualifier are front-loaded in the first sentence, and the operational prerequisite is a tight second sentence. 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?

The output schema exists, so return values are documented elsewhere, and annotations cover the mutation/destructive profile. However, for a destructive action the description is thin: it doesn't explain the `delay` parameter, the array form of `job`, or what happens post-trigger (e.g., build is queued vs. started). These are real gaps, but the schema and annotations mitigate the worst of 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 0%, so the description must compensate — and it doesn't. 'Non-parameterized' refers to the Jenkins job, not the tool's parameters. The description says nothing about what `delay` means (format, unit, null semantics) or why `job` accepts both a string and an array (does an array trigger multiple jobs?). Both parameters remain effectively undocumented.

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 ('Trigger'), a specific resource ('job build'), and a crucial scoping qualifier ('non-parameterized'). The qualifier cleanly distinguishes this from its sibling jenkins_trigger_build_with_parameters, so an agent can tell them apart without opening either 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 'non-parameterized' qualifier gives clear context for when to use this tool, and the env-var prerequisite is explicit operational guidance. However, it never names the alternative tool for parameterized jobs (jenkins_trigger_build_with_parameters), so the routing is implied rather than explicit — clear context, but no stated 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 that the tool is non-readonly, non-idempotent, and destructive, so the safety profile is handled. The description adds genuinely useful behavior beyond annotations by disclosing the environment gate 'Requires JENKINS_MCP_ENABLE_WRITES=1,' an operational precondition that will cause the call to fail if not satisfied.

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 totaling roughly a dozen words, with the action front-loaded and the prerequisite in the second sentence. There is zero redundancy and every sentence earns its place.

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

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

Annotations cover the destructive write safety profile and an output schema exists, which lowers the bar for explaining return values. However, given 0% schema description coverage, a nested object parameter, and a sibling jenkins_trigger_build that needs differentiation, the description leaves parameter formatting and tool-selection decisions entirely to the agent.

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

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

Schema description coverage is 0%, so the description carried the full burden of explaining the three parameters (job, parameters, delay), but it names none of them. The parameter names are self-evident enough to avoid a 1, yet the nested 'parameters' object shape and the string-or-array flexibility of 'job' are left completely unexplained.

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 action verb ('trigger') and a specific resource ('a parameterized job build'), and the qualifier 'parameterized' distinguishes it from the closely related sibling jenkins_trigger_build. The action is unambiguous and tells an agent exactly what this tool does.

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 a real prerequisite, 'Requires JENKINS_MCP_ENABLE_WRITES=1,' which tells the agent the condition under which the call will succeed. However, it gives no explicit guidance on when to choose this over the sibling jenkins_trigger_build; that routing is only implied by the tool name rather than stated.

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

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

Annotations already mark the call destructive and readOnly=false; the description adds that Jenkins 'reserializes' the supplied config, warning that input is not stored verbatim. Mentioning 'write gates' gives authorization context beyond what annotations provide. 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?

Two short sentences carry the core action, a behavioral caveat, and a permission prerequisite. There is no filler, and the critical 'Replace job config.xml' statement is front-loaded.

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

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

With destructiveHint and an output schema present, the description doesn't need to cover safety or return values. It still lacks parameter semantics and the batch/single-job ambiguity implied by the `job` array type, but the core replace behavior, permission gate, and reserialization caveat make it minimally complete.

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

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

With schema description coverage at 0%, the description needed to explain both `job` and `config_xml`; it only hints at `config_xml` via 'config.xml'. It says nothing about the `job` parameter, including its string-or-array ambiguity. This is inadequate compensation for the missing schema descriptions.

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

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

The opening phrase 'Replace job config.xml' names a specific mutation and target. It clearly distinguishes this from siblings like jenkins_get_job_config, jenkins_create_job, and jenkins_delete_job. The reserialization note reinforces what 'update' means 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 implies the use case—replacing an existing job's config—and adds a permission prerequisite ('Requires job-config write gates'). It does not, however, name alternatives or state when not to use it relative to jenkins_create_job or jenkins_copy_job. This leaves routing decisions mostly 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?

The annotations already declare readOnlyHint=true and openWorldHint=true, establishing the safety profile. The description adds a specific behavioral detail—that the version is read from the X-Jenkins response header—giving the agent insight into how the result is obtained. This is useful context beyond the annotations, though it doesn't cover error handling or auth requirements, which are minor for such a simple read 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, tightly worded sentence that delivers the core purpose and a notable behavioral detail. It has no filler or redundant content, and the key action is front-loaded. Every word earns its place.

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

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

For a zero-parameter, read-only tool with an output schema present, the description fully covers what the tool does and where the data comes from. An agent has everything needed to invoke it correctly. No additional context is required.

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

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

There are zero parameters, and the schema coverage is 100% (empty schema). The baseline for zero-parameter tools is 4. The description does not need to add parameter details, and mentioning the response header is not parameter-related. No gaps exist.

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

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

The description states a specific action ('Return'), a specific resource ('Jenkins version'), and the data source ('X-Jenkins response header'). This clearly distinguishes it from siblings like jenkins_health or jenkins_whoami, which address different purposes. There is no ambiguity about what this tool does.

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

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

There is no explicit guidance on when to use this tool versus alternatives, nor any mention of exclusions or prerequisites. However, the purpose is self-evident, so an agent can reasonably infer that it should be used when the Jenkins server version is needed. This falls under implied usage rather than no 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 and openWorldHint, so the safety profile is covered. The description adds the endpoint detail but does not disclose additional behavioral traits such as authentication failure behavior or response shape, though that information would be useful.

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 that front-loads the tool's purpose and includes the relevant endpoint without any filler. Every word earns its place.

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

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

For a no-parameter, read-only tool with an output schema, this description is complete. It tells the agent exactly what the tool returns and from where, and there is no ambiguity about invocation requirements.

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. The description correctly does not attempt to specify any parameters, and the schema already confirms there are none.

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 it returns the authenticated Jenkins identity, naming both the specific resource and the endpoint it queries. This is precise and unambiguous, and it naturally distinguishes the tool from all sibling tools that deal with jobs, builds, nodes, or plugins.

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 tool when you need the current authenticated Jenkins identity. It does not explicitly list exclusions or name alternatives, but there is no close sibling tool covering the same function, so the intended usage is straightforward.

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