Factorial ATS Ops Control Plane

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 disclosing behavior. It mentions using the buyer's saved connection details but does not disclose that this tool can execute arbitrary HTTP methods (including mutations), that non-GET requests require confirmation, or that dry-run mode exists. The potential for side effects is not surfaced at all.

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

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

The description is a single concise sentence that is front-loaded with the tool's purpose. No filler or redundancy.

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

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

For a generic raw API tool with 7 parameters, no output schema, and no annotations, a one-sentence description is insufficient. It does not explain how to construct a request, what to expect in the response, or what safety mechanisms exist. The rich schema partially compensates, but the description alone leaves significant 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?

The input schema already provides detailed descriptions for 86% of parameters, including path, method, confirm, dry_run, body_json, query_json, and headers_json. The description adds no additional parameter semantics, but given the high schema coverage 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 identifies the tool as a generic API request tool for any documented endpoint in the Factorial ATS Ops Control Plane. This distinguishes it from the many specific sibling tools that target individual resources/operations. The verb 'use' is somewhat generic but combined with the resource description it is unambiguous.

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

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

The description implies this tool is for making requests to any documented endpoint, but it does not explicitly state when to prefer this over the dedicated sibling tools. There is no mention of fallback scenarios or exclusions. The 'documented' constraint offers some guidance but no explicit alternatives 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?

With no annotations provided, the description carries full burden for behavioral disclosure, but it only states 'Create a Factorial ATS application.' It does not mention that creation may be a live mutation, require confirmation (confirm parameter), or support dry-run previews (dry_run parameter). This is a significant transparency gap for a write operation.

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

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

The description is a single clear sentence with no wasted words. It is appropriately front-loaded and easy to read, though it might be too sparse for the complexity of the tool, earning a 4 rather than 5.

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 6 parameters, nested objects, no annotations, and no output schema, the one-line description is insufficient. It does not explain the live-change confirmation flow (confirm/dry_run), what an 'application' entails in Factorial ATS, or any limitations. The description leaves the agent without enough context to safely invoke the mutation.

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 covers 100% of parameters with descriptions, so the baseline is 3. The tool description adds no additional meaning about how the parameters like body_json or query_json should be used for creating an application, but it doesn't need to because the schema is comprehensive.

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 'Create a Factorial ATS application.' uses a specific verb ('Create') and a specific resource ('Factorial ATS application'), clearly distinguishing it from siblings like update_application or get_application. It fully states what the tool does.

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

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

There is no guidance on when to use this tool versus alternatives or any prerequisites. The description is purely declarative and does not mention context such as whether to use dry_run first or how it relates to other application 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?

The description only states 'Create' and gives no insight into the confirm/dry_run workflow, potential side effects, or required permissions. With no annotations, the description carries the full burden but fails to disclose these behavioral aspects.

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

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

The description is a single concise sentence, front-loaded with the action and resource. It avoids filler, though it could be slightly more informative without hurting 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 description lacks essential context about the request body, confirmation flags, or expected outcomes. With no output schema or annotations, this is insufficient for a tool with a generic API wrapper 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?

The input schema has 100% description coverage for all parameters, so the baseline of 3 applies. The tool description itself adds no parameter-specific 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 a specific verb ('Create') and a resource ('a Factorial ATS candidate'), clearly distinguishing it from sibling tools such as update_candidate or 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?

There is no guidance on when to use this tool versus alternatives. It does not mention that this tool is for adding a new candidate, nor does it exclude cases like checking for duplicates.

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, and the description only states the action without disclosing side effects, required confirmations, or permission needs. It does not mention that this is a live mutation or how dry_run/confirm behave.

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 redundancy, but given the tool's complexity (6 generic parameters), the extreme brevity omits critical usage context.

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

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

With no annotations, no output schema, and a generic parameter schema, the description does not explain return value, required fields, or how to use dry_run/confirm for this specific write operation.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds no parameter-specific meaning beyond the generic schema descriptions for body_json, path_params, etc.

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' and identifies the exact resource 'Factorial ATS feedback record', clearly distinguishing it from sibling tools like create_application or create_candidate.

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 update_feedback or list_feedbacks, nor are prerequisites or scenarios 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, so the description must disclose behavioral traits. It simply says 'Create', which implies a mutating action, but it fails to mention the confirm/dry_run mechanism, required confirmation for live changes, or any side effects. This is a significant gap for a write operation.

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

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

The description is a single concise sentence with zero wasted words. However, it is so brief that it skips important contextual information, so it doesn't fully earn its place despite being well-structured.

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

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

For a create operation with six parameters and no output schema, the description is severely under-specified. It doesn't explain what a 'Factorial ATS job posting' entails, what fields are typically required, or what the response will be. The generic schema parameters (body_json, query_json) need more guidance.

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

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

Schema coverage is 100%, so the schema fully describes all six parameters. The description adds no parameter-specific value, but the baseline of 3 is appropriate since the schema carries the burden.

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

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

The description clearly states the action ('Create') and the resource ('a Factorial ATS job posting'), which unambiguously distinguishes it from sibling update/get/list tools. It is specific and actionable.

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 update_job_posting or create_application. Usage must be entirely inferred from the name, with no explicit 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 must disclose behavioral traits. It only implies a write operation ('create') but does not mention that this is a live change requiring confirmation, potential side effects, permissions, or that it follows a dry_run/confirm pattern. This is minimal disclosure.

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 words. It efficiently states the core purpose, and 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 6 parameters, nested objects, no output schema, and no annotations, yet the description is only one sentence. It fails to explain what a webhook subscription is, when to create one, what the return value looks like, or any operational context, making it severely 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?

