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

Annotations already declare destructiveHint=true, so the description adds value by specifying that it terminates the worker process tree and only affects queued or running jobs. This provides concrete behavioral context beyond the annotation without contradiction.

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

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

The description is a single, front-loaded sentence with no redundant words. Every element adds value, making it highly concise and well-structured.

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

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

The description is incomplete for effective use: it omits parameter guidance, does not clarify the difference from 'cancel_jobs', and provides no usage context. While the output schema exists, the description still fails to cover essential operational details.

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 mention the 'job_id' parameter at all. It fails to explain what the identifier represents, its format, or how to obtain it, leaving the agent to rely solely on the bare schema.

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

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

The description uses a specific verb ('Cancel') and resource ('a queued or running job'), and adds detail about the effect ('terminating the worker process tree'). It is clear and distinct from read tools, but does not explicitly differentiate from the sibling 'cancel_jobs' beyond the singular 'a 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?

No guidance is given on when to use this tool versus the plural 'cancel_jobs' or other siblings. There is no mention of prerequisites, exclusions, or alternative tools, leaving the agent to infer usage.

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

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

Annotations already indicate destructive behavior with destructiveHint=true, so the description does not need to restate that. It adds useful context that only queued or running jobs are affected, but does not mention what happens to already completed or canceled jobs.

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, focused sentence that conveys the core behavior without filler. Every word earns its place and the scope 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?

The tool is simple with one parameter and has an output schema, so the description covers the basic call. However, it lacks usage guidance relative to cancel_job and does not enrich the job_ids parameter semantics, leaving minor but real gaps for an agent deciding how to invoke 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 job_ids parameter beyond the word 'selected'. The schema itself shows an array of strings, but the description provides no additional meaning such as how IDs are obtained, uniqueness requirements, or batch size limits.

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 (cancel), resource (jobs), and scope (selected queued or running jobs). It distinguishes the operation from starting or listing jobs, though it does not explicitly differentiate itself from the sibling cancel_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?

No guidance is given about when to use this plural cancel_jobs versus cancel_job, or when cancellation is appropriate versus starting or checking jobs. The context that only queued or running jobs are eligible is present, but no alternatives or exclusions are 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 'Return' is consistent with a read operation. The description adds only the 'current' freshness nuance and the metadata/status scope, but does not disclose behavior like caching, error handling, or auth requirements. With the annotation covering the safety profile, this is adequate but minimal.

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

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

A single, short declarative sentence with no redundancy. Every word contributes to the meaning, and the key scope ('one job') 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?

For a simple, single-parameter, read-only tool with an output schema and readOnlyHint annotation, the description doesn't need to explain return values. It covers what the call does and at what scope, but the lack of sibling routing guidance keeps it from being fully complete.

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

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

There is one parameter, job_id, and the description maps to it indirectly via 'for one job'. Schema description coverage is 0%, so the description should compensate; it partially does by clarifying the target of the operation, but it does not explain valid formats, how to obtain a job_id, or edge cases.

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 states a specific verb and resource: 'Return' plus 'one job', and specifies the content as 'current metadata and status'. This makes the operation clear and distinguishes it from sibling plural/result tools like get_jobs and get_results.

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 'for one job' implies when to use it, but no explicit alternatives or exclusions are given. An agent gets no direct guidance on choosing between get_job, get_jobs, list_jobs, or get_result.

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 the description does not need to repeat that. It adds the qualifier 'current' to metadata/status, implying a snapshot of the present state rather than historical data. However, it does not disclose potential partial failures, error behavior, or any special cases. With the annotation covering the core safety profile, a 3 is appropriate.

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

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

The description is a single, concise sentence with no wasted words. It is front-loaded with the action and target. However, it is so brief that it borders on under-specification, but as a concise statement it is 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?

