Teamtailor Ops Control Plane

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It fails to mention that non-GET requests can have side effects, that confirm must be true to execute a live change, or that dry_run is available for preview. The schema includes these safety features, but the description itself does not set expectations about mutating behavior or confirmation requirements.

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

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

The description is a single, well-structured sentence that immediately conveys the tool's purpose. There is no filler or redundant content; 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 tool has 7 parameters, nested objects, a generic endpoint-calling scope, and no output schema. The one-sentence description does not explain the request/response format, error behavior, or how the confirm/dry_run fields interact with the saved connection details. Given the tool's flexibility, more context about advanced usage and fallback scenarios is needed.

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

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

The schema descriptions cover 86% of parameters, including detailed explanations for confirm, dry_run, body_json, query_json, and headers_json. The description adds no parameter-level information beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool's function: use any documented Teamtailor Ops Control Plane endpoint via the buyer's saved connection details. This distinguishes it from specific sibling tools like create_candidate or list_jobs, which target individual resources. The verb 'use' plus 'any documented endpoint' makes the scope explicit.

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 'any documented endpoint' implies it can be used when no specific tool exists, but it never explicitly says 'prefer the specific tools when available' or 'use only for endpoints without a dedicated function.' The guidance is implied, not stated, so it lacks clear when/when-not 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?

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It merely says 'create' and does not mention key behaviors like the confirm/dry_run mechanism, potential side effects, or required permissions. This leaves the agent blind to critical runtime behaviors.

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

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

The description is a single sentence with no wasted words, but it is under-specified. For a tool with six parameters and complex nested objects, this level of brevity is more under-specification than effective conciseness. It earns its place but provides minimal 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?

Given the tool's complexity (6 parameters, nested objects, no annotations, no output schema), the description is far from complete. It doesn't explain what constitutes a Teamtailor candidate, what fields body_json should contain, what the return value is, or how confirm/dry_run affect the operation. Almost all necessary context is missing.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-specific information beyond what the schema already provides. While the generic wrapper parameters (confirm, dry_run, body_json, etc.) are documented in the schema, the description doesn't clarify how they apply to creating a candidate specifically.

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 ('Create') and resource ('Teamtailor candidate'), which clearly conveys the tool's core function. However, it doesn't differentiate from sibling tools like create_job or create_job_application beyond the resource name itself, which is already evident from the tool name.

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

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

There is no guidance on when to use this tool versus alternatives, nor any mention of prerequisites or exclusions. The description simply states what it does without providing context for selection.

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

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

With no annotations, the description carries the full burden of disclosing behavioral traits. It does not mention that this is a live mutation, that confirm=true is required, or that dry_run offers a preview. The description is completely opaque about side effects, permissions, or execution semantics, which is a serious gap for a write tool.

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

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

The description is a single sentence with no wasted words, making it very concise and well-structured. It does not suffer from bloat or poor organization. Its brevity is a double-edged sword, but for this dimension, 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?

This is a mutation tool with no annotations, no output schema, and generic HTTP-style parameters. The description provides none of the necessary context: expected body fields, confirm/dry_run semantics, or return values. It is severely under-specified and would not enable an agent to confidently 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?

The input schema provides descriptions for all six parameters, so the baseline is 3 per the rubric. However, those schema descriptions are generic (e.g., body_json as 'JSON request body for documented write operations') and the tool description adds no job-specific meaning. The description does not help the agent understand what fields to include or how to supply 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 clearly states the action ('Create') and the resource ('Teamtailor job'), making the core purpose unambiguous. It distinguishes itself from update_job by the verb and from other create tools by the resource, though it lacks scope details. The description is essentially a restatement of the tool name but remains 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 alternatives such as api_request or update_job. No prerequisites, exclusions, or context are provided. The only implied usage is the action itself, which is insufficient for an agent to decide between similar write tools.

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

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

No annotations are provided, and the description merely says 'Create a Teamtailor job application.' It does not disclose side effects, required confirm/dry_run semantics, authentication needs, or expected return behavior, offering no behavioral context beyond the tool name.

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, making it concise. However, it is under-specified; adding a second sentence about required input or usage would improve value without sacrificing conciseness.

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

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

With no output schema and no annotations, this one-sentence description is insufficient for a mutation tool with six generic parameters. An agent cannot determine the required payload structure, confirmation flow, or expected outcome, making the description incomplete for the tool's complexity.

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

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

The schema has 100% description coverage for all six parameters, but those descriptions are generic boilerplate (e.g., 'JSON request body for documented write operations'). The tool description adds no job-application-specific parameter guidance, so the baseline 3 applies due to full schema coverage.

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

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

The description uses the specific verb 'Create' with the resource 'a Teamtailor job application', making the tool's purpose clear. It is distinguishable from sibling tools like create_candidate or create_job, though it does not explicitly differentiate itself.

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 create_candidate, create_job, or update_job_application. The description only states the action and offers no context for selection.

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

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

No annotations are provided, so the description carries the full burden. It only says 'Get one answer' and the domain of answers, but does not disclose read-only status, response format, error behavior, or required permissions. It relies on the conventional meaning of 'get'.

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-loaded with the action ('Get one answer') and followed by context. No wasted words, though it is minimal.

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

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

For a tool with 5 parameters, nested objects, no annotations, and no output schema, the description is too brief. It does not mention the include parameter, the effect of detail_profile, response structure, or any usage tips. The schema covers params but the description leaves the agent without guidance on what the response contains or how to handle 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 80%, so the schema already documents most parameters. The description adds no parameter-specific detail beyond what the schema provides, so the baseline 3 applies.

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

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

The description uses a specific verb and resource ('Get one answer') and adds the context of 'Application answers for qualification and application-completeness analysis.' This clearly distinguishes it from list_answers and other get_* tools for different entities.

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 singular retrieval ('one answer') but does not explicitly state when to use this tool versus list_answers or other alternatives. No exclusions or alternative mentions 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?

With no annotations, the description carries full responsibility for behavioral disclosure. It only defines audit events ('governance and change history') but does not mention return format, pagination, auth requirements, error behavior, or the effect of the detail_profile parameter that could alter response 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?

The description is concise with two short sentences and no fluff. The second sentence adds context about audit events, but the overall brevity could be seen as under-specification rather than efficient conciseness, though it is appropriately 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?

Given the tool has 5 parameters, no output schema, and no annotations, the description is insufficient. It does not explain return values, provide usage context, or clarify the optional parameters like include and query_json. The description is too sparse to fully support an agent in invoking the tool correctly.

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

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

Schema coverage is high (80%), with descriptions for id, query_json, path_params, and detail_profile, so the baseline is 3. The description itself adds no parameter information, and the 'include' parameter remains undocumented in both schema and description, leaving a 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 'Get one audit_event', specifying the verb and resource, which is a straightforward retrieval operation by ID. It distinguishes from list_audit_events by using 'one', but does not explicitly name the alternative or elaborate on the 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?

No guidance is provided on when to use this tool versus alternatives like list_audit_events. The description implies usage by saying 'Get one' but omits any context about prerequisites, typical scenarios, or situations where another tool would be more appropriate.

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

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

No annotations are provided, and the description gives no details about side effects, authentication, rate limits, or return format. The term 'Get' implies a read operation, but the description does not explicitly state that this is read-only or disclose any behavioral constraints.

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

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

The description is only two sentences, with the first sentence being clear and front-loaded. The second sentence is somewhat ambiguous but still concise, so it does not waste words.

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

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

For a tool with 5 parameters and no output schema, the description is thin. It does not explain the meaning of the analysis types, the behavior of the 'include' parameter, or when a different detail_profile should be used, limiting the agent's ability to invoke the tool 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?