The schema descriptions cover 100% of parameters, so the baseline of 3 is appropriate. The tool description adds no parameter-specific meaning beyond what the schema already provides.

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' and the resource 'Factorial API webhook subscription', clearly distinguishing it from sibling tools like update_webhook_subscription, delete_webhook_subscription, and get_webhook_subscription. It unambiguously states the operation and target.

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

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

The description gives no guidance on when to use this tool, prerequisites, or how it relates to alternatives. It does not mention when to prefer create over update, or any conditions required before creating a subscription.

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 only says 'delete' without disclosing that the action is irreversible, whether confirmation is needed, or the impact on webhook delivery. The schema includes confirm and dry_run parameters that imply safety behavior, but the description does not reference them.

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

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

The description is one concise sentence that directly states the tool's purpose. It is front-loaded and contains no filler, earning a high score for 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?

For a mutating tool with no output schema and no annotations, the description is incomplete. It doesn't explain what happens after deletion, how to specify which subscription to delete (e.g., via path_params), or any side effects, leaving critical operational details unaddressed.

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

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

All 6 parameters have descriptions in the schema (100% coverage), so the baseline is 3. The description adds no parameter-specific meaning beyond that, but this is acceptable given the schema's completeness.

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

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

The description clearly states the action 'Delete' and the resource 'Factorial API webhook subscription', which distinguishes it from sibling tools like create, get, list, and update. It 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?

No guidance is provided about when to use this tool versus alternatives such as api_request or update_webhook_subscription. There is no mention of prerequisites, exclusions, or context in which this delete is 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?

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It only states 'Get one answer' with no mention of safety, read-only nature, response format, error handling, or side effects. This is a significant gap for a tool with nested parameters and no output 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 very concise—two short sentences with no filler words. Both sentences contribute meaning (what it does and what domain it applies to). However, the extreme brevity leaves out critical usage and behavior details, preventing a 5.

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 woefully incomplete. It does not explain return values, when to use it, how parameters interplay, or distinguish from list_answers. The description provides only a minimal hint of purpose, leaving the agent under-informed 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 80% (high), so the baseline is 3. The tool description itself adds no parameter-level meaning beyond what the schema provides. The schema already covers most parameters, though 'include' lacks a description, and the tool description does not fill that 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 answer,' specifying a single resource retrieval. It adds context with 'Application answers for qualification and application-completeness analysis,' clarifying the domain. However, it does not explicitly differentiate from sibling tools like list_answers or get_application, 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 description gives no guidance on when to use this tool versus alternatives. It neither names sibling tools nor provides contextual triggers, leaving the agent without direction on choosing get_answer over list_answers 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 present, so the description must disclose behavior. It only states 'Get one application,' implying a read operation, but it does not mention error handling, response format, permissions, or any side effects. The phrase 'stale pipeline analysis' is too vague to count as meaningful behavioral disclosure.

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 includes a second sentence that is grammatically incomplete and confusing: 'Applications for candidate/job/phase state and stale pipeline analysis.' This adds clutter without clear value, detracting from the otherwise clear first sentence. A more focused one-sentence description would be better.

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, no output schema, and no annotations, so the description needs to provide more context about return values, usage limitations, or when to use the tool. It only says 'Get one application,' which is inadequate for a tool that supports nested query_json and path placeholders. The vague second sentence does not fill this gap.

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

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

The schema provides descriptions for 4 of 5 parameters (id, query_json, path_params, detail_profile), leaving only 'include' undocumented. The description adds no parameter information, so it neither compensates for the gap nor contradicts the schema. With 80% schema coverage, 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 action and resource: 'Get one application.' This distinguishes it from list_applications (plural) and get_application_phase (phase-specific). However, the second sentence about 'candidate/job/phase state and stale pipeline analysis' is vague and could be misinterpreted as the tool's purpose rather than a use case for the data.

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 description does not mention scenarios like 'use for a specific application ID' or contrast with list_applications. The singular 'one' implies a use case, but no direct comparison or exclusions are provided.

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

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

No annotations are provided, so the description carries the full burden of explaining behavior, but it only says 'Get one application_phase' with no mention of return format, auth requirements, error behavior, or side effects. This is a read operation, but the description adds no behavioral detail beyond the obvious implication 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 very concise, consisting of two short sentences, with the key action front-loaded. It avoids unnecessary filler, though the second sentence adds limited context and could be more informative without making the description longer.

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 annotations and no output schema, the description is too sparse to be fully complete. It does not explain what the returned application_phase contains, how the detail_profile affects the response, or any operational nuances, leaving the agent with significant gaps in understanding for a tool with 5 parameters and nested objects.

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%, with descriptions for id, query_json, path_params, and detail_profile, so the schema already documents most parameters. The description itself adds no parameter-specific meaning, keeping the score at the baseline 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 'Get one application_phase', identifying the exact verb, resource, and singular scope, which distinguishes it from siblings like list_application_phases. The additional context 'Application phases for ATS funnel state' clarifies the domain 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?

No guidance is provided on when to use this tool versus alternatives such as list_application_phases or get_application. The description only states what the tool does, not the appropriate 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 for behavioral disclosure. It only states the basic 'get' operation and lists use cases, without mentioning read-only nature, error handling, response format, or the impact of the detail_profile parameter. This is a significant gap for a tool with zero 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 short and front-loaded with the core action, but the second sentence is vague and not clearly informative ('Candidates for stale-candidate...'). It could be considered waste or confusion, so it does not achieve the zero-waste standard of a 4 or 5.

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, no output schema, and no annotations. The description fails to specify what the response contains, how detail_profile alters the data shape, or how errors are handled. This incomplete context makes it difficult for an agent to use the tool effectively without additional information.

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

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