Given the tool has one parameter, an output schema (which defines the return format), and a read-only annotation, the description is minimally sufficient. It communicates the core action but lacks context on usage, parameter details, and any edge cases. For a simple read operation, it is adequate but not rich. More detail would help the agent call it correctly in all scenarios.

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 parameter 'job_ids' has no description in the schema. The tool description merely says 'selected jobs' without elaborating on the format, constraints, or meaning of job IDs. This leaves the agent without clear guidance on what values to provide, requiring it to guess or look elsewhere. The description should compensate for the missing schema descriptions 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 clearly states a specific action ('Return current metadata and status') on a specific resource ('selected jobs'), using a plural to indicate multiple jobs, which distinguishes it from the singular 'get_job' sibling. It is not a tautology and gives an agent a precise idea of what the 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 provides no guidance on when to use this tool versus alternatives like 'get_job', 'list_jobs', or 'get_result'. There is no mention of prerequisites, exclusions, or typical scenarios. The agent is left to infer usage from the name and parameter 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?

Given the readOnlyHint annotation already covers safety, the description adds some behavioral context ('persisted' and 'when completed'), implying the result is only available after completion. However, it doesn't disclose behavior for non-completed jobs, error conditions, or whether the call blocks. This is adequate but not rich.

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

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

The description is a single, front-loaded sentence with no filler. It efficiently communicates the core purpose, though it could add a brief note about parameter requirements without becoming verbose.

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

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

Since an output schema is present, return values don't need describing, and the readOnly annotation covers safety. However, the description does not clarify the distinction from get_job/get_results or explain the behavior when a job is not completed, leaving some gaps for correct invocation.

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

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

Schema description coverage is 0%, so the description carries the burden of explaining the job_id parameter. It does not mention job_id at all, nor its format or how to obtain it. Although the parameter name is self-explanatory, the description adds no value for parameter understanding.

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

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

The description clearly states a specific verb ('Return') and resource ('persisted job metadata and its result'), and adds the condition 'when completed' which differentiates it from sibling tools like get_job (metadata only) and get_results (multiple results). An agent can accurately identify the tool's scope.

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

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

The description implies the tool is used after a job completes, but it does not explicitly say when to use it over alternatives like get_job or list_jobs, nor does it provide exclusionary guidance. The usage context 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?

The readOnlyHint annotation already establishes that this is a safe read operation. The description adds the 'persisted' qualifier, which hints that results are stored and returned after jobs have run, but it does not clarify behavior around incomplete jobs, invalid IDs, or response handling.

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 nine-word sentence that front-loads the action and object. Every word earns its place, and 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?

With readOnlyHint, an output schema, and a single self-explanatory parameter, the description is nearly complete for this simple batch-read tool. The only minor gap is the lack of explicit lifecycle context, though 'persisted' partially covers that.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented job_ids parameter. It does this only loosely by referring to 'selected jobs', which maps to job_ids but adds no detail about ID format, limits, or semantics beyond what the property name already implies.

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 ('Return') and resource ('persisted metadata and results') for selected jobs, which conveys the batch retrieval purpose. It does not explicitly contrast with get_job or get_jobs, but the plural 'jobs' plus the required job_ids parameter makes the batch nature reasonably clear.

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

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

There is no guidance about when to use this tool versus get_job, get_jobs, or list_jobs, and no mention of prerequisites such as jobs being completed. The only usage signal is implicit from 'selected jobs' and the job_ids parameter.

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, so the read-only nature is covered. The description adds only 'recent' and optional status filtering, which provides modest behavioral context but does not address ordering guarantees, pagination, or how 'recent' is defined. No contradiction with annotations exists.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes meaning: 'List', 'recent jobs', and 'optionally filtered by status' all add useful scope without redundancy.

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

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

For a simple read-only list operation with an output schema and only two optional parameters, the description is mostly adequate. However, it leaves the notion of 'recent' undefined, does not specify valid status values, and gives no mention of how limit affects results. These are small but real gaps for an agent deciding how to invoke the tool.

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

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