The schema covers 80% of parameters with descriptions for id, query_json, path_params, and detail_profile, so the baseline is 3. The description itself adds no parameter guidance, and the 'include' parameter remains undocumented in both the description and schema.

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

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

The description opens with 'Get one candidate,' which clearly identifies the action and resource. The follow-up phrase 'Candidates for stale-candidate, source-quality, ownership, and follow-up analysis' adds a usage scope, distinguishing this tool from generic list candidates.

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 analysis use cases but does not explicitly state when to use this tool versus alternatives like list_candidates. There is no mention of exclusions or prerequisites, leaving the decision to the agent.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. 'Show' implies a read-only operation, but the description does not explicitly state that it is safe, what permissions are required, or what side effects (if any) exist. It also does not explain what 'coverage' entails beyond the three categories.

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, front-loaded with the verb and resource, and contains no filler or redundant information. It 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?

The tool is simple with no parameters and no output schema, so the description should compensate by explaining the nature of the output. While it mentions the three coverage areas, it does not clarify what 'coverage' means (e.g., a list, counts, booleans) or what the return format looks like, leaving some ambiguity.

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

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

The input schema is empty with zero parameters, so the baseline is 4. The description adds context about the tool's output scope (question, reporting, action coverage), which goes beyond the schema. It does not need to document parameters since 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 identifies the tool as showing 'Teamtailor Ops Control Plane' coverage and distinguishes it from sibling get_* tools for specific entities. The verb 'Show' is specific, and the resource is well-defined, though the phrase 'question, reporting, and action coverage' is somewhat jargon-heavy.

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 is implied by the tool's name and description: it provides an overview of control plane capabilities. However, there is no explicit guidance on when to use this instead of alternatives like api_request or the entity-specific get_/list_ tools, nor any exclusions.

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

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

With no annotations, the description carries full behavioral burden but only states 'Get one department.' It does not mention return format, error behavior, authentication needs, or any side effects, offering little beyond the tool's name.

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. It is front-loaded and easy to parse, though it could be slightly longer to cover essential behavioral context.

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

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

Despite having 5 parameters, nested objects, and no output schema, the description is minimal and does not explain query_json, path_params, include, or return behavior. It is insufficient for an agent to fully understand the tool's capabilities.

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

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

Schema description coverage is 80%, so baseline is 3. The description itself adds no parameter meaning; notably, the 'include' parameter has no schema description and the description does not clarify it, preventing a higher score.

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

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

The description clearly states the action ('Get one department') and resource, distinguishing it from list_departments. The phrase 'Departments for role/function slicing' adds domain context but does not explicitly mention sibling 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?

No explicit when-to-use or alternative guidance is provided. 'Departments for role/function slicing' hints at a use case but does not clarify when to prefer this over list_departments or other get_* tools.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only says 'Get one division,' offering no information about return format, whether it supports partial responses, permissions required, or any side effects. This is insufficient for a tool with no annotation support.

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 very concise: two short sentences. It front-loads the primary action 'Get one division' immediately. The second sentence 'Divisions for organization-level slicing' is somewhat vague but adds a hint of purpose without bloating the text. 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?

This is a single-resource getter with 5 parameters and no output schema, so some contextual depth would help. The description provides minimal context beyond the tool's core action. Given the schema explains detail_profile and query_json, the description is adequately complete for a simple get, but could benefit from noting the division's organizational role or response behavior.

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

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

Schema description coverage is 80%, so the schema already documents most parameters (id, detail_profile, query_json, path_params). The tool description adds no parameter-level meaning, but the high schema coverage makes this acceptable. The 'include' parameter lacks a description, but that gap isn't filled here.

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

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

The description states a clear verb and resource: 'Get one division.' It distinguishes itself from list_divisions by emphasizing 'one' (singular) and adds a domain hint with 'Divisions for organization-level slicing.' While not as explicit as naming alternative tools, the purpose is specific and unambiguous.

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

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

There is no explicit guidance on when to use this tool versus list_divisions or other get_* tools. The phrase 'Divisions for organization-level slicing' is vague and doesn't clarify selection criteria. No alternatives are named and no exclusion conditions are given.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states what the tool gets, not whether it is read-only, what data is returned, or any side effects. The phrase 'application structure metadata' is vague and adds limited transparency.

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

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

The description is extremely concise, with no filler. 'Get one form' is front-loaded and effective, and the clarifying clause is short. However, the phrase 'Forms and application structure metadata' is slightly vague, preventing a perfect score.

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 has 5 parameters, nested objects, and no output schema or annotations, yet the description is minimal. It does not explain return values, filtering behavior, or how parameters like include and query_json interact. The description is inadequate for the tool's complexity.

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

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

Schema description coverage is 80%, so the schema already documents most parameters. The description adds no detail about id, include, query_json, path_params, or detail_profile beyond what the schema provides. Baseline score of 3 is appropriate since the schema does most of the work.

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 'Get one form' uses a specific verb and resource, clearly indicating it fetches a single form. It distinguishes itself from sibling list_forms by emphasizing 'one', and the added phrase 'Forms and application structure metadata' helps contextualize the 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 context ('Get one form') but does not explicitly state when to use this tool versus list_forms or other get_* tools. No alternatives or exclusion criteria 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?

No annotations are provided, and the description does not disclose behavioral traits such as return format, permissions, or whether the operation has side effects. The name 'get' implies read-only, but the description fails to confirm this or mention any limitations.

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

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

The description is concise, with only two sentences that directly state the tool's purpose and context. There is no redundant or irrelevant information.

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

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

The tool has complex parameters and no output schema, yet the description is too thin. It does not explain what 'process load and feedback obligation analysis' means, nor does it clarify return values or usage prerequisites. The path_params schema description even mentions 'write operation', which is inconsistent with a getter 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 80%, which is high, so the baseline is 3. The description adds no parameter-level detail beyond the schema, but the schema itself provides good documentation, especially for detail_profile with its enum and default.

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 'Get one interview' with a specific verb and resource, and the phrase 'Interview records for process load and feedback obligation analysis' adds context. It distinguishes from sibling list_interviews by emphasizing the singular nature.

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 use this tool versus alternatives like list_interviews. The implied use case of 'process load and feedback obligation analysis' is mentioned, but there are no exclusions or alternative references.

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

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

No annotations are provided, and the description doesn't disclose behavioral aspects like whether it returns null for missing IDs, error handling, or any permission requirements. It only states what it does at a high level, leaving the agent without guidance on edge cases or side effects. Since it's a read operation, the risk is lower, but the description still fails to provide meaningful behavioral context.

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

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

The description is two short sentences: 'Get one job. Jobs for open-role inventory and hiring-team analysis.' It's front-loaded with the primary action and contains no unnecessary words.

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

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

The tool has 5 parameters including nested objects, but the schema provides good descriptions for most. The description doesn't explain return values or clarify whether 'job' refers to an open role or any job. Given no annotations or output schema, a bit more context about the tool's response or typical use would improve completeness, but the existing description is adequate for a straightforward get-by-ID operation.

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

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

Schema has descriptions for 4 of the 5 params (id, query_json, path_params, detail_profile), covering 80%. The description itself doesn't elaborate on parameters, but the schema already documents them adequately, including the detail_profile enum which explains the difference between operational and full responses. The un-described 'include' param remains uncovered, but with high schema coverage, the description doesn't need to compensate.

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 a specific verb 'Get' and resource 'one job', clearly distinguishing it from list_jobs which retrieves multiple jobs. The phrase 'Jobs for open-role inventory and hiring-team analysis' provides relevant domain context.

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

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

The phrase 'Jobs for open-role inventory and hiring-team analysis' gives a clear use case, implying the tool is used when analyzing open roles or hiring teams. However, it doesn't explicitly mention alternatives like list_jobs for multiple jobs, so it's context without exclusions.

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

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