The input schema covers 80% of parameters with descriptions for id, query_json, path_params, and detail_profile. The description itself adds no parameter-specific information, relying entirely on the schema. Given the high schema coverage, a neutral 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 'Get one candidate,' which is a specific verb+resource and distinguishes from plural list tools like list_candidates. However, it does not explicitly contrast with sibling get tools (e.g., get_candidate_source) or elaborate on how it differs beyond the name, so it's clear but not fully differentiated.

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 hints at use cases ('stale-candidate, source-quality, owner, and follow-up analysis'), implying when this tool might be relevant. But it lacks explicit guidance on when to use it versus alternatives like list_candidates or get_candidate_source, and offers no exclusions, so usage context is implied rather than explicit.

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

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

No annotations are provided, so the description carries the full burden. It does not mention read-only behavior, permissions, return format, or side effects. The only behavioral detail (detail_profile's projection behavior) resides in the schema, not the tool description, leaving 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 brief sentences, front-loaded with the core action ('Get one candidate_source') and a short domain note. Every word earns its place with no redundancy or fluff.

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

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

With no annotations and no output schema, the description should explain the tool's return behavior and any critical nuances. It does not mention what the response contains, how to handle the ambiguous 'include' or 'path_params' parameters, or any filtering/auth requirements. The schema provides some parameter documentation, but the overall context remains incomplete 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 80%, so the baseline is 3. The description adds no parameter-specific meaning; however, the schema already covers id, query_json, path_params, and detail_profile. The 'include' parameter lacks schema description, and the tool description does not clarify it, but the high overall coverage keeps this at baseline.

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 candidate_source', identifying the verb and resource, and distinguishes from the sibling list_candidate_sources by specifying 'one'. The added context about candidate sources ('source-quality and referral-like slicing') provides some domain meaning, though it 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 description implies usage for retrieving a single candidate_source, but does not explicitly state when to use this tool versus alternatives like list_candidate_sources. There are no exclusions or alternative references, so guidance is only implied through 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. The word 'Show' implies a read-only action, but the description does not disclose what the returned coverage data looks like, whether it includes availability filters, or any other behavioral details.

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

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

The description is a single, front-loaded sentence with no unnecessary words. It is appropriately concise for a zero-parameter tool, though the content could be more explicit.

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?

Even for a simple tool, the description is incomplete—it gives a high-level hint but not enough to understand the actual output or purpose. The absence of an output schema and detailed annotations makes this more problematic, leaving the agent uncertain about what 'coverage' means in practice.

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

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

The tool has zero parameters (empty schema), so there is nothing to document. The description doesn't need to add parameter meaning, and the baseline for 0 params is 4.

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

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

The description identifies a clear verb ('Show') and a resource ('Factorial ATS Ops Control Plane question, reporting, and action coverage'), which distinguishes it from sibling CRUD tools. However, the exact meaning of 'coverage' is ambiguous—it could mean a list, a status report, or a capabilities matrix.

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. It is clearly a meta-tool given the siblings, but the description doesn't state that it should be used to discover capabilities before calling other 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 restates the action and provides domain context; it does not mention response format, error behavior, the effect of detail_profile on the returned data, or any other operational details.

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

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

Two short sentences with the core action front-loaded. The first sentence is somewhat redundant with the tool name, but the second sentence adds useful context. Overall it is concise and free of fluff.

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

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

With no annotations and no output schema, the description is too sparse. It does not cover usage trade-offs, return values, or the significant behavioral nuance of detail_profile, leaving the agent under-informed for correct invocation beyond what the schema provides.

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%, including detailed descriptions for id, query_json, path_params, and detail_profile. The description itself adds no parameter semantics, so the baseline of 3 is appropriate; the uncovered 'include' parameter is not addressed.

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?

Clearly states 'Get one evaluation_form,' identifying the exact resource and scope (singular). The second sentence explains the resource's domain purpose, distinguishing it from generic feedback retrieval and sibling tools like list_evaluation_forms.

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 through the domain cue 'Evaluation forms for feedback structure and coverage analysis,' but it does not explicitly state when to use this tool versus alternatives such as get_feedback or list_evaluation_forms. No exclusions or alternative tools 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action and link relationships, but does not disclose return format, error handling, authorization requirements, or the effect of the detailed profile options. 'Get' implies read-only, but no explicit behavioral traits are described beyond that.

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. It front-loads the primary action ('Get one feedback') and then provides a concise relational context. 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?

While the description gives the essential purpose and relationships, it omits any guidance on when to use the additional query parameters (include, query_json, path_params) or the detail_profile options. With no output schema, the description minimally sets context but leaves the tool's full capability to be inferred from the schema. It is adequate for a simple get but lacks completeness for a tool with 5 parameters.

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 description itself adds no parameter information, so the schema already provides the needed semantics for most parameters. The base score of 3 applies because the schema does the heavy lifting, and the description does not compensate for the missing 'include' parameter description.

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

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

The description clearly states 'Get one feedback' with a specific verb and resource, immediately distinguishing it from list_feedbacks by emphasizing 'one'. It also adds context about feedback being linked to candidates, applications, and phases, which further clarifies the tool's 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 singular 'one' implies use when a single feedback record is needed, but the description does not explicitly state when to use this over list_feedbacks or other get_* tools. There is no mention of alternatives or exclusions, leaving the usage context implied rather than explicit.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Get,' which implies a read-only operation, but it does not mention permissions, return format, error behavior, or any side effects. For a tool with such minimal disclosure, this is a significant gap.

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

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

The description is exactly two sentences, with the core verb and resource in the first sentence. The second sentence adds a domain-specific reason without fluff. Every word earns its place, and the most important information is front-loaded.

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

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

The tool has 5 parameters, nested objects, and no output schema or annotations, yet the description is extremely sparse. It does not explain return values, the purpose of query_json, path_params, or detail_profile, nor when to choose this over list_hiring_stages. The detail_profile parameter, which controls response projection, is completely unaddressed.

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

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

Schema description coverage is 80% (4 of 5 parameters), so the schema already documents most parameters. The description adds no parameter-level detail and does not compensate for the undocumented 'include' parameter. Given the high schema coverage, a baseline of 3 is appropriate.

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

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

The description opens with 'Get one hiring_stage,' which clearly states the action (retrieving a single resource) and the resource. It differentiates from the sibling list_hiring_stages by emphasizing the singular nature, and the additional note about 'canonical pipeline joins' gives useful 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?

Usage is implied through the singular 'one' as opposed to the list sibling, but there is no explicit mention of alternatives or exclusions. The phrase 'Hiring stages for canonical pipeline joins' hints at a use case, but does not clearly state when to use this tool versus list_hiring_stages.

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 says 'Get one job_posting' and a vague phrase about job postings. It doesn't mention return structure, pagination, authentication, or the impact of the detail_profile parameter on personal fields, which 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 short and front-loaded with the core verb, but the second sentence is vague filler that doesn't earn its place. It's concise but not effectively structured to convey useful 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 5 parameters including nested objects (query_json, path_params) and a sophisticated detail_profile enum that controls whether personal fields are omitted. The description provides almost no context about these behaviors, response format, or filtering capabilities, making it inadequate for practical use without 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%, so the baseline is 3. The description adds no parameter-specific meaning beyond what the schema provides; the phrase 'job status, team, location, and open-role inventory' does not clearly map to any parameter like query_json or include.

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 says 'Get one job_posting', identifying the verb and resource. However, it doesn't differentiate from sibling get_* tools, and the second sentence 'Job postings for job status, team, location, and open-role inventory' is vague and adds little clarity about the tool's specific 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?

No guidance is provided on when to use this tool versus alternatives like list_job_postings or other get_* tools. No prerequisites, exclusions, or alternative tool mentions are present.

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 message' and gives context about ATS messages, but does not mention return format, potential errors, permissions, or any side effects. This is minimal for a read 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 two short sentences, front-loaded with the primary action, and contains no redundant wording. It is appropriately sized for a simple get operation, though the second sentence is slightly cryptic.

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, an enum, and no output schema, the description is too sparse to give an agent sufficient context. It fails to explain the purpose of the include, query_json, or detail_profile parameters, or what the response contains, making it incomplete for complex usage.

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

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

The description makes no mention of parameters, but the input schema already provides descriptions for 80% of parameters (id, query_json, path_params, detail_profile). The description adds no additional semantic value beyond what the schema already documents, so 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 message' with a specific verb and resource, and the ATS context distinguishes it from list_messages. It communicates the tool's scope 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 activity hygiene and follow-up context but does not explicitly say when to use this tool over alternatives like list_messages. 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 the full burden of behavioral context. It states only 'Get one question' and a vague domain note, failing to disclose read-only semantics, response format, error behavior, or any side effects. The detail_profile parameter in the schema hints at data sensitivity, but the description itself adds little.

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

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

The description is two sentences with no filler, front-loading the core action. It is appropriately concise, though the second sentence is somewhat cryptic and could be clearer.

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, no output schema, and no annotations, the description is too sparse. It does not mention what the response contains, how query_json or path_params are used, or when the detail_profile option matters. The overall context is insufficient for reliable 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%, so most parameters are already documented in the schema. The description adds no extra meaning to id, include, query_json, path_params, or detail_profile, so it falls at the baseline for schema-covered 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 uses a specific verb ('Get') and resource ('one question'), clearly distinguishing it from sibling tools like list_questions and get_answer. The second sentence adds domain context about application completeness metadata, making the purpose unambiguous.

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

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

No explicit guidance on when to use this tool versus alternatives. The name and 'Get one question' imply retrieval by ID, but there is no mention of exclusions or when to prefer get_question over list_questions.

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

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

Annotations are absent, so the description carries the full burden. It only states that the tool fetches a rejection_reason and gives a vague domain reference, but it does not describe the response shape, potential side effects (or lack thereof), required permissions, or any other behavioral characteristics. A 'get' verb implicitly suggests read-only, but the agent is given no concrete behavioral detail.

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 the primary verb and resource front-loaded in the first four words. The second sentence adds a slight domain context but is vague and arguably unnecessary. It earns a high score for brevity, though not a perfect one due to the somewhat unclear 'disposition hygiene' phrase.

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 five parameters, nested objects, and no output schema, the description offers almost no contextual completeness. It fails to explain what a rejection_reason is, what data will be returned, or how to effectively use the parameters. The agent is left to infer nearly everything from the schema alone, which is insufficient 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?

The schema already documents the id, query_json, path_params, and detail_profile parameters with meaningful descriptions, and schema coverage is 80%. The description itself adds no parameter-level context, so it neither enhances nor detracts. A baseline score 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 starts with 'Get one rejection_reason', a clear verb+resource pairing that unambiguously denotes a singular read operation. It also distinguishes itself from the sibling list_rejection_reasons by explicitly stating 'one' rather than a collection, and adds a domain hint ('Rejection reasons for disposition hygiene').

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 usage guidance is provided. The phrase 'Get one' implies a single-item lookup, but there is no mention of when to prefer this over list_rejection_reasons or any other alternative. The description lacks both context and 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. It only restates the operation ('Get one') and provides domain context, but does not explicitly confirm this is a read-only operation, mention returned data shape, or discuss any side effects, rate limits, or authorization requirements. This is a notable gap because the description adds no behavioral value 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 extremely concise: two short sentences that immediately state the action and resource, followed by purpose context. Every word earns its place, and the key information is front-loaded in the first 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?

The description is minimal but minimally viable for a simple get operation. It does not explain the behavior of the detail_profile parameter, the difference between operational and full projections, or what the return value contains. With no output schema and no annotations, the description could provide more context, but the high schema coverage partially compensates. The description is not fully complete but is adequate for a straightforward retrieval 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 high (80% of parameters have descriptions), so the baseline is 3. The tool description itself adds no parameter-specific meaning beyond what the schema already provides. The mention of incremental sync and delivery setup is contextual but does not enrich understanding of the individual parameters like include, query_json, or detail_profile.

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') and the resource ('webhook_subscription'), and adds domain context about incremental sync and delivery setup. It distinguishes this from listing all subscriptions (list_webhook_subscriptions) and from create/update/delete operations, making the purpose unambiguous.

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

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

The description implies usage by saying 'Get one' and mentions the domain context, but there is no explicit guidance on when to use this tool versus list_webhook_subscriptions or any mention of prerequisites or alternatives. The context about sync/delivery setup partially suggests intent, but it does not clearly say when to choose this over 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?

With no annotations, the description carries the full burden of behavioral disclosure, yet it only states that answers are listed for analysis. It omits details such as pagination behavior, filtering possibilities, read-only nature, or any side effects, leaving the agent with insufficient 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 and front-loaded, which is good, but the second sentence is somewhat vague and does not add much actionable information. It is appropriately sized for the tool's simplicity but under-specifies given the number of 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 9 parameters, no output schema, and no annotations. The description offers only a minimal statement of purpose and provides no information about return values, pagination, filters, or any behavioral contract. This is severely inadequate for an agent to invoke the tool correctly.

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

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

The description provides no parameter-specific information. The schema covers only 33% of parameters (with descriptions for query_json and detail_profile), and the description adds no detail about the many unannotated parameters like page, sort, limit, cursor, and include, failing to compensate for the schema's 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 the resource (answers), and clarifies that these are application answers used for qualification and application-completeness analysis. This distinguishes it from similar list_* tools that target other resources, though it could be more explicit about the exact 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 get_answer or list_applications. There is no mention of typical use cases, prerequisites, or situations where another tool would be preferred.

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 merely states 'List' without describing pagination, filtering, return structure, or any side effects. The additional phrase 'Application phases for ATS funnel state' adds minimal context but does not clarify query behavior or output.

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 but under-specified. The first sentence repeats the tool name almost verbatim, and the second sentence adds only a vague contextual phrase. This is not effective conciseness; it lacks substantive information needed for correct invocation.

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, no output schema, and no annotations, the description is wholly inadequate. It fails to explain return values, filtering capabilities, pagination, or how the tool fits into the broader ATS workflow, leaving the agent with almost no guidance 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?

Schema description coverage is only 33% (3 of 9 parameters have descriptions). The tool description adds no parameter semantics, failing to mention how to use pagination, sorting, filters, or the detail_profile option. It does not 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 clearly states the tool lists application_phases, with a brief contextual hint that these are 'Application phases for ATS funnel state.' This distinguishes it from list_applications and get_application_phase by resource name, but it does not elaborate on scope or specific behavior beyond the 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?

No guidance is provided on when to use this tool versus alternatives like list_applications or get_application_phase. There is no mention of expected use cases, prerequisites, or scenarios where this tool would be preferred.

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 applications' and gives no information about pagination, filtering behavior, response projections, or read-only nature. The detail_profile parameter, which toggles output shape, is not mentioned.

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

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

Two short sentences with the core action front-loaded. The second sentence adds purpose context but is somewhat vague; nonetheless, there is no wordiness or redundancy.

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

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

With 9 parameters, no output schema, and no annotations, the description is too minimal to support correct invocation. It lacks essential context about pagination, filtering, response shape, and how applications relate to pipeline analysis.

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 says nothing about any parameters. With schema description coverage at only 33%, the description should compensate by explaining page/limit/cursor, query_json, or detail_profile, 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?

Clear verb+resource ('List applications') with an additional purpose statement identifying candidate/job/phase state and stale pipeline analysis. It distinguishes from get_application and create_application by resource, though it doesn't explicitly contrast with sibling 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?

Usage is implied from the purpose clause ('for candidate/job/phase state and stale pipeline analysis'), but there is no explicit when-to-use or mention of alternatives such as get_application for single records or other list tools for different resources.

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 candidates' and mentions analysis categories. It does not describe pagination, default limits, response shape, authentication requirements, or any side effects. The description is too thin to set accurate expectations.

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

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

The description is very short and front-loaded with the core action. The second sentence adds context but is somewhat jargon-heavy ('stale-candidate, source-quality, owner, and follow-up analysis') and may be unclear without further explanation, though it is not wasteful.

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, yet the description provides no information about pagination, filtering, return values, or common use cases. For a list endpoint with this complexity, the description is insufficiently complete.

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

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

Schema description coverage is only 33%, and the description adds no parameter-specific meaning. Properties like page, sort, limit, cursor, include, and per_page are left entirely unexplained. The schema documents query_json, path_params, and detail_profile, but the description itself does not help with the undocumented parameters.

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

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

The description clearly states the action ('List candidates') and the resource ('candidates'), and adds analytic context by mentioning stale-candidate, source-quality, owner, and follow-up analysis. It does not explicitly distinguish from sibling tools like get_candidate, but the plural 'list' and resource name make the purpose 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?

No guidance is provided on when to use this tool versus alternatives such as get_candidate or list_candidate_sources. The phrase 'Candidates for ... analysis' hints at intended use cases, but there are no explicit conditions, exclusions, or comparisons.

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, and the description only says 'List,' implying a read operation but without details on pagination, filtering, or response format. It fails to disclose any behavioral traits beyond the basic verb.

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 includes a redundant first sentence that merely restates the tool name. The second sentence adds some context, but overall it's not as efficient as it could be.

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

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

With 9 parameters, no output schema, and no annotations, this description is severely incomplete. It omits essential information about pagination, filtering, return values, and the distinction from get_candidate_source.

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. Key parameters like page, sort, limit, cursor, and include are left undocumented in both description and schema, creating 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 'List candidate_sources' with a follow-up context about the resource's use. However, it repeats the tool name and does not explicitly differentiate from sibling tools like get_candidate_source.

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. The mention of 'source-quality and referral-like slicing' hints at a use case but does not clarify selection criteria 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?

No annotations are provided, so the description must disclose behavioral traits. It only says 'List evaluation_forms' and a vague purpose, with no mention of authorization, pagination, filtering, response format, or side effects. This is a significant disclosure gap for a list operation with 9 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 (two sentences), but the second sentence is unclear and doesn't earn its place. The first sentence is redundant with the tool name, yet concise. Overall, it's brief but not effectively structured.

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

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

For a list tool with 9 parameters, no output schema, and no annotations, the description is critically incomplete. It omits pagination, filtering, response structure, and behavioral details, making it inadequate for an agent to invoke correctly 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?

Schema description coverage is only 33%, and the tool description adds no information about parameters. It doesn't mention pagination, filters, sorting, or the detail_profile option, forcing the agent to guess parameter meanings solely from names and the partial schema descriptions.

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

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

The description clearly states the tool's action ('List evaluation_forms') and names a specific resource that distinguishes it from sibling list tools like list_answers or list_feedbacks. However, the second sentence 'Evaluation forms for feedback structure and coverage analysis' is vague and adds little clarity, and there's no explicit differentiation from similar 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 guidance on when to use this tool versus alternatives, no exclusions, and no mention of prerequisites or typical use cases. It simply states the action with no context or recommendations.

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 bears full responsibility. It does not disclose pagination behavior, default sort, response format, or whether associated entities are included. The mention of 'linked to' hints at associations but is vague. This is a significant gap for a list tool with many query 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 extremely concise: two sentences with no wasted words. The first sentence states the action, the second adds relational context. It is perfectly sized for the information it conveys.

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

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

With 9 parameters, no output schema, no annotations, and minimal description, the tool is not adequately specified. The description covers the basic purpose but omits essential operational details such as pagination, filtering options, field projections, and the exact data returned, which are critical 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 only 33% (3 of 9 properties have descriptions), and the tool description adds no parameter information at all. It does not explain the meaning of cursor, include, query_json, detail_profile, or pagination parameters, leaving the agent to guess their usage.

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

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

The description clearly states 'List feedbacks' with a specific verb and resource, and adds context that feedback records are linked to candidates, applications, and phases. This distinguishes it from the singular get_feedback and create_feedback siblings.

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

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

The description implies a list operation but provides no explicit guidance on when to use this tool versus alternatives like get_feedback or list_candidates. The relational context ('linked to candidates, applications, and phases') gives some sense of scope, but there are no exclusions or alternative recommendations.

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 'List hiring_stages' and offers no information about pagination, filtering options, authentication requirements, or the meaning of 'canonical pipeline joins.' The cryptic phrase raises questions rather than clarifying 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 very short (two sentences), which is concise, but the second sentence is unclear and fails to earn its place. The structure front-loads the core action but the added context is confusing rather than helpful.

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 far too minimal. It doesn't explain what a hiring stage is, what 'canonical pipeline joins' means, or what the response contains. This is inadequate for an agent to invoke the tool correctly.

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

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

Schema description coverage is only 33%, and the description adds no parameter-level meaning. It does not explain query_json, detail_profile, or other parameters. The vague 'canonical pipeline joins' reference does not compensate for the lack of parameter documentation.

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

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

The description clearly states the action and resource: 'List hiring_stages.' This is a specific verb+resource pair that distinguishes it from singular get_hiring_stage. However, the appended phrase 'Hiring stages for canonical pipeline joins' is ambiguous and doesn't help differentiate from related list tools like list_application_phases.

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 sibling tools like get_hiring_stage for singular retrieval, nor any exclusions or prerequisites. The description leaves usage context entirely unstated.

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 full burden for behavioral disclosure. It only states that it lists job postings, without mentioning default behavior, pagination, authentication needs, or any side effects. The description gives no insight into how the tool behaves beyond the literal action.

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, which is good for conciseness, but the second sentence earns no place because it is unclear and adds no concrete value. It is not as egregiously under-specified as a single tautological word, but it lacks structure and clarity.

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

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

Given the tool has 9 parameters, nested objects, no output schema, and no annotations, the description is severely incomplete. It does not address key behaviors like pagination, filtering semantics, or the meaning of 'open-role inventory'. The description is insufficient for an agent to use the tool effectively.

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 does little to compensate. The vague mention of 'job status, team, location, and open-role inventory' could relate to filtering, but it does not map these concepts to any of the 9 parameters. Parameters like page, sort, limit, cursor, include, and per_page remain 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 action 'List job_postings' is clear, but the second sentence is vague and confusingly worded. It does not differentiate this list tool from other list tools in the sibling set (e.g., list_applications, 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?

No guidance is provided on when to use this tool versus alternatives like get_job_posting or other list tools. There are no exclusions, prerequisites, or suggested contexts.

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

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

With no annotations provided, the description must carry the behavioral burden. It only says 'List messages' (implied read-only) but does not disclose pagination behavior, response format, side effects, or any safety details. Missing important context for a 9-parameter 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 a single short sentence, which is concise, but the latter half ('ATS messages for activity hygiene and follow-up context') is vague and adds little value. It is under-specified rather than efficiently informative, so a mid-range score is appropriate.

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, this description is severely incomplete. It fails to cover the tool's purpose in depth, its parameterization, or its expected results, leaving significant gaps for an AI 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 only 33% (3 of 9 params have descriptions), yet the description adds zero parameter information. It fails to explain the many pagination and filtering parameters, leaving the agent to rely on names alone. This is inadequate given the low 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 tool lists messages ('List messages') and identifies them as ATS messages, distinguishing it from get_message (singular). However, it doesn't specify what constitutes a message or elaborate on the resource beyond that.

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 only a vague use case ('for activity hygiene and follow-up context') with no explicit guidance on when to use this tool versus alternatives like get_message or other list_* tools. No exclusions or comparison to siblings 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 present, so the description must carry the full burden of behavioral disclosure. It only states 'List questions' and offers no detail on pagination, filtering, read-only guarantees, response shape, or other behavioral traits. The description adds almost no transparency 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 extremely concise with no wasted words, and the core action is front-loaded. However, the brevity is borderline under-specification for a tool with nine parameters, though this is more a completeness issue than a conciseness one.

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, no output schema, and no annotations, the description leaves many gaps. It does not explain what data is returned, how pagination/filtering works, or how the 'application completeness metadata' relates to the parameters, making it incomplete 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% (query_json, path_params, detail_profile have descriptions), leaving most parameters such as page, sort, limit, cursor, include, and per_page unexplained. The description does not compensate by explaining any of these parameters or their intended use, providing no additional semantic value.

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

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

The description identifies the verb 'List' and the resource 'questions', clarifying that these are application questions related to application completeness metadata. It is clear enough to distinguish the tool from answer- or application-focused siblings, though it does not explicitly name alternatives.

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

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

There is no guidance on when to use this tool versus alternatives like list_answers or list_applications. The mention of 'application completeness metadata' hints at a use case, but no explicit when-to-use or when-not-to-use context 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?

With no annotations provided, the description carries the full burden but fails to disclose any behavioral details such as pagination, sorting, read-only guarantees, or return format. The phrase 'disposition hygiene' is cryptic and provides no operational 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?

While extremely short, the description is under-specified rather than concise. The first sentence is redundant with the name, and the second sentence is unclear jargon, so neither 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 9 parameters, no annotations, and no output schema, yet the description is a single line. It fails to explain core behaviors, request/response shape, or usage scenarios, making it completely inadequate for an agent.

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

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

The description addresses none of the 9 parameters. Schema coverage is low (33%), so the description should compensate, but it adds no parameter semantics whatsoever, leaving agents without meaningful guidance for parameters like page, sort, limit, or cursor.

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 restates the tool name as 'List rejection_reasons' and adds a vague phrase 'Rejection reasons for disposition hygiene' that offers no concrete meaning. It does not differentiate from sibling list tools or clarify the resource's role beyond what the name already conveys.

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 get_rejection_reason or other list_* tools. The description only states the action, leaving the agent to infer usage context without any 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, and the description only says 'List', which implies a read-only operation but does not explicitly disclose safety, response format, pagination behavior, or any other operational traits. The description carries the full burden and only minimally meets it.

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, but the first sentence 'List webhook_subscriptions' merely restates the tool name and adds no value. The second sentence provides useful context, yet overall it is too terse and not optimally information-dense.

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 annotations, and no output schema, yet the description does not explain return values, pagination, filtering, or how the parameters work together. This is insufficient for correct invocation without external knowledge.

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 9 parameters and schema description coverage at only 33%, the description provides zero parameter information and does not compensate for undocumented params such as page, sort, limit, cursor, include, and per_page. This leaves the agent with little help beyond raw schema property names.

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

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

The description uses a specific verb 'List' and identifies the resource 'webhook_subscriptions', adding context about Factorial API webhook subscriptions for incremental sync and delivery setup. It is clear enough to distinguish from get/create/update/delete siblings, though it does not specify whether the list is scoped or filtered.

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 get_webhook_subscription or create_webhook_subscription. The phrase 'for incremental sync and delivery setup' implies some context but does not state conditions or exclusions, so usage guidance is largely absent.

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 'Update' and gives no information about destructive potential, confirmation requirements, dry-run behavior, authentication needs, or consequences. This is a significant transparency gap for a mutation tool.

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

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

The description is a single, efficient sentence that is front-loaded with the key action and resource. It earns its place but is minimal, which is acceptable for conciseness if not for completeness.

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 mutating operation with no annotations, no output schema, and a generic parameter schema. The description does not mention the critical confirm/dry_run workflow, required path parameters, or what fields can be updated. It is incomplete for an agent to safely and correctly invoke this 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?

All parameters have descriptions in the schema (100% coverage), so the baseline is 3. However, the schema descriptions are generic across all write operations (e.g., 'JSON request body for documented write operations') and do not explain what specific fields or path parameters apply to updating an application. The description adds no additional parameter context.

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

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

The description states a clear verb ('Update') and resource ('a Factorial ATS application'), making the tool's basic purpose obvious. However, it does not explicitly distinguish itself from sibling tools like update_candidate or update_feedback, relying on the resource name for 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?

There is no guidance on when to use this tool versus alternatives. It does not mention that get_application should be used for reading, nor does it clarify prerequisites or scenarios where updating an application is appropriate. The usage context is only implied by the verb 'Update'.

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

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

With no annotations provided, the description must disclose behavioral traits, but it only repeats the verb 'update'. It fails to mention live-change confirmation (confirm=true), dry-run capability, potential side effects, or return format. This leaves critical behavioral details 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 a single, front-loaded sentence with no wasted words. However, it is so minimal that it borders on under-specification, which is why it does not receive a 5.

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 complex mutation tool with 6 parameters, nested objects, no annotations, and no output schema. A one-sentence description is insufficient to guide an AI agent; it omits required fields, safety mechanics, and examples, making the tool much harder 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 description coverage is 100% with generic explanations for all 6 parameters (confirm, dry_run, body_json, query_json, path_params, headers_json), so the baseline is 3. The description adds no candidate-specific parameter meaning beyond what the schema already provides.

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 ('update') with a clear resource ('candidate') and system ('Factorial ATS'), distinguishing it from sibling update_* tools like update_application or update_feedback. The purpose is 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?

No guidance is given on when to use this tool vs alternatives, nor does it mention the dry_run/confirm workflow that the schema implies. There are no exclusions or references to other tools, so the agent receives 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?

The description omits critical behavioral context such as the need for confirmation for live changes, the availability of dry_run, and any implications of updating a feedback record. With no annotations, the description fails to carry the full transparency burden.

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

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

The description is a single, front-loaded sentence with no wasted words. It is appropriately concise for stating the core purpose.

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 generic mutation wrapper with confirm, dry_run, and generic body/path parameters, but the description offers no context on how to use these. With no output schema or annotations, the agent lacks essential guidance 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?

All 6 parameters have schema descriptions, meeting the high-coverage baseline. However, the description itself adds no parameter-specific meaning, and the schema descriptions are generic templates that don't clarify what body_json or path_params should contain.

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 ('Update') and the resource ('a Factorial ATS feedback record'), making it distinct from siblings like create_feedback, get_feedback, and list_feedbacks.

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, prerequisites, or when to prefer an alternative. It does not explain the write-operation safety flow with confirm/dry_run or mention the generic body/path parameters.

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 says 'Update a Factorial ATS job posting' without mentioning the required confirmation (confirm parameter), dry-run capability (dry_run), potential side effects, or any permissions needed. This is a significant gap for a mutation tool.

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

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

The description is one short sentence, which is concise but overly minimal. It lacks any structure (such as usage context or parameter hints) and doesn't provide enough information beyond the name itself. It is not verbose, but it is under-specified rather than efficiently complete.

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 6 parameters, including dry_run, confirm, and complex nested objects, and no output schema, the description is far from complete. It doesn't explain the update semantics, required identifiers, or any operational constraints, leaving the agent to infer almost everything from the schema alone.

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 covers 100% of parameters with description, so a baseline of 3 applies. The tool description adds no extra meaning beyond the schema's generic parameter descriptions (e.g., body_json, query_json), and it doesn't explain which parameters are relevant for updating a job posting 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 ('Update') and resource ('Factorial ATS job posting'), making the core purpose clear and distinguishable from siblings like create_job_posting or get_job_posting. However, it lacks details on what fields or aspects can be updated, which is a minor gap.

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. With siblings like create_job_posting, get_job_posting, and list_job_postings, the description should at least imply that this is for modifying an existing posting, but it doesn't address prerequisites, exclusions, or comparison to other update 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 must disclose behavior. It only states 'update' which implies mutation, but provides no details about the effects of the update, required permissions, idempotency, or what the response contains. This is a significant gap for a write operation.

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

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

The description is a single, front-loaded sentence with no wasted words. It is concise, though it could arguably include more useful context without becoming bloated, so it doesn't earn a 5.

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 it's a mutation tool with no annotations and no output schema, the description is too sparse. It doesn't explain how to use the parameters (e.g., which fields to update), what the response looks like, or any side effects. This is inadequate for a tool with six parameters.

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?

Since schema description coverage is 100%, all six parameters are already documented with descriptions. The tool description adds no additional parameter semantics; the baseline of 3 is appropriate because the schema carries the full load.

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 has a specific verb 'update' and a specific resource 'Factorial API webhook subscription', clearly distinguishing it from sibling tools like create_webhook_subscription, delete_webhook_subscription, and get_webhook_subscription.

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. It does not mention prerequisites, such as needing an existing subscription ID, nor does it contrast with create or delete operations. The usage context is only implied by the verb 'update'.

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