Schema description coverage is 0%, so the description carries the burden of explaining parameters. It mentions status filtering but does not explain the limit parameter or the possible values/format of status. The schema's property names, types, and defaults provide some guidance, but the description only partially compensates for the lack of parameter documentation.

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 resource ('jobs') and adds the scoping qualifier 'recent' plus an optional status filter. This clearly differentiates it from sibling tools like start_job, cancel_job, and get_job, which represent different operations.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention that get_job/get_jobs should be used for retrieving details of specific jobs, nor does it specify when the status filter is appropriate. Usage must be inferred entirely from the tool name and sibling list.

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 the description is not required to state that. It adds context about the optional reload behavior, but does not explain what reload does (e.g., side effects on the displayed list or underlying data). This is a moderate addition beyond 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 sentence that front-loads the core purpose and then adds the optional behavior. There is no redundancy or filler, making it highly concise and well-structured.

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

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

Given the tool's simplicity (one optional boolean parameter), the presence of an output schema, and annotations covering read-only behavior, the description is complete enough. An agent can invoke this tool correctly without missing critical information.

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 only defines 'reload' as a boolean with default false, and schema description coverage is 0%. The description explicitly mentions 'optionally reload TOML files', which explains the parameter's purpose and adds meaning beyond the raw schema. This is a clear compensation for the missing schema description.

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

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

The description clearly states the verb 'List' and the resource 'declarative worker profiles and capabilities', and mentions an optional reload behavior. It is distinct from sibling tools which all relate to jobs and results, so there is no ambiguity about its 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?

The description gives a hint about when to use the reload option ('optionally reload TOML files') but does not explicitly contrast this tool with alternatives or state when not to use it. Since siblings are clearly job-related, usage is implied, but no direct guidance is 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?

The description adds a meaningful behavioral detail beyond annotations: the tool 'return[s] immediately' rather than waiting for job completion. Annotations already signal non-read-only and non-destructive behavior, so the description does not need to restate that, but it also does not mention limits, validation failures, or side effects.

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

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

The description is a single front-loaded sentence with no wasted words. It loses a point because the word 'controlled' is vague and does little to clarify behavior, but overall it is appropriately compact.

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

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

For a tool with six parameters, no schema-description coverage, and no explicit sibling routing, this is too sparse to support correct invocation. The output schema covers the return shape, so that part is fine, but the agent is left guessing about parameter semantics and lifecycle context.

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

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

Schema description coverage is 0%, and the description mentions none of the six parameters. It does not clarify what task, worker_profile, timeout, scope_paths, output_schema, or evidence_budget mean or how they interact, placing the entire burden on parameter 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 ('Queue') and resource ('one controlled research job'), and states the outcome ('return immediately with its job metadata'). It distinguishes from sibling start_jobs by explicitly limiting to one job, though it doesn't name the sibling directly.

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

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

There is an implied usage context: use this to launch a single job and get its metadata right away. However, it does not state when to prefer start_jobs for multiple jobs, or mention that status and results are retrieved via get_job/get_result. No alternatives or exclusions 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?

The description adds meaningful behavioral context beyond the annotations: atomicity of validation, queueing semantics (jobs are not executed synchronously), and that only metadata is returned immediately (implying results must be fetched later). This aligns with readOnlyHint=false/destructiveHint=false and helps the agent set follow-up 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?

One dense 11-word sentence that front-loads the core action (atomic validate, queue) and the key consequence (immediate metadata return). No filler words or redundant restatements of the 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 adequately covers the tool's headline behavior and the output schema presumably documents the return metadata, so return format is not a gap. However, for a tool with a complex nested JobRequest (six sub-fields, including worker_profile that a sibling lists) and asynchronous queue semantics, the description leaves out what happens on validation failure and how to follow up on results, which the agent must infer.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters, but it only restates 'multiple jobs' and says nothing about the JobRequest sub-fields (task, worker_profile, timeout, scope_paths, output_schema, evidence_budget). The schema's titles and defaults carry the entire semantic burden, and the description adds no meaning to them.

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 ('queue') and resource ('multiple jobs') and adds behavioral detail — 'atomically validate' and 'immediately return metadata' — that goes well beyond a generic verb+noun phrase. The plural form implicitly distinguishes this from the sibling start_job 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 phrase 'multiple jobs' implies a batch use case and suggests preferring this over start_job for bulk operations, but the description never explicitly says when to choose this tool versus start_job, gets, or cancels. There is no when-not guidance or mention of alternatives.

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