No annotations are provided, so the description carries the burden. The verb 'Get' implies a read operation, and the analysis context adds some behavioral framing. However, it does not disclose response behavior, error handling, permissions, or rate limits, leaving gaps.

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

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

The description is concise, two sentences, with the primary action front-loaded. The second sentence adds context but is somewhat vague. Still, it is efficient and free of unnecessary verbiage.

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

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

Given no output schema and 5 parameters (including nested objects), the description is sparse. It does not explain how the analysis dimensions relate to query parameters like include or query_json, nor what the response contains. This leaves the agent with insufficient context to fully leverage 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 80%, with descriptions for id, query_json, path_params, and detail_profile. The tool description itself does not add parameter-level meaning, so it relies on the schema. Baseline of 3 is appropriate since schema covers most parameters.

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

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

The description clearly states the tool retrieves a single job_application ('Get one job_application'), using a specific verb and resource. It also distinguishes from list operations by indicating singular retrieval, and adds analysis context that differentiates it from other get_* 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 implies usage context by mentioning 'for stage, candidate, source, and stale-pipeline analysis', but does not explicitly state when to use this tool over list_job_applications or other alternatives. There are no exclusions or comparative guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it offers nothing beyond the literal 'Get one job_offer.' It does not mention read-only semantics, return format, pagination, auth needs, or any side effects. The cryptic 'offer-state hygiene' phrase does not clarify 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?

The first sentence is concise, but the second sentence 'Job offers for offer-state hygiene' is vague and does not earn its place. It adds confusion rather than value, making the description less effective than a single clear sentence would be.

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

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

For a tool with 5 parameters, nested objects, and no output schema, the description is severely lacking. It provides no context about response structure, how to use query_json or path_params, or why one would use this over list_job_offers. The description is inadequate for an agent to invoke this tool correctly beyond a basic guess.

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

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

Schema coverage is high (80%), so the baseline is 3. The description itself adds no parameter meaning, but the schema already describes most parameters including detail_profile with enum values. The 'include' parameter lacks a description, and the description does not compensate for this gap, but overall the schema handles parameter semantics adequately.

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 the core action 'Get one job_offer' with a specific resource, making it clear this retrieves a single job offer. However, it does not explicitly differentiate from sibling getters like get_job or get_candidate, though the resource name itself provides distinction. The second sentence 'Job offers for offer-state hygiene' is cryptic and does not clarify the 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 provides no guidance on when to use this tool versus alternatives such as list_job_offers or other get_* tools. There is no mention of context, prerequisites, or scenarios where this tool is appropriate, leaving the agent without decision-making information.

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

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

No annotations are provided, so the description carries the burden. The verb 'get' strongly implies a read-only operation, and the phrase 'for office/region slicing' adds purpose. However, it does not explicitly state read-only nature, response format, or any side effects, leaving some behavior implicit.

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 short sentences, with no fluff or repetition. It front-loads the core action and then adds context, making it highly 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 no output schema and no annotations, the description is minimal but adequate for a simple read tool. It indicates the resource and use case, but lacks details about return values or filtering behavior. The schema provides parameter details, but the description could offer more context on the response shape.

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

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

Schema description coverage is 80% (4 of 5 parameters have descriptions), so the baseline is 3. The description itself does not add meaning beyond 'Get one location,' which indirectly maps to the required 'id' parameter. The 'include' parameter lacks a schema description, and the description does not compensate.

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 location.' The second sentence, 'Locations for office/region slicing,' adds context and differentiates it from list_locations, which would be the sibling for fetching multiple locations. This is specific and non-tautological.

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

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

The description implies when to use the tool: when you need a single location by ID or for office/region slicing. It does not explicitly name alternatives or exclusions, but the context is clear enough for an agent to distinguish it from listing 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?

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'Get one note' and gives use cases, but omits return format, authentication needs, or the fact that the 'full' details may include personal fields (which is only in the schema). No contradictions exist, but critical behavioral context is missing.

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

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

The description is very short (two sentences) and front-loads the core action. The second sentence adds some vague purpose context but isn't egregiously wasteful. It earns a 4 for conciseness, though the second sentence could be more specific.

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 has 5 parameters, nested objects, and no output schema, yet the description explains almost nothing about behavior, return values, or the differences between detail profiles. It omits critical context like pagination, field projections, or the meaning of 'operational' vs 'full'. The schema covers parameter syntax but not operational context, so the description is inadequate for a tool of this complexity.

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

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

Schema description coverage is high at 80% (4 of 5 parameters have descriptions), so the baseline is 3. The tool description adds no additional parameter meaning, relying entirely on the schema. The missing 'include' parameter is undocumented in both description and schema, but the high coverage means the description doesn't need to compensate.

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 'Get one note' with a specific verb and resource, clearly distinguishing it from list_notes by emphasizing a single note retrieval. It also adds purpose context ('activity hygiene, follow-up context, and recruiter handoff analysis') 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 usage for retrieving a single note in specific recruiting contexts, but it does not explicitly state when to prefer this over list_notes or other tools. There's no mention of alternatives or exclusions, so it only provides implied guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It fails to mention key behavior such as the default 'operational' detail profile omitting personal fields, and that 'full' includes them. It also does not disclose error handling or rate limits. The description provides minimal insight into what the tool actually does beyond the basic 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 very short and front-loaded with the primary action. However, the second sentence 'Referrals for referral SLA and source-quality investigations' is grammatically awkward and does not earn its place; it could be removed or rewritten for clarity. As a result, while concise, the structure is flawed.

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 5 parameters, including a detail_profile with distinct projections and no output schema, the description is far too minimal. It does not explain return values, the impact of the detail_profile parameter, or the purpose of query_json. The vague use-case sentence does not provide sufficient context for an agent to understand how to invoke this tool correctly in different 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 80% (4 of 5 parameters have descriptions), and the tool description adds no parameter semantics. The 'include' parameter is left entirely undocumented, and the description does not clarify any parameter's purpose, format, or interaction. Since it does not compensate for the one missing parameter and adds no value beyond the schema, a score below the baseline is appropriate.

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

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

The description starts with 'Get one referral,' which is a clear specific verb+resource and distinguishes it from 'list_referrals' by indicating a single item. However, the second sentence 'Referrals for referral SLA and source-quality investigations' is a fragment that adds little clarity and could confuse the reader.

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 like 'list_referrals.' The singular 'one' implies fetching a single referral, but the description does not mention exclusions, prerequisites, or when a different tool would be more appropriate. The vague purpose clause does not serve as effective usage guidance.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior, but it only says 'Get one reject_reason.' It does not explain what the response contains, whether detail_profile affects the payload, or any other behavioral traits, leaving the agent with little information about the tool's actual execution.

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, only two short sentences. It front-loads the action and avoids any fluff or repetition, making it easy to parse and directly 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?

Given the tool has five parameters, nested objects, and no output schema, the description is too minimal. It does not explain return values, usage patterns, or how parameters like detail_profile alter responses. The lack of an output schema increases the need for descriptive context, which is not provided.

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

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

Schema description coverage is 80%, so the baseline is 3. The description adds no parameter-level meaning; however, most parameters already have descriptions in the schema. The 'include' parameter lacks a schema description and is not addressed in the tool description, but the overall coverage is sufficient for a baseline score.

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

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

The description clearly states the action ('Get one reject_reason') and resource, with the word 'one' distinguishing it from list_reject_reasons. The phrase 'Reject reasons for disposition hygiene' provides useful domain context, making the purpose unambiguous and distinct from sibling 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?

No guidance is given on when to use this tool versus alternatives like list_reject_reasons. The word 'one' implies fetching a single record, but there is no explicit mention of prerequisites, such as needing a specific ID, or when to prefer this over the list variant.

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

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

With no annotations present, the description carries full behavioral burden. It only says 'Get one requisition' and provides domain context; it does not disclose return format, permissions, side effects, or the existence of projection options like detail_profile, which are only in the schema.

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

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

The description is two concise sentences, front-loaded with the core action. No wasted words; each sentence adds relevant context.

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

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

For a simple get-by-id tool, the description covers the core purpose, and the schema provides parameter details. However, the description does not mention the available options (include, query_json, detail_profile) that affect the response, and there is no output schema to clarify return structure, leaving 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 80%, with most parameters documented in the schema. The description adds no additional parameter-level meaning; the baseline of 3 applies because the schema does the heavy lifting, though the 'include' parameter remains 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 opens with 'Get one requisition,' a specific verb and resource. The second sentence clarifies the domain context ('headcount and approval-flow investigations'), which distinguishes this from other get_* tools and from list_requisitions.

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 requisitions are for headcount and approval-flow investigations, but it does not explicitly say when to choose this over sibling tools like list_requisitions or get_requisition_step_verdict, nor when not to use it.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It simply states 'Get' which implies a read-only operation, but does not mention potential errors, authentication needs, rate limits, or any output/response behavior. The phrase 'Requisition approval verdicts' adds domain context but not behavioral transparency.

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

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

The description is two sentences, front-loaded with the core action and then a brief contextual clause. Every word earns its place; there is no fluff 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?

With no output schema and no annotations, the description must compensate for the tool's complexity. It has 5 parameters including nested objects and an enum, but the description does not explain what a requisition_step_verdict is (beyond a vague phrase), how to use the parameters, or what the response contains. This is insufficient for an agent to invoke the tool correctly without relying heavily on the schema.

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

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

Schema description coverage is 80% (4 of 5 parameters have descriptions). The tool description itself adds no parameter-level meaning beyond the schema. Since coverage is high, the baseline of 3 applies, and the description does not improve or degrade it.

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 resource ('requisition_step_verdict'), and explicitly says 'one' to distinguish from the sibling 'list_requisition_step_verdicts'. The added phrase 'Requisition approval verdicts for headcount workflow bottlenecks' gives domain context, though it is slightly jargon-heavy.

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

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

Usage is implied by the word 'one' which contrasts with the sibling 'list_requisition_step_verdicts', but there is no explicit statement of when to use this tool over alternatives, nor exclusions. The description provides minimal context for tool selection beyond the obvious.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Get' which implies a read operation, but does not explicitly state read-only, side effects, error behavior, or authentication requirements. With zero annotation coverage, this is a significant transparency gap.

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

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

The description is two sentences, front-loaded with the primary action. It avoids verbosity, but the second sentence 'Roles for permission and governance joins' is somewhat vague and earns its place only partially. Still, it is concise and structured acceptably.

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 five parameters, nested objects, no output schema, and no annotations, the description provides insufficient context. It does not explain what the tool returns, how include or query_json affect behavior, or when to prefer this over list_roles. The schema fills some gaps, but the overall picture remains 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 80%, with meaningful descriptions for id, query_json, path_params, and detail_profile. The description itself adds no parameter-specific meaning beyond 'one role' which is already captured by the required id. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description 'Get one role' clearly states a specific verb and resource, distinguishing it from list_roles by emphasizing singular retrieval. The added phrase 'Roles for permission and governance joins' gives domain context but does not explicitly differentiate from all sibling getters, so it earns a 4 rather than 5.

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

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

The description provides no explicit when-to-use guidance or alternatives. It does not mention when to use get_role versus list_roles or other getters, and the phrase 'Roles for permission and governance joins' is a vague domain hint rather than actionable direction. This is a lack of usage guidance.

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

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

No annotations are provided, so the description must disclose behavioral traits, but it does not. It fails to state that this is a read-only operation, what the return payload contains, or any authentication requirements. The vague phrase 'metadata' does not cover the behavior described in the detail_profile parameter.

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

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

The description is very short and front-loaded, with no filler. However, the second sentence 'Scorecard criteria metadata' adds minimal value and is somewhat redundant with the first, slightly reducing the score.

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

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

With no output schema and no annotations, the description should explain expected return values and usage context. It does not describe the response shape, nor does it differentiate from list operations or other getter tools, leaving the agent 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 80%, so the schema already documents most parameters, including id, query_json, path_params, and detail_profile. The tool description adds no parameter semantics, but since the schema carries the burden, a baseline score of 3 is appropriate.

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

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

The description clearly states 'Get one scorecard_criterion' using a specific verb and resource, distinguishing it from sibling tools such as get_scorecard_pick and get_scorecard_score. The phrase 'Scorecard criteria metadata' adds domain context, making the tool's purpose unmistakable.

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

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

The description provides no guidance on when to use this tool versus alternatives like list_scorecard_criteria. It only states what it does, leaving the agent to infer usage solely from the tool name and the word 'one'.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state whether the operation is read-only, whether authentication or permissions are required, or what the return payload contains. The domain context about feedback completion is informational but not behavioral. The tool name 'get' implies read-only, but the description does not explicitly confirm safety.

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, each earning its place. The first states the action, the second provides domain context. No redundant or filler content, and the key information is front-loaded. Excellent conciseness.

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

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

The tool is a simple get operation with one required parameter, but it has five parameters including generic ones like query_json and path_params. The description does not clarify the purpose of the generic parameters in this context, and there is no output schema, so return values are unaddressed. The domain context helps but is insufficient for a tool with nested objects and a mysterious 'include' parameter. Adequate but with 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 80% (4 of 5 parameters have descriptions), so the schema does most of the work. The tool description adds no parameter-specific meaning. The undocumented 'include' parameter remains unexplained in both schema and description, so the description does not compensate for that gap. This aligns with the baseline score of 3 for high schema coverage.

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

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

The description clearly states the action 'Get one scorecard_pick' with a specific resource, and adds domain context ('Scorecard picks for feedback completion and scorecard coverage analysis') that distinguishes it from sibling tools like get_scorecard_criterion or get_scorecard_score. The verb+resource pattern is explicit and unambiguous.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives such as list_scorecard_picks. It does not mention exclusions, prerequisites, or preferred use cases. The phrase 'Get one' weakly implies singleton retrieval, but no contextual or alternative guidance 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?

No annotations are provided, so the description carries full responsibility. It only describes what scorecard scores are, not behavior such as read-only status, auth needs, or response shape. There is no mention of side effects, pagination, or error conditions, leaving significant transparency gaps.

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

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

The description is two sentences and front-loads the action verb. There is no fluff or redundancy. However, it could have used the second sentence more effectively, but as written it is concise and readable.

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 5 parameters, nested objects, no output schema, and no annotations, the description is too thin. It fails to explain the return format, the meaning of query_json/path_params in practice, or any constraints. For a tool of this complexity, more context is needed to make it usable.

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

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

Schema description coverage is 80% (high), so the baseline is 3. The description adds no additional meaning to the parameters; the schema already documents id, include, query_json, path_params, and detail_profile reasonably well. The description's mention of 'feedback completion and scorecard coverage' is conceptual but not parameter-specific.

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

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

The description states a specific verb and resource ('Get one scorecard_score') and adds clarifying context about what scorecard scores represent ('feedback completion and scorecard coverage'). However, it doesn't explicitly differentiate from sibling tools like get_scorecard_criterion or get_scorecard_pick, though the resource names are distinct.

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

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

Usage is implied by 'Get one', suggesting this is for retrieving a single scorecard_score rather than using list_scorecard_scores. But no explicit when-to-use or alternatives are provided, and there is no guidance on when to choose this over related scorecard 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?

With no annotations, the description carries the full burden of behavioral disclosure. It only states 'Get one stage' and a vague analysis context, but does not describe the response format, security implications, or the fact that detail_profile can return different projections. The description adds minimal behavioral transparency beyond the unambiguous read-only nature implied by 'get.'

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 short, but the second sentence is vague and adds little structure. It is not verbose, yet it lacks a clear layout that front-loads critical information. The first sentence is a concise purpose statement, but the second sentence could be more informative or omitted. Overall, it is acceptable but not optimal.

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 5 parameters, nested objects, no output schema, and no annotations, the description fails to provide sufficient context for correct invocation. It does not explain what a stage is, how to use query_json or path_params, or what the response will look like. The minimal description leaves significant gaps for an agent.

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

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

Schema description coverage is 80%, with four of five parameters having descriptions. The tool description itself adds no parameter semantics, but the schema largely documents id, query_json, path_params, and detail_profile. The include parameter lacks a description, and the description does not compensate, so the baseline of 3 is appropriate.

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

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

The description opens with 'Get one stage,' which clearly identifies the verb (get) and resource (stage), distinguishing it from list_stages and get_stage_type by focusing on a single stage. However, the second sentence is vaguely contextual and doesn't explicitly differentiate it from other get_* tools that also fetch single entities.

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. The phrase 'Stages for pipeline joins and stage conversion analysis' hints at a use case but does not clearly instruct the agent when to choose get_stage over list_stages or other related tools. No exclusions or alternative tool names 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?

No annotations are provided, so the description carries full responsibility for disclosing behavior. It only restates the operation ('Get one stage_type') with no mention of return format, error handling, permissions, or side effects. This fails to provide any behavioral insight beyond the action itself.

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-loaded with the primary action. The second sentence ('Stage types for canonical stage grouping.') adds a small but useful context note. It is concise without being verbose, though the brevity limits substantive guidance.

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

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

The tool has 5 parameters including nested objects, no annotations, and no output schema. The description gives minimal context about what a stage_type is or how it relates to stages. It does not address the purpose of query_json, path_params, or detail_profile, nor does it clarify return expectations. This is insufficient for complete understanding.

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 description does not explain any parameters, but the input schema provides descriptions for 4 of 5 parameters (id, query_json, path_params, detail_profile), which is 80% coverage. This meets the high-coverage threshold, so the baseline score of 3 is appropriate; the description adds no extra semantics.

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

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

The description clearly states the tool gets one stage_type, using the verb 'Get' with the specific resource. It distinguishes from list_stage_types by indicating 'one' and adds context that stage types are for canonical stage grouping. However, it could be more explicit about fetching by ID and how it differs from get_stage.

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 like list_stage_types or get_stage. The description provides no use-case context, prerequisites, or exclusions, leaving the agent without direction for selection.

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 are absent, so the description carries the full burden for behavioral disclosure. It does not mention whether the operation is read-only, what data it returns, the meaning of the 'include' parameter, or any error or permission considerations. The description provides only a bare statement of purpose.

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 very brief, which is concise, but the second sentence 'Teams for ownership and department joins' is vague and adds little value. It is not as under-specified as a pure tautology, but the structure could be improved by removing or clarifying the second sentence.

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 5 parameters, nested objects, no output schema, and no annotations, the description is inadequate. It does not explain the purpose of the 'include', 'query_json', or 'path_params' parameters, nor what a typical response looks like. The schema covers some param semantics but the overall context is 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 coverage is 80%, and the schema already documents most parameters. The description adds no parameter-specific meaning, so it does not go beyond the structured schema. Baseline of 3 is appropriate because the schema handles the heavy lifting.

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

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

The description clearly states 'Get one team', a specific verb and resource, which distinguishes it from list_teams. However, the second sentence 'Teams for ownership and department joins' is ambiguous and does not meaningfully differentiate from other get_* tools like get_team_membership.

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 on when to use this tool versus alternatives such as list_teams or get_team_membership. There is no mention of prerequisites, context, or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Get one team_membership', which mostly restates the name, and offers no details about permissions, response format, pagination, or other side effects. The vague phrase 'hiring-team ownership joins' does not explain 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?

The description is only two sentences and is front-loaded with the core action 'Get one team_membership'. The second sentence adds domain context, though its phrasing is somewhat cryptic. Overall it is concise and avoids unnecessary filler.

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

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

Given there is no output schema and no annotations, the description is insufficiently complete. It does not explain what the response contains, how to use the optional parameters, or how this tool relates to list_team_memberships. A more robust description would include usage guidance and expected return behavior.

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 high (80%), so the baseline is 3 even though the description itself adds no parameter-specific meaning. The schema already documents id, detail_profile, query_json, and path_params, but the description does not clarify the undocumented 'include' parameter or provide additional context beyond the schema.

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

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

The description begins with 'Get one team_membership', which clearly states a specific verb and resource, and explicitly distinguishes this singular getter from the sibling list_team_memberships tool. The added context about 'hiring-team ownership joins' provides useful domain differentiation.

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

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

The description implies this tool is for fetching a single team_membership by ID, but it does not explicitly state when to use it versus the sibling list_team_memberships tool. There is no mention of prerequisites, exclusions, or alternative guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Get' implies a read-only operation, but the description does not state that it is non-mutating, require any permissions, or describe the response format. It adds domain context but no explicit behavioral transparency.

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

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

Two short, front-loaded sentences with no wasted words. The first sentence states the core purpose, and the second adds useful domain context.

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

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

The tool has 5 parameters, nested objects, and no output schema, yet the description doesn't explain return values or the significance of 'operational work queues'. However, the schema partially compensates with detailed parameter descriptions. The description is modest but not inadequate for a simple GET 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 80% (4 of 5 parameters have descriptions), so the schema already explains most parameters. The description adds no parameter-specific meaning. Baseline 3 is appropriate given high schema coverage.

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

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

The description clearly states it retrieves a single todo, with a specific verb and resource. It distinguishes from the sibling list_todos by specifying 'one todo'. Additional context about operational work queues and overdue follow-up clarifies the domain.

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 'Get one todo' implies use when a single todo ID is needed, contrasting with list_todos, but it doesn't explicitly state when to use this versus alternatives or mention any exclusions. No alternative tools are named.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only says 'Get one user' and provides a vague context, with no mention of return format, sensitive field handling, permissions, or other behavioral traits. This is essentially tautological with the tool name.

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

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

The description is concise at two short sentences, with the primary action front-loaded. It wastes no words, though it is so brief that it borders on under-specification rather than effective conciseness.

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

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

Given no output schema and minimal annotations, the description should explain more about what the agent will get back or how the tool behaves. It offers only a vague hint about use cases and omits any guidance on parameters like 'include' or 'query_json', leaving the agent under-informed 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 80% (4 of 5 params have descriptions), so baseline is 3. The description adds no parameter-specific meaning beyond the schema, and the 'include' parameter lacks any schema or description 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 states 'Get one user' with a specific verb and resource, clearly distinguishing it from list_users and other get_* tools. The additional phrase 'Users for recruiter, coordinator, and hiring-team joins' gives context about the resource type, reinforcing its unique 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 implies usage for retrieving users associated with recruiter, coordinator, and hiring-team joins, but does not explicitly state when to use this tool versus alternatives like list_users or get_candidate. No when-not-to-use 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?

No annotations are provided, so the description must disclose behavior. It only states the basic listing action and purpose, omitting any details about pagination, default fields, filtering behavior, authentication requirements, or whether the operation is read-only. 'List' implies a read, but side effects and return semantics are 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?

The description is two short sentences with no wasted words. The first sentence names the operation, and the second gives valuable domain context, making it well-structured and 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 tool with 9 parameters, no output schema, and no annotations, the description is too sparse. It lacks guidance on return values, filter usage, pagination defaults, and parameter interactions, leaving significant gaps that the schema's sparse descriptions do not fill.

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

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

Schema description coverage is only 33%, with most parameters (page, sort, limit, cursor, include, per_page) lacking descriptions. The tool description adds no parameter semantics whatsoever; it does not explain query_json, path_params, or detail_profile beyond what the schema already states.

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

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

The description clearly states a verb ('List') and resource ('answers'), and adds context that these are application answers used for qualification and application-completeness analysis. It distinguishes from the singular get_answer sibling by using the plural list form and specifying the application-answers domain.

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 qualification and application-completeness analysis' provides an implied use case, suggesting when this tool is relevant. However, no explicit comparison to alternatives or exclusion criteria is given, so the agent must infer when to prefer this over other list_* 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?

With no annotations, the description carries the full burden. It only says 'List audit_events' and adds a high-level context sentence. It does not disclose return shape, pagination behavior, required permissions, or any side effects. This is insufficient for a tool with no annotation support.

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 very brief (two sentences) and front-loaded with the verb. However, the first sentence merely restates the tool name, adding no value, and the second sentence provides only vague context. It is concise but arguably under-specified.

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 has 9 parameters, no output schema, and no annotations. The description does not explain what the returned audit event list contains, how pagination works, or what the query_json/detail_profile parameters do. The description is too sparse to be considered complete for this level of complexity.

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

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

The description adds no information about any of the nine parameters. Schema coverage is only 33% (only query_json, path_params, detail_profile have descriptions), and the description does not compensate by mentioning pagination (page, limit, cursor), sorting, or filtering. The agent is left to infer parameter usage from the schema alone, which is incomplete.

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

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

The description clearly states the tool's function as 'List audit_events' and provides context about audit events for governance and change history. It distinguishes from the sibling get_audit_event by using the plural list verb, though it lacks scoping details.

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 on when to use this tool versus alternatives. The description does not mention get_audit_event for single events or any filtering criteria. It is a purely declarative statement without directional context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, yet it only says 'List candidates' and names analysis categories. It does not mention pagination, filtering, output shape, side effects, authentication, or rate limits, leaving the agent blind to key operational 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?

The description is extremely short and front-loaded, with no filler. It earns a 4 rather than a 5 because the second sentence is vague and could be more informative without sacrificing brevity.

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

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

Given 13 parameters, no output schema, and no annotations, this description is severely under-specified. It fails to explain return values, pagination behavior, response structure, or how the documented filters map to the stated analysis use cases, making it inadequate for reliable tool 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 only 54%, and the description adds no parameter-level meaning. It does not explain the relationship between the analysis categories and the query_json, sort, or detail_profile parameters, so the agent cannot infer how to shape a request beyond the bare schema 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 states a clear verb and resource ('List candidates') and adds a use-case qualifier ('for stale-candidate, source-quality, ownership, and follow-up analysis'), which distinguishes it from generic list operations. However, it does not explicitly differentiate from sibling tools like get_candidate or list_users, so it stops short of a 5.

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

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

The phrase 'Candidates for stale-candidate, source-quality, ownership, and follow-up analysis' implies some intended contexts but gives no explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. This is effectively no actionable guidance for an AI agent comparing 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states 'List departments' without explaining pagination, filtering, response format, or any side effects. The schema hints at pagination and filtering parameters, but the description adds no transparency about how the tool behaves.

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 short with no wasted words, but the second 'sentence' is actually a fragment ('Departments for role/function slicing.') and adds minimal value. It is concise but lacks proper structure and substantive content.

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

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

Given the tool has 9 parameters (all optional), no output schema, and no annotations, the description is grossly inadequate. It provides no context on invocation, response shape, default behaviors, or caveats. This is far below the minimum viable description for a tool with this complexity.

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

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

Schema description coverage is only 33%, with only query_json, path_params, and detail_profile described. The description text adds no meaning for page, sort, limit, cursor, include, or per_page. With low schema coverage, the description was expected to compensate, but it 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 'List departments' with a specific verb and resource. The added phrase 'Departments for role/function slicing' provides a slight hint at its purpose but does not explicitly distinguish it from sibling tools like list_divisions or list_roles. Thus it is clear but lacks sibling differentiation.

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

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

The description offers no guidance on when to use this tool versus alternatives. The phrase 'for role/function slicing' vaguely implies a use case, but it does not mention any exclusion criteria or alternative tools. With dozens of sibling list tools, this lack of explicit usage guidance is a significant gap.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It only restates the action and gives a vague purpose, failing to mention pagination, read-only nature, filtering behavior, or return format. This is a significant gap for a tool with no annotation support.

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

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

The description is concise at two sentences, but the first sentence 'List divisions' is redundant with the tool name, and the second adds only minimal context. While not overly verbose, it is under-specified and the structure is not optimally informative.

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

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

With 9 parameters, no output schema, and no annotations, the description is deeply inadequate. It does not address return values, pagination, parameter usage, or operational details, making it nearly useless for an agent to understand the tool's full behavior.

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

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

Schema coverage is only 33% with six parameters lacking descriptions. The description adds no parameter information, leaving the agent to rely entirely on bare schema names like 'page' and 'sort'. It does not compensate for the low coverage at all.

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

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

The description clearly states the tool lists divisions and adds context that divisions are for organization-level slicing. However, it does not differentiate this from sibling list tools like list_departments or list_teams, so it misses full sibling differentiation.

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

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

The phrase 'Divisions for organization-level slicing' implies a usage context, but it does not explicitly state when to use this tool versus alternatives or when not to use it. This is implied usage guidance rather than explicit 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?

No annotations are provided, so the description must carry the full behavioral burden. It only says 'List forms,' which implies a read-only operation, but it does not disclose pagination behavior, result scope, or any side effects. The extra phrase 'application structure metadata' is vague and does not clarify what fields or data will be returned.

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

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

The description is very brief at two sentences, with no padding. However, the second sentence 'Forms and application structure metadata' is somewhat redundant and adds little concrete value, making it slightly less than maximally effective.

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 nine parameters, nested objects, no annotations, and no output schema, the description is vastly under-specified. It does not mention pagination, filtering, return structure, or any usage details, leaving the agent without essential contextual 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?

Schema description coverage is only 33%, with descriptions for only query_json, path_params, and detail_profile in the schema. The description provides no explanation of parameters such as page, sort, limit, cursor, include, or per_page, nor does it clarify how to use them. It fails to compensate for the low schema coverage.

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

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

The description begins with 'List forms,' which clearly states a listing verb and the target resource. The second sentence 'Forms and application structure metadata' adds slight domain context but does not explicitly distinguish from sibling tools like get_form or other list_* 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?

No statements provide guidance on when to use this tool versus alternatives, such as get_form for individual forms or other list tools. It only restates the basic action without context or exclusions.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It only says 'List interviews,' implying a read-only operation, but does not disclose pagination behavior, response format, field restrictions, or any side effects. The existence of the 'detail_profile' parameter is not mentioned, which is a significant behavioral nuance.

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 very concise, consisting of two short sentences with the core action front-loaded. The second sentence adds some purpose context but is vaguely worded. It is appropriately sized, though the second sentence could be more informative without adding length.

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 list tool with 9 parameters and no annotations or output schema, this description is incomplete. It provides no guidance on filtering, pagination, response structure, or when to use this tool instead of alternatives. The schema partially compensates, but the description leaves too much unsaid 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?

The description adds no parameter information. Schema coverage is only 33% (3 of 9 parameters), and the poorly described parameters (page, sort, limit, cursor, include, per_page) are not explained in either the schema or the description. The description's purpose clause does not map to any 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 'List interviews' clearly states the verb and resource. The additional phrase 'Interview records for process load and feedback obligation analysis' provides some context, but it is vague and does not distinguish this tool from sibling tools like 'get_interview' or other list_* tools. It is clear enough for basic identification.

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 on when to use this tool versus alternatives like 'get_interview' or other list tools. The purpose phrase suggests a use case but does not explicitly state when to choose this tool or when to avoid it. There is no mention of alternatives or exclusions.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only says 'List' and names analysis themes. It does not disclose pagination behavior, default detail_profile projection, filter capabilities, or what data is returned. This is a significant gap for a tool with 13 parameters.

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 short and front-loaded with the action in the first sentence. The second sentence adds useful purpose but the first sentence largely repeats the tool name, making it slightly less dense than an ideal description.

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

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

For a list tool with 13 parameters, no output schema, and no annotations, this description is too sparse. It omits return value expectations, pagination/filtering behavior, and details about the 'detail_profile' projection even though the schema only partially covers these. The description is minimally viable but leaves substantial 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 coverage is 54%, so the description should compensate for undocumented parameters, but it does not mention page, sort, limit, cursor, include, or query_json. The 'stage, candidate, source' phrase hints at filtering dimensions but never connects them to query_json or other parameters.

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

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

The description opens with a clear verb+resource construction, 'List job_applications,' and adds analytical purpose with 'stage, candidate, source, and stale-pipeline analysis.' It is distinct from get_job_application and other list_* siblings by naming the resource, though it does not explicitly contrast with those siblings.

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

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

The phrase 'Job applications for stage, candidate, source, and stale-pipeline analysis' gives clear intended use cases but does not state when not to use this tool or mention alternatives. There is no explicit comparison with list_candidates, list_jobs, or get_job_application.

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

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

With no annotations provided, the description carries the full burden for behavioral disclosure. It only restates that the tool lists job offers and mentions 'offer-state hygiene' without explaining what that means, how pagination works, what data is returned, or any side effects. This is minimal and insufficient.

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 brief (two short fragments), but this is under-specification rather than effective conciseness. It omits critical details about parameters and use context, making it unsuitable for a tool with 9 parameters.

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 has moderate complexity (9 parameters, no output schema, no annotations) and the description is wholly inadequate. It does not explain return values, pagination, filter semantics, or the purpose of 'offer-state hygiene'. An AI agent would be unable to invoke this tool correctly with confidence.

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

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

Schema description coverage is only 33%, and the description itself does not explain any of the 9 parameters. It fails to compensate for the low schema coverage, even for non-obvious parameters like query_json, path_params, or detail_profile. The description adds no parameter meaning beyond what is already in the schema.

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

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

The description clearly states 'List job_offers', which identifies the verb and resource. It is distinct from sibling tools like get_job_offer or list_jobs. However, the phrase 'Job offers for offer-state hygiene' is vague and does not add clarity about the specific scope or intent.

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

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

The description offers no guidance on when to use this tool versus alternatives such as get_job_offer or list_job_applications. There are no exclusions, prerequisites, or contextual hints about typical use cases.

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?

There are no annotations, so the description carries the full burden of disclosing behavior. It only says 'List jobs' and does not mention pagination, default page size, filtering semantics, read-only guarantees, or response format. This is minimal disclosure with no added behavioral context beyond the operation name.

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 core action. The second sentence adds purpose without redundancy. No wasted words.

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

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

For a tool with 13 parameters, no output schema, and no annotations, this description is far from complete. It does not mention that results may be paginated or filtered, nor how to request operational vs full profiles, nor what the returned list represents. The schema partially compensates, but the description itself leaves major questions unanswered.

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 description adds no parameter-level meaning. While the schema has descriptions for roughly half the parameters (e.g., updated_after, detail_profile), common parameters like page, sort, limit, cursor, include, and per_page are undocumented and the description does not clarify them. Given 13 parameters and 54% schema coverage, the absence of any param guidance in the description is a notable 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 'List jobs' is a specific verb+resource statement that unambiguously identifies the operation. The added phrase 'Jobs for open-role inventory and hiring-team analysis' supplies useful context while naturally distinguishing this tool from sibling tools like get_job (single record) and list_candidates (different 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 phrase 'for open-role inventory and hiring-team analysis' implies when the tool is useful, but there is no explicit guidance about alternatives, such as using get_job for a single job, or when not to use this tool. No exclusions or prerequisites are stated.

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

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

No annotations are provided, so the description carries the full burden. It only says 'List locations' and a purpose, but does not disclose pagination behavior, response format, permission requirements, or rate limits. This is a significant gap for a list tool.

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

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

The description is very brief and not verbose, but the first sentence 'List locations' is nearly redundant with the tool name. The second sentence adds some context but remains vague. It's concise yet under-specified.

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 9 parameters, nested objects, no output schema, and no annotations, this description is inadequate. It doesn't cover pagination, filtering, or the distinction between operational and full detail profiles, making it difficult for an agent to invoke correctly.

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

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

Schema description coverage is only 33%, and the tool description adds no parameter information. It doesn't mention pagination, filtering, or the detail_profile option, leaving many parameters (page, limit, cursor, sort, include, per_page, query_json) 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 'List' and resource 'locations', and adds a brief purpose: 'Locations for office/region slicing.' This is specific enough to understand the tool's function, though it doesn't explicitly differentiate from other list_* sibling tools beyond the resource name.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives like get_location or other list_* tools. The phrase 'for office/region slicing' gives a vague use case but doesn't establish conditions, 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?

No annotations are provided, so the description carries full behavioral disclosure burden. It only says 'List notes' and gives use-case context, but does not disclose pagination behavior, filtering capabilities, authentication needs, or response structure. It implies a read-only operation but offers no meaningful behavioral insight.

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 very short and front-loaded with the verb, but the second sentence is vague and adds little value. It is concise but under-specified, not earning the full 5 because it omits essential context while remaining brief.

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 9 parameters, nested objects, and no output schema, the description is severely incomplete. It does not mention what notes are, how listing works, or any control flow. The use-case context is the only value, leaving many gaps for an agent to operate correctly.

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

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

Schema description coverage is only 33%, and the description adds no parameter information whatsoever. It does not explain page, sort, limit, cursor, include, per_page, or query_json semantics. With low coverage, the description should compensate but fails to do so.

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 'List notes' with a specific verb and resource. The second sentence adds purpose context (activity hygiene, follow-up, recruiter handoff analysis) but does not explicitly distinguish this from other list_* sibling tools, so it lacks sibling differentiation.

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

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

The description provides clear context for when to use the tool (for activity hygiene, follow-up context, recruiter handoff analysis) but does not mention alternatives or exclusions. This aligns with 'clear context, no exclusions'.

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

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

With no annotations provided, the description carries the full burden for behavioral disclosure, but it merely says 'List referrals' without mentioning pagination behavior, response format, auth requirements, or any side effects. It is not misleading, but it provides very little beyond the name.

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 very short and free of fluff, with two concise sentences. It is appropriately sized for a simple list operation, though it could be slightly more informative without losing conciseness.

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

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

Given the complexity of the tool (9 parameters, nested objects, no output schema, no annotations), the description is severely underspecified. It does not explain return values, pagination, filtering behavior, or the exact scope of 'referrals', making it inadequate for an AI agent to confidently invoke the tool in varied contexts.

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

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

The input schema has 9 parameters but only 33% have descriptions. The tool description adds no parameter-level guidance, and the low schema coverage means the description should compensate but does not. While some parameter names are self-explanatory, the description adds no meaning beyond the schema.

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

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

The description uses the clear verb 'List' with the resource 'referrals', and adds a practical use case ('referral SLA and source-quality investigations'). It distinguishes from the singular sibling tool 'get_referral' by being plural, though it lacks explicit scope or filter information.

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 'Referrals for referral SLA and source-quality investigations' implies that this tool is for listing referrals in those investigative contexts. However, it does not explicitly state when to use this tool versus alternatives like get_referral or list_candidates, nor does it provide any exclusions.

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

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

With no annotations, the description carries the full burden of disclosing behavioral traits, but it reveals nothing about pagination, filtering, response shape, authentication, or side effects. The phrase 'for disposition hygiene' does not explain the operational behavior of the tool.

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

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

The description is very short, but this is under-specification rather than effective conciseness. The second sentence 'Reject reasons for disposition hygiene' adds little value and does not earn its place, while the first sentence merely repeats 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?

Given the absence of annotations, an output schema, and only 33% schema coverage, the description is critically incomplete. It does not explain the domain concept of reject reasons, the meaning of 'disposition hygiene', or the purpose of the 9 parameters, making it insufficient for correct tool 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 only 33% (3 of 9 parameters have descriptions), and the description adds no parameter information whatsoever. It fails to compensate for the undocumented page, sort, limit, cursor, include, and per_page parameters, leaving the agent without guidance on how to use 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 'List reject_reasons' is essentially a tautology of the tool name, restating the resource without adding scope or context. The phrase 'Reject reasons for disposition hygiene' is vague jargon that does not clarify what the tool actually does or how it differs from get_reject_reason.

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 usage guidance is provided. The description does not indicate when to use this tool versus get_reject_reason or other list_* siblings, nor does it mention any prerequisites, exclusions, or typical scenarios beyond the cryptic 'disposition hygiene' phrase.

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?

There are no annotations, so the description is the sole source of behavioral information. It only says 'List requisitions' without detailing pagination, return format, permissions, or side effects. This is a significant gap for a list operation.

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

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

The description is very brief, consisting of two sentences. The first is a direct definition and the second adds domain context, with no fluff. It is front-loaded, though it sacrifices substance for brevity.

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

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

With 9 parameters, no output schema, and no annotations, the description is insufficient to fully guide an agent. The lack of information about pagination, filtering, and response structure makes it incomplete for a list 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 coverage is only 33% (3 of 9 parameters have descriptions), and the description adds no parameter information. It does not explain page, sort, limit, cursor, include, per_page, or query_json, leaving the agent to infer 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 clearly states 'List requisitions' with a specific verb and resource, and adds context by noting requisitions are for headcount and approval-flow investigations. This distinguishes it from related tools like get_requisition, though it doesn't explicitly differentiate from other list_* 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 provides no guidance on when to use this tool versus alternatives. It doesn't mention when to use get_requisition for individual records or other list tools, and there are no exclusions or context cues.

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

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

With no annotations, the description carries the full burden, but it only states the resource and vague domain context. It does not disclose pagination, filtering, sorting, return format, or any side effects, which are key behavioral traits for a list operation.

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

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

The description is two short sentences with no redundancy. The first sentence is direct, and the second adds a small domain context. It is efficient, though the brevity borders on under-specification.

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 nine parameters, a nested query object, no output schema, and no annotations, this description is grossly inadequate. It fails to explain how to use the listing, what results are returned, or any constraints, leaving the agent without essential 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?

The description adds zero parameter semantics. The schema documents only a few parameters (query_json, path_params, detail_profile), leaving page, sort, limit, cursor, include, and per_page without descriptions. The low schema coverage (33%) makes this gap critical, and the description does nothing to compensate.

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 'requisition_step_verdicts', and adds context about approval verdicts for headcount workflow bottlenecks. It distinguishes from the sibling get_requisition_step_verdict via the list verb, though it doesn't explicitly compare.

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 on when to use this tool versus alternatives. There is no mention of intended use cases, prerequisites, or exclusions, leaving the agent to infer usage solely from the name.

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

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

With no annotations, the description carries the full transparency burden. 'List' implies a read-only operation, but nothing is disclosed about pagination, permissions, response format, or filter behavior. The description adds minimal behavioral context.

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

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

The description is very short (two sentences), but the second sentence 'Roles for permission and governance joins' is vague and does not earn its place. It could be considered efficient, but not fully purposeful.

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?

Without an output schema or annotations, and with 9 parameters, the description provides far too little context about what a caller should expect. It does not explain return shape, pagination, or typical use cases, making it insufficient for practical invocation.

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

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

Schema coverage is only 33%, leaving 6 of 9 parameters undocumented. The description name-drops no parameters and provides no hints about how to use page, sort, limit, cursor, include, per_page, or other fields. It completely fails to compensate for the schema gaps.

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 ('roles'), and adds a hint about their intended use ('permission and governance joins'). However, it lacks scope details such as pagination or filtering, and does not explicitly distinguish from get_role.

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 like get_role or other list_* endpoints. The description merely states what it does, without any exclusions, prerequisites, or context.

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

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

No annotations are provided, placing the burden on the description, which discloses nothing about pagination, filtering, auth, return shape, or side effects. The two-sentence description is purely definitional.

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 short but not effectively front-loaded—it merely repeats the name and adds a vague noun phrase. Every sentence is low-value, making it under-specified rather than 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?

Given 9 parameters, a nested query_json, no output schema, and no annotations, the description provides almost no operational context. It fails to mention pagination behavior, filter semantics, or what fields are returned.

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

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

With schema description coverage at only 33% and 9 parameters, the tool description adds no parameter context (e.g., what 'page', 'sort', 'cursor', or 'include' do). The description does not compensate for the sparse 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 'List scorecard_criteria. Scorecard criteria metadata.' restates the tool name without clarifying what distinguishes this from sibling list tools like list_scorecard_scores or get_scorecard_criterion. The term 'metadata' is vague and doesn't explain the resource or 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?

No guidance on when to use this tool vs alternatives such as get_scorecard_criterion or list_scorecard_scores. The description provides no context for selection.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It does not mention pagination, default limits, filtering options, or the detail_profile behavior that controls whether personal fields are returned, leaving significant behavioral traits undisclosed.

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 short and front-loaded with the action. The second sentence adds purpose but is somewhat vague; however, it avoids redundancy and 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 tool with 9 parameters, no output schema, and no annotations, the description is too sparse. It fails to explain pagination, filtering, or the significance of detail_profile, and it doesn't clarify the concept of a 'scorecard pick' beyond the name.

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 only 33% schema description coverage, the description needed to compensate, but it does not explain any of the 9 parameters. It only says 'Scorecard picks for feedback completion...' which adds no parameter-level meaning beyond the schema.

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

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

The description uses the specific verb 'List' with the resource 'scorecard_picks', making the action clear. It also provides a purpose ('feedback completion and scorecard coverage analysis'), which distinguishes it slightly from generic list tools, though it doesn't explicitly differentiate from sibling tools like list_scorecard_scores.

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

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

The second sentence implies when to use the tool ('for feedback completion and scorecard coverage analysis'), but it does not provide explicit guidance on when to use alternatives such as get_scorecard_pick or list_scorecard_scores. No exclusions or alternative recommendations are given.

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

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

With no annotations, the description must disclose behavioral traits, but it only defines the resource. It does not mention return format, pagination behavior, read-only status, or any constraints. This is as minimal as the 'process' tautology example.

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 short, but the first sentence is a tautology and the second is a vague definition. It is not verbose, yet it also doesn't front-load substantive information that earns its place.

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

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

Given the 9 parameters, no output schema, and no annotations, the description is significantly inadequate. It lacks essential context about return values, supported filters, and operational behavior, making it hard for an agent to use correctly.

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

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

Schema coverage is only 33%, and the description adds no parameter explanations. It fails to compensate for the low coverage, leaving most parameters (page, sort, limit, cursor, include, per_page) undefined.

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 scorecard_scores' and adds a clarifying phrase 'Scorecard scores for feedback completion and scorecard coverage.' However, it does not distinguish this from sibling tools like get_scorecard_score or list_scorecard_criteria, so it lacks explicit differentiation.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of pagination, filtering, or when to prefer this list endpoint over getting a single scorecard score.